1 /*
2 * Copyright (c) 2000-2019, NVIDIA CORPORATION. All rights reserved.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *
16 */
17
18 /**
19 \file dump.c
20 \brief dump routines for compiler's internal data structures.
21 This file contains dump routines for the compiler's various internal
22 data structures (e.g., symbol tables, dtype records, etc.).
23 */
24
25 #include "gbldefs.h"
26 #include "global.h"
27 #include "error.h"
28 #include "symtab.h"
29 #include "dtypeutl.h"
30 #include "ast.h"
31 #include "nme.h"
32 #include "optimize.h"
33 #include "dpm_out.h"
34 #include "hlvect.h"
35 #include "soc.h"
36 #include "fih.h"
37 #include "symutl.h"
38
39 #if DEBUG
40 static FILE *dfile;
41 static int linelen = 0;
42 static char BUF[900];
43
44 static int longlines = 1;
45
46 static void
putit()47 putit()
48 {
49 int l = strlen(BUF);
50 if (linelen + l >= 78 && !longlines) {
51 fprintf(dfile, "\n%s", BUF);
52 linelen = l;
53 } else if (linelen > 0) {
54 fprintf(dfile, " %s", BUF);
55 linelen += l + 2;
56 } else {
57 fprintf(dfile, "%s", BUF);
58 linelen = l;
59 }
60 } /* putit */
61
62 static void
appendit()63 appendit()
64 {
65 int l = strlen(BUF);
66 fprintf(dfile, "%s", BUF);
67 linelen += l;
68 } /* appendit */
69
70 static void
putline()71 putline()
72 {
73 if (linelen)
74 fprintf(dfile, "\n");
75 linelen = 0;
76 } /* putline */
77
78 static void
putint(char * s,int d)79 putint(char *s, int d)
80 {
81 sprintf(BUF, "%s:%d", s, d);
82 putit();
83 } /* putint */
84
85 static void
putintstar(char * s,int d,int star,char * starstring)86 putintstar(char *s, int d, int star, char *starstring)
87 {
88 if (star) {
89 sprintf(BUF, "%s:%d%s", s, d, starstring);
90 } else {
91 sprintf(BUF, "%s:%d", s, d);
92 }
93 putit();
94 } /* putintstar */
95
96 static void
put2int(char * s,int d1,int d2)97 put2int(char *s, int d1, int d2)
98 {
99 sprintf(BUF, "%s(%d:%d)", s, d1, d2);
100 putit();
101 } /* put2int */
102
103 static void
putint1(int d)104 putint1(int d)
105 {
106 sprintf(BUF, "%d", d);
107 putit();
108 } /* putint1 */
109
110 static void
appendint1(int d)111 appendint1(int d)
112 {
113 sprintf(BUF, "%d", d);
114 appendit();
115 } /* appendint1 */
116
117 static void
put2int1(int d1,int d2)118 put2int1(int d1, int d2)
119 {
120 sprintf(BUF, "%d:%d", d1, d2);
121 putit();
122 } /* put2int1 */
123
124 static void
putint1star(int d,int star,char * starstring)125 putint1star(int d, int star, char *starstring)
126 {
127 if (star) {
128 sprintf(BUF, "%d%s", d, starstring);
129 } else {
130 sprintf(BUF, "%d", d);
131 }
132 putit();
133 } /* putint1star */
134
135 static void
putnzint(char * s,int d)136 putnzint(char *s, int d)
137 {
138 if (d != 0) {
139 sprintf(BUF, "%s:%d", s, d);
140 putit();
141 }
142 } /* putnzint */
143
144 static void
putnzhex(char * s,int d)145 putnzhex(char *s, int d)
146 {
147 if (d != 0) {
148 sprintf(BUF, "%s:0x%x", s, d);
149 putit();
150 }
151 } /* putnzhex */
152
153 static void
putnzbits(char * s,int d)154 putnzbits(char *s, int d)
155 {
156 if (d != 0) {
157 char *b;
158 int any = 0;
159 sprintf(BUF, "%s:", s);
160 b = BUF + strlen(BUF);
161 while (d) {
162 if (d & 0x8000000) {
163 *b = '1';
164 ++b;
165 any = 1;
166 } else if (any) {
167 *b = '0';
168 ++b;
169 }
170 d = d << 1;
171 }
172 *b = '\0';
173 putit();
174 }
175 } /* putnzbits */
176
177 static void
putcharacter(char * s,char c)178 putcharacter(char *s, char c)
179 {
180 sprintf(BUF, "%s:%c", s, c);
181 putit();
182 } /* putchar */
183
184 static void
putedge(int d1,int d2)185 putedge(int d1, int d2)
186 {
187 sprintf(BUF, "%d-->%d", d1, d2);
188 putit();
189 } /* putedge */
190
191 static void
putsym(char * s,int sptr)192 putsym(char *s, int sptr)
193 {
194 if (sptr == NOSYM) {
195 sprintf(BUF, "%s:%d=%s", s, sptr, "NOSYM");
196 } else if (sptr > 0 && sptr < stb.stg_avail) {
197 sprintf(BUF, "%s:%d=%s", s, sptr, SYMNAME(sptr));
198 } else {
199 sprintf(BUF, "%s:%d", s, sptr);
200 }
201 putit();
202 } /* putsym */
203
204 static void
putsym1(int sptr)205 putsym1(int sptr)
206 {
207 if (sptr == NOSYM) {
208 sprintf(BUF, "%d=%s", sptr, "NOSYM");
209 } else if (sptr > 0 && sptr < stb.stg_avail) {
210 sprintf(BUF, "%d=%s", sptr, SYMNAME(sptr));
211 } else {
212 sprintf(BUF, "%d", sptr);
213 }
214 putit();
215 } /* putsym1 */
216
217 static void
putintsym1(int d,int sptr)218 putintsym1(int d, int sptr)
219 {
220 if (sptr == NOSYM) {
221 sprintf(BUF, "%d:%d=%s", d, sptr, "NOSYM");
222 } else if (sptr > 0 && sptr < stb.stg_avail) {
223 sprintf(BUF, "%d:%d=%s", d, sptr, SYMNAME(sptr));
224 } else {
225 sprintf(BUF, "%d:%d", d, sptr);
226 }
227 putit();
228 } /* putintsym1 */
229
230 static void
putsymilist(int symi)231 putsymilist(int symi)
232 {
233 for (; symi; symi = SYMI_NEXT(symi)) {
234 putsym1(SYMI_SPTR(symi));
235 }
236 } /* putsymilist */
237
238 void
dumpsymi(int symi)239 dumpsymi(int symi)
240 {
241 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
242 if (symi <= 0 || symi >= aux.symi_avl) {
243 fprintf(dfile, "\nsymi %d out of %d\n", symi, aux.symi_avl);
244 return;
245 }
246 putint("symi", symi);
247 putsymilist(symi);
248 putline();
249 } /* dumpsymi */
250
251 static void
putnsym(char * s,int sptr)252 putnsym(char *s, int sptr)
253 {
254 if (sptr == NOSYM) {
255 sprintf(BUF, "%s:%d=%s", s, sptr, "NOSYM");
256 putit();
257 } else if (sptr > 0 && sptr < stb.stg_avail) {
258 if (STYPEG(sptr) == ST_CONST) {
259 if (DTY(DTYPEG(sptr)) == TY_CHAR) {
260 sprintf(BUF, "%s:%d=%s", s, sptr, stb.n_base + CONVAL1G(sptr));
261 } else {
262 sprintf(BUF, "%s:%d", s, sptr);
263 }
264 } else {
265 sprintf(BUF, "%s:%d=%s", s, sptr, SYMNAME(sptr));
266 }
267 putit();
268 } else {
269 sprintf(BUF, "%s:%d", s, sptr);
270 putit();
271 }
272 } /* putnsym */
273
274 static void
putstring(char * s,char * t)275 putstring(char *s, char *t)
276 {
277 sprintf(BUF, "%s:%s", s, t);
278 putit();
279 } /* putstring */
280
281 static void
putstring1(char * t)282 putstring1(char *t)
283 {
284 sprintf(BUF, "%s", t);
285 putit();
286 } /* putstring1 */
287
288 static void
appendstring1(char * t)289 appendstring1(char *t)
290 {
291 sprintf(BUF, "%s", t);
292 appendit();
293 } /* appendstring1 */
294
295 static void
putsc(char * s,int sc)296 putsc(char *s, int sc)
297 {
298 if (sc >= 0 && sc <= SC_MAX) {
299 sprintf(BUF, "%s:%d=%s", s, sc, stb.scnames[sc] + 3);
300 } else {
301 sprintf(BUF, "%s:%d", s, sc);
302 }
303 putit();
304 } /* putsc */
305
306 static void
putstype(char * s,int stype)307 putstype(char *s, int stype)
308 {
309 if (stype >= 0 && stype <= ST_MAX) {
310 sprintf(BUF, "%s:%d=%s", s, stype, stb.stypes[stype]);
311 } else {
312 sprintf(BUF, "%s:%d", s, stype);
313 }
314 putit();
315 } /* putstype */
316
317 static void
putstype1(int stype)318 putstype1(int stype)
319 {
320 if (stype >= 0 && stype <= ST_MAX) {
321 sprintf(BUF, "%s", stb.stypes[stype]);
322 } else {
323 sprintf(BUF, "stype=%d", stype);
324 }
325 appendit();
326 } /* putstype1 */
327
328 #ifdef CUDAG
329 static void
putcuda(char * s,int cu)330 putcuda(char *s, int cu)
331 {
332 if (cu) {
333 strcpy(BUF, s);
334 strcat(BUF, ":");
335 if (cu & CUDA_HOST) {
336 strcat(BUF, "host");
337 cu &= ~CUDA_HOST;
338 if (cu)
339 strcat(BUF, "+");
340 }
341 if (cu & CUDA_GRID) {
342 strcat(BUF, "grid");
343 cu &= ~CUDA_GRID;
344 if (cu)
345 strcat(BUF, "+");
346 }
347 if (cu & CUDA_DEVICE) {
348 strcat(BUF, "device");
349 cu &= ~CUDA_DEVICE;
350 if (cu)
351 strcat(BUF, "+");
352 }
353 if (cu & CUDA_GLOBAL) {
354 strcat(BUF, "global");
355 cu &= ~CUDA_GLOBAL;
356 if (cu)
357 strcat(BUF, "+");
358 }
359 if (cu & CUDA_BUILTIN) {
360 strcat(BUF, "builtin");
361 cu &= ~CUDA_BUILTIN;
362 if (cu)
363 strcat(BUF, "+");
364 }
365 putit();
366 }
367 } /* putcuda */
368 #endif
369
370 static void
putintent(char * s,int intent)371 putintent(char *s, int intent)
372 {
373 switch (intent) {
374 case 0:
375 break;
376 case 1:
377 sprintf(BUF, "%s:in", s);
378 putit();
379 break;
380 case 2:
381 sprintf(BUF, "%s:out", s);
382 putit();
383 break;
384 case 3:
385 sprintf(BUF, "%s:inout", s);
386 putit();
387 break;
388 default:
389 sprintf(BUF, "%s:%d", s, intent);
390 putit();
391 break;
392 }
393 } /* putintent */
394
395 static void
putinkind(char * s,int k)396 putinkind(char *s, int k)
397 {
398 switch (k) {
399 case IK_ELEMENTAL:
400 putstring(s, "elemental");
401 break;
402 case IK_INQUIRY:
403 putstring(s, "inquiry");
404 break;
405 case IK_TRANSFORM:
406 putstring(s, "transform");
407 break;
408 case IK_SUBROUTINE:
409 putstring(s, "subroutine");
410 break;
411 default:
412 putint(s, k);
413 break;
414 }
415 } /* putinkind */
416
417 static void
put_inkwd(char * s,int k)418 put_inkwd(char *s, int k)
419 {
420 if (k) {
421 putstring(s, intrinsic_kwd[k]);
422 }
423 } /* put_inkwd */
424
425 static void
putnname(char * s,int off)426 putnname(char *s, int off)
427 {
428 if (off) {
429 putstring(s, stb.n_base + off);
430 }
431 } /* putnname */
432
433 static void
putdtype(char * s,int d)434 putdtype(char *s, int d)
435 {
436 if (d) {
437 char typebuff[4096];
438 getdtype(d, typebuff);
439 sprintf(BUF, "%s:%d:%s", s, d, typebuff);
440 putit();
441 }
442 } /* putdtype */
443
444 static void
putdty(char * s,int dty)445 putdty(char *s, int dty)
446 {
447 if (dty < 0 || dty > TY_MAX || stb.tynames[dty] == NULL) {
448 sprintf(BUF, "%s:<%d>", s, dty);
449 } else {
450 sprintf(BUF, "%s:%s", s, stb.tynames[dty]);
451 }
452 putit();
453 } /* putdty */
454
455 static void
putparam(int dpdsc,int paramct)456 putparam(int dpdsc, int paramct)
457 {
458 if (paramct == 0)
459 return;
460 putline();
461 putstring1("Parameters:");
462 for (; dpdsc && paramct; ++dpdsc, --paramct) {
463 int sptr = aux.dpdsc_base[dpdsc];
464 if (sptr == 0) {
465 putstring1("*");
466 } else {
467 putsym1(sptr);
468 }
469 }
470 } /* putparam */
471
472 void
putsymlk(char * name,int list)473 putsymlk(char *name, int list)
474 {
475 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
476 if (list <= NOSYM)
477 return;
478 putline();
479 putstring1(name);
480 for (; list > NOSYM; list = SYMLKG(list)) {
481 putsym1(list);
482 }
483 } /* putsymlk */
484
485 void
putslnk1(int list)486 putslnk1(int list)
487 {
488 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
489 if (list <= NOSYM)
490 return;
491 for (; list > NOSYM; list = SLNKG(list)) {
492 putsym1(list);
493 }
494 } /* putslnk1 */
495
496 void
dumplists()497 dumplists()
498 {
499 int stype;
500 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
501 for (stype = 0; stype <= ST_MAX; ++stype) {
502 if (aux.list[stype] > NOSYM) {
503 putstring1("aux.list[");
504 putstype1(stype);
505 appendstring1("] =");
506 putslnk1(aux.list[stype]);
507 putline();
508 }
509 }
510 } /* dumplists */
511
512 static void
putsymflags()513 putsymflags()
514 {
515 #undef GETBIT
516 #define GETBIT(flg, f) flg = (flg << 1) | stb.stg_base->f
517 int flag1, flag2;
518 flag1 = 0;
519 GETBIT(flag1, f31);
520 GETBIT(flag1, f30);
521 GETBIT(flag1, f29);
522 GETBIT(flag1, f28);
523 GETBIT(flag1, f27);
524 GETBIT(flag1, f26);
525 GETBIT(flag1, f25);
526 GETBIT(flag1, f24);
527 GETBIT(flag1, f23);
528 GETBIT(flag1, f22);
529 GETBIT(flag1, f21);
530 GETBIT(flag1, f20);
531 GETBIT(flag1, f19);
532 GETBIT(flag1, f18);
533 GETBIT(flag1, f17);
534 GETBIT(flag1, f16);
535 GETBIT(flag1, f15);
536 GETBIT(flag1, f14);
537 GETBIT(flag1, f13);
538 GETBIT(flag1, f12);
539 GETBIT(flag1, f11);
540 GETBIT(flag1, f10);
541 GETBIT(flag1, f9);
542 GETBIT(flag1, f8);
543 GETBIT(flag1, f7);
544 GETBIT(flag1, f6);
545 GETBIT(flag1, f5);
546 GETBIT(flag1, f4);
547 GETBIT(flag1, f3);
548 GETBIT(flag1, f2);
549 GETBIT(flag1, f1);
550 flag2 = 0;
551 GETBIT(flag2, f64);
552 GETBIT(flag2, f63);
553 GETBIT(flag2, f62);
554 GETBIT(flag2, f61);
555 GETBIT(flag2, f60);
556 GETBIT(flag2, f59);
557 GETBIT(flag2, f58);
558 GETBIT(flag2, f57);
559 GETBIT(flag2, f56);
560 GETBIT(flag2, f55);
561 GETBIT(flag2, f54);
562 GETBIT(flag2, f53);
563 GETBIT(flag2, f52);
564 GETBIT(flag2, f51);
565 GETBIT(flag2, f50);
566 GETBIT(flag2, f49);
567 GETBIT(flag2, f48);
568 GETBIT(flag2, f47);
569 GETBIT(flag2, f46);
570 GETBIT(flag2, f45);
571 GETBIT(flag2, f44);
572 GETBIT(flag2, f43);
573 GETBIT(flag2, f42);
574 GETBIT(flag2, f41);
575 GETBIT(flag2, f40);
576 GETBIT(flag2, f39);
577 GETBIT(flag2, f38);
578 GETBIT(flag2, f37);
579 GETBIT(flag2, f36);
580 GETBIT(flag2, f35);
581 GETBIT(flag2, f34);
582 GETBIT(flag2, f33);
583 GETBIT(flag2, f32);
584 #undef GETBIT
585 if (flag1 || flag2) {
586 sprintf(BUF, "flags=%8.8x %8.8x ", flag1, flag2);
587 putit();
588 }
589 } /* putsymflags */
590
591 static void
putbit(char * s,int b)592 putbit(char *s, int b)
593 {
594 /* single space between flags */
595 if (b) {
596 int l = strlen(s);
597 if (linelen + l >= 78 && !longlines) {
598 fprintf(dfile, "\n%s", s);
599 linelen = l;
600 } else if (linelen > 0) {
601 fprintf(dfile, " %s", s);
602 linelen += l + 1;
603 } else {
604 fprintf(dfile, "%s", s);
605 linelen = l;
606 }
607 }
608 } /* putbit */
609
610 static void
check(char * s,int v)611 check(char *s, int v)
612 {
613 if (v) {
614 fprintf(dfile, "*** %s: %d 0x%x\n", s, v, v);
615 }
616 } /* check */
617
618 static void
putmap(char * s,int m)619 putmap(char *s, int m)
620 {
621 /* single space between flags */
622 switch (m) {
623 case PRESCRIPTIVE:
624 putstring(s, "prescriptive");
625 break;
626 case DESCRIPTIVE:
627 putstring(s, "descriptive");
628 break;
629 case TRANSCRIPTIVE:
630 putstring(s, "transcriptive");
631 break;
632 default:
633 sprintf(BUF, "%s:(%d)", s, m);
634 putit();
635 }
636 } /* putmap */
637
638 void
putasttype(char * s,int opc)639 putasttype(char *s, int opc)
640 {
641 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
642 if (opc < 0 || opc > AST_MAX) {
643 sprintf(BUF, "%s:%d", s, opc);
644 } else {
645 sprintf(BUF, "%s:%d:%s", s, opc, astb.atypes[opc]);
646 }
647 putit();
648 } /* putasttype */
649
650 static void
putast(char * s,int a)651 putast(char *s, int a)
652 {
653 if (a == 0)
654 return;
655 if (a < 0 || a >= astb.stg_avail) {
656 if (s && *s) {
657 sprintf(BUF, "(%s=%d)", s, a);
658 } else {
659 sprintf(BUF, "(%d)", a);
660 }
661 putit();
662 return;
663 }
664 if (linelen + 2 >= 78 && !longlines) {
665 fprintf(dfile, "\n");
666 linelen = 1;
667 } else if (linelen > 0) {
668 fprintf(dfile, " ");
669 linelen += 1;
670 }
671 if (s && *s) {
672 sprintf(BUF, "%s:%d=", s, a);
673 putit();
674 }
675 printast(a);
676 } /* putast */
677
678 static void
putval(char * s,int val,char * values[],int sizeofvalues)679 putval(char *s, int val, char *values[], int sizeofvalues)
680 {
681 if (val < 0 || val >= sizeofvalues) {
682 sprintf(BUF, "%s:%d", s, val);
683 putit();
684 } else {
685 putstring(s, values[val]);
686 }
687 } /* putval */
688
689 #define SIZEOF(array) (sizeof(array) / sizeof(char *))
690
691 static void
putoptype(char * s,int optype)692 putoptype(char *s, int optype)
693 {
694 static char *opt[] = {"neg", "add", "sub", "mul", "div", "xtoi",
695 "xtox", "cmp", "aif", "ld", "st", "func",
696 "con", "cat", "log", "leqv", "lneqv", "lor",
697 "land", "eq", "ge", "gt", "le", "lt",
698 "ne", "lnot", "loc", "ref", "val", "scand",
699 "scalar", "array", "derived"};
700 putval(s, optype, opt, SIZEOF(opt));
701 } /* putoptype */
702
703 void
dastli(int astli)704 dastli(int astli)
705 {
706 int a;
707 for (a = astli; a; a = ASTLI_NEXT(a)) {
708 if (a <= 0 || a > astb.astli.stg_avail) {
709 sprintf(BUF, "badastli:%d", a);
710 putit();
711 } else {
712 sprintf(BUF, "%d:%d:%d:0x%4.4x", a, ASTLI_SPTR(a), ASTLI_TRIPLE(a),
713 ASTLI_FLAGS(a));
714 }
715 }
716 } /* dastli */
717
718 void
dast(int astx)719 dast(int astx)
720 {
721 int atype, dtype, shape, asdx, j, argcnt, args, astli;
722 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
723 if (astx < 0 || astx >= astb.stg_avail) {
724 fprintf(dfile, "\nast %d out of range [0:%d)\n", astx, astb.stg_avail);
725 return;
726 }
727 putint("ast", astx);
728
729 BCOPY(astb.stg_base, astb.stg_base + astx, AST, 1);
730
731 atype = A_TYPEG(0);
732 putasttype("atype", atype);
733 putint("hashlk/std", A_HSHLKG(0));
734 putint("shape", A_SHAPEG(0));
735
736 switch (atype) {
737 case A_ID:
738 case A_CNST:
739 case A_BINOP:
740 case A_UNOP:
741 case A_CMPLXC:
742 case A_CONV:
743 case A_PAREN:
744 case A_MEM:
745 case A_SUBSCR:
746 case A_SUBSTR:
747 case A_FUNC:
748 case A_INTR:
749 case A_INIT:
750 case A_ASN:
751 dtype = A_DTYPEG(0);
752 putdtype("dtype", dtype);
753 break;
754 }
755 switch (atype) {
756 case A_ID:
757 case A_BINOP:
758 case A_UNOP:
759 case A_CMPLXC:
760 case A_CONV:
761 case A_PAREN:
762 case A_SUBSTR:
763 case A_FUNC:
764 case A_INTR:
765 putnzint("alias", A_ALIASG(0));
766 A_ALIASP(0, 0);
767 putbit("callfg", A_CALLFGG(0));
768 A_CALLFGP(0, 0);
769 break;
770 }
771 putnzint("opt1", A_OPT1G(0));
772 A_OPT1P(0, 0);
773 putnzint("opt2", A_OPT2G(0));
774 A_OPT2P(0, 0);
775 switch (atype) {
776 case A_NULL:
777 break;
778 case A_ID:
779 case A_LABEL:
780 case A_ENTRY:
781 putsym("sptr", A_SPTRG(0));
782 A_SPTRP(0, 0);
783 break;
784 case A_CNST:
785 putsym("sptr", A_SPTRG(0));
786 A_SPTRP(0, 0);
787 break;
788 case A_BINOP:
789 putoptype("optype", A_OPTYPEG(0));
790 A_OPTYPEP(0, 0);
791 putint("lop", A_LOPG(0));
792 A_LOPP(0, 0);
793 putint("rop", A_ROPG(astx));
794 A_LOPP(0, 0);
795 break;
796 case A_UNOP:
797 putoptype("optype", A_OPTYPEG(astx));
798 A_OPTYPEP(0, 0);
799 putint("lop", A_LOPG(astx));
800 A_LOPP(0, 0);
801 putbit("ptr0", astx == astb.ptr0);
802 putbit("ptr1", astx == astb.ptr1);
803 putbit("ptr0c", astx == astb.ptr0c);
804 break;
805 case A_CMPLXC:
806 putint("lop", A_LOPG(0));
807 A_LOPP(0, 0);
808 putint("rop", A_ROPG(astx));
809 A_LOPP(0, 0);
810 break;
811 case A_CONV:
812 putint("lop", A_LOPG(0));
813 A_LOPP(0, 0);
814 break;
815 case A_PAREN:
816 putint("lop", A_LOPG(0));
817 A_LOPP(0, 0);
818 break;
819 case A_MEM:
820 putint("parent", A_PARENTG(0));
821 A_PARENTP(0, 0);
822 putint("mem", A_MEMG(0));
823 A_MEMP(0, 0);
824 putnzint("alias", A_ALIASG(0));
825 A_ALIASP(0, 0);
826 break;
827 case A_SUBSCR:
828 putint("lop", A_LOPG(0));
829 A_LOPP(0, 0);
830 asdx = A_ASDG(0);
831 putint("asd", A_ASDG(0));
832 A_ASDP(0, 0);
833 putnzint("alias", A_ALIASG(0));
834 A_ALIASP(0, 0);
835 for (j = 0; j < ASD_NDIM(asdx); ++j) {
836 put2int1(j, ASD_SUBS(asdx, j));
837 }
838 break;
839 case A_SUBSTR:
840 putint("lop", A_LOPG(0));
841 A_LOPP(0, 0);
842 putint("left", A_LEFTG(0));
843 A_LEFTP(0, 0);
844 putint("right", A_RIGHTG(0));
845 A_RIGHTP(0, 0);
846 break;
847 case A_TRIPLE:
848 putint("lbd", A_LBDG(0));
849 A_LBDP(0, 0);
850 putint("upbd", A_UPBDG(0));
851 A_UPBDP(0, 0);
852 putint("stride", A_STRIDEG(0));
853 A_STRIDEP(0, 0);
854 break;
855 case A_FUNC:
856 case A_INTR:
857 case A_CALL:
858 case A_ICALL:
859 putint("lop", A_LOPG(0));
860 A_LOPP(0, 0);
861 argcnt = A_ARGCNTG(0);
862 putint("argcnt", A_ARGCNTG(0));
863 A_ARGCNTP(0, 0);
864 args = A_ARGSG(0);
865 putint("args", A_ARGSG(0));
866 A_ARGSP(0, 0);
867 if (atype == A_INTR || atype == A_ICALL || atype == A_INIT) {
868 putoptype("optype", A_OPTYPEG(0));
869 A_OPTYPEP(0, 0);
870 }
871 for (j = 0; j < argcnt; ++j) {
872 put2int1(j, ARGT_ARG(args, j));
873 }
874 break;
875 case A_ASN:
876 case A_ASNGOTO:
877 putint("dest", A_DESTG(0));
878 A_DESTP(0, 0);
879 putint("src", A_SRCG(0));
880 A_SRCP(0, 0);
881 break;
882 case A_IF:
883 putint("ifexpr", A_IFEXPRG(0));
884 A_IFEXPRP(0, 0);
885 putint("ifstmt", A_IFSTMTG(0));
886 A_IFSTMTP(0, 0);
887 break;
888 case A_IFTHEN:
889 putint("ifexpr", A_IFEXPRG(0));
890 A_IFEXPRP(0, 0);
891 break;
892 case A_ELSE:
893 break;
894 case A_ELSEIF:
895 putint("ifexpr", A_IFEXPRG(0));
896 A_IFEXPRP(0, 0);
897 break;
898 case A_ENDIF:
899 break;
900 case A_AIF:
901 putint("ifexpr", A_IFEXPRG(0));
902 A_IFEXPRP(0, 0);
903 putint("l1g", A_L1G(0));
904 A_L1P(0, 0);
905 putint("l2g", A_L2G(0));
906 A_L2P(0, 0);
907 putint("l3g", A_L3G(0));
908 A_L3P(0, 0);
909 break;
910 case A_GOTO:
911 putint("l1g", A_L1G(0));
912 A_L1P(0, 0);
913 break;
914 case A_CGOTO:
915 case A_AGOTO:
916 putint("lop", A_LOPG(0));
917 A_LOPP(0, 0);
918 astli = A_LISTG(0);
919 putint("list", A_LISTG(0));
920 A_LISTP(0, 0);
921 dastli(astli);
922 break;
923 case A_DO:
924 putint("dolab", A_DOLABG(0));
925 A_DOLABP(0, 0);
926 putint("dovar", A_DOVARG(0));
927 A_DOVARP(0, 0);
928 putint("m1g", A_M1G(0));
929 A_M1P(0, 0);
930 putint("m2g", A_M2G(0));
931 A_M2P(0, 0);
932 putint("m3g", A_M3G(0));
933 A_M3P(0, 0);
934 putint("m4g", A_M4G(0));
935 A_M4P(0, 0);
936 break;
937 case A_DOWHILE:
938 putint("dolab", A_DOLABG(0));
939 A_DOLABP(0, 0);
940 putint("ifexpr", A_IFEXPRG(0));
941 A_IFEXPRP(0, 0);
942 break;
943 case A_ENDDO:
944 case A_CONTINUE:
945 case A_END:
946 break;
947 case A_STOP:
948 case A_PAUSE:
949 case A_RETURN:
950 putint("lop", A_LOPG(0));
951 A_LOPP(0, 0);
952 break;
953 case A_ALLOC:
954 putint("tok", A_TKNG(0));
955 A_TKNP(0, 0);
956 putint("lop", A_LOPG(0));
957 A_LOPP(0, 0);
958 putint("src", A_SRCG(0));
959 A_SRCP(0, 0);
960 putint("dest", A_DESTG(0));
961 A_DESTP(0, 0);
962 putint("m3", A_M3G(0));
963 A_M3P(0, 0);
964 putint("start", A_STARTG(0));
965 A_STARTP(0, 0);
966 putint("dtype", A_DTYPEG(0));
967 A_DTYPEP(0, 0);
968 putint("devsrc", A_DEVSRCG(0));
969 A_DEVSRCP(0, 0);
970 putint("align", A_ALIGNG(0));
971 A_ALIGNP(0, 0);
972 break;
973 case A_WHERE:
974 putint("ifexpr", A_IFEXPRG(0));
975 A_IFEXPRP(0, 0);
976 putint("ifstmt", A_IFSTMTG(0));
977 A_IFSTMTP(0, 0);
978 break;
979 case A_FORALL:
980 putint("ifexpr", A_IFEXPRG(0));
981 A_IFEXPRP(0, 0);
982 putint("ifstmt", A_IFSTMTG(0));
983 A_IFSTMTP(0, 0);
984 putint("src", A_SRCG(0));
985 A_SRCP(0, 0);
986 astli = A_LISTG(0);
987 putint("list", A_LISTG(0));
988 A_LISTP(0, 0);
989 dastli(astli);
990 break;
991 case A_ELSEWHERE:
992 case A_ENDWHERE:
993 case A_ENDFORALL:
994 case A_ELSEFORALL:
995 break;
996 case A_REDIM:
997 putint("src", A_SRCG(0));
998 A_SRCP(0, 0);
999 break;
1000 case A_COMMENT:
1001 putint("lop", A_LOPG(0));
1002 A_LOPP(0, 0);
1003 break;
1004 case A_INIT:
1005 putint("left", A_LEFTG(0));
1006 A_LEFTP(0, 0);
1007 putint("right", A_RIGHTG(0));
1008 A_RIGHTP(0, 0);
1009 putsym("sptr", A_SPTRG(0));
1010 A_SPTRP(0, 0);
1011 putoptype("optype", A_OPTYPEG(0));
1012 A_OPTYPEP(0, 0);
1013 break;
1014 case A_COMSTR:
1015 putint("comptr", A_COMPTRG(0));
1016 A_COMPTRP(0, 0);
1017 putstring1(COMSTR(astx));
1018 break;
1019 case A_REALIGN:
1020 putint("alndsc", A_DTYPEG(0));
1021 A_DTYPEP(0, 0);
1022 putint("lop", A_LOPG(0));
1023 A_LOPP(0, 0);
1024 break;
1025 case A_REDISTRIBUTE:
1026 putint("dstdsc", A_DTYPEG(0));
1027 A_DTYPEP(0, 0);
1028 putint("lop", A_LOPG(0));
1029 A_LOPP(0, 0);
1030 break;
1031 case A_HLOCALIZEBNDS:
1032 putint("lop", A_LOPG(0));
1033 A_LOPP(0, 0);
1034 putint("itriple", A_ITRIPLEG(0));
1035 A_ITRIPLEP(0, 0);
1036 putint("otriple", A_OTRIPLEG(0));
1037 A_OTRIPLEP(0, 0);
1038 putint("dim", A_DIMG(0));
1039 A_DIMP(0, 0);
1040 break;
1041 case A_HALLOBNDS:
1042 putint("lop", A_LOPG(0));
1043 A_LOPP(0, 0);
1044 break;
1045 case A_HCYCLICLP:
1046 putint("lop", A_LOPG(0));
1047 A_LOPP(0, 0);
1048 putint("itriple", A_ITRIPLEG(0));
1049 A_ITRIPLEP(0, 0);
1050 putint("otriple", A_OTRIPLEG(0));
1051 A_OTRIPLEP(0, 0);
1052 putint("otriple1", A_OTRIPLE1G(0));
1053 A_OTRIPLE1P(0, 0);
1054 putint("dim", A_DIMG(0));
1055 A_DIMP(0, 0);
1056 break;
1057 case A_HOFFSET:
1058 putint("dest", A_DESTG(0));
1059 A_DESTP(0, 0);
1060 putint("lop", A_LOPG(0));
1061 A_LOPP(0, 0);
1062 putint("rop", A_ROPG(astx));
1063 A_LOPP(0, 0);
1064 break;
1065 case A_HSECT:
1066 putint("lop", A_LOPG(0));
1067 A_LOPP(0, 0);
1068 putint("bvect", A_BVECTG(0));
1069 A_BVECTP(0, 0);
1070 break;
1071 case A_HCOPYSECT:
1072 putint("dest", A_DESTG(0));
1073 A_DESTP(0, 0);
1074 putint("src", A_SRCG(0));
1075 A_SRCP(0, 0);
1076 putint("ddesc", A_DDESCG(0));
1077 A_DDESCP(0, 0);
1078 putint("sdesc", A_SDESCG(0));
1079 A_SDESCP(0, 0);
1080 break;
1081 case A_HPERMUTESECT:
1082 putint("dest", A_DESTG(0));
1083 A_DESTP(0, 0);
1084 putint("src", A_SRCG(0));
1085 A_SRCP(0, 0);
1086 putint("ddesc", A_DDESCG(0));
1087 A_DDESCP(0, 0);
1088 putint("sdesc", A_SDESCG(0));
1089 A_SDESCP(0, 0);
1090 putint("bvect", A_BVECTG(0));
1091 A_BVECTP(0, 0);
1092 break;
1093 case A_HOVLPSHIFT:
1094 putint("src", A_SRCG(0));
1095 A_SRCP(0, 0);
1096 putint("sdesc", A_SDESCG(0));
1097 A_SDESCP(0, 0);
1098 break;
1099 case A_HGETSCLR:
1100 putint("dest", A_DESTG(0));
1101 A_DESTP(0, 0);
1102 putint("src", A_SRCG(0));
1103 A_SRCP(0, 0);
1104 putnzint("lop", A_LOPG(0));
1105 A_LOPP(0, 0);
1106 break;
1107 case A_HGATHER:
1108 case A_HSCATTER:
1109 putint("vsub", A_VSUBG(0));
1110 A_VSUBP(0, 0);
1111 putint("dest", A_DESTG(0));
1112 A_DESTP(0, 0);
1113 putint("src", A_SRCG(0));
1114 A_SRCP(0, 0);
1115 putint("ddesc", A_DDESCG(0));
1116 A_DDESCP(0, 0);
1117 putint("mdesc", A_MDESCG(0));
1118 A_MDESCP(0, 0);
1119 putint("sdesc", A_SDESCG(0));
1120 A_SDESCP(0, 0);
1121 putint("bvect", A_BVECTG(0));
1122 A_BVECTP(0, 0);
1123 break;
1124 case A_HCSTART:
1125 putnzint("lop", A_LOPG(0));
1126 A_LOPP(0, 0);
1127 putint("dest", A_DESTG(0));
1128 A_DESTP(0, 0);
1129 putint("src", A_SRCG(0));
1130 A_SRCP(0, 0);
1131 break;
1132 case A_HCFINISH:
1133 case A_HCFREE:
1134 putnzint("lop", A_LOPG(0));
1135 A_LOPP(0, 0);
1136 break;
1137 case A_MASTER:
1138 putnzint("lop", A_LOPG(0));
1139 A_LOPP(0, 0);
1140 break;
1141 case A_ENDMASTER:
1142 putnzint("lop", A_LOPG(0));
1143 A_LOPP(0, 0);
1144 argcnt = A_ARGCNTG(0);
1145 putint("argcnt", A_ARGCNTG(0));
1146 A_ARGCNTP(0, 0);
1147 args = A_ARGSG(0);
1148 putint("args", A_ARGSG(0));
1149 A_ARGSP(0, 0);
1150 for (j = 0; j < argcnt; ++j) {
1151 put2int1(j, ARGT_ARG(args, j));
1152 }
1153 break;
1154 case A_CRITICAL:
1155 case A_ENDCRITICAL:
1156 case A_ATOMIC:
1157 case A_ATOMICCAPTURE:
1158 case A_ATOMICREAD:
1159 case A_ATOMICWRITE:
1160 putnzint("lop", A_LOPG(0));
1161 A_LOPP(0, 0);
1162 break;
1163 case A_ENDATOMIC:
1164 case A_BARRIER:
1165 case A_NOBARRIER:
1166 break;
1167 case A_MP_SECTIONS:
1168 case A_MP_CANCELLATIONPOINT:
1169 putint("endlab", A_ENDLABG(0));
1170 A_ENDLABP(0, 0);
1171 break;
1172 case A_MP_CANCEL:
1173 putnzint("ifcancel", A_IFPARG(0));
1174 A_IFPARP(0, 0);
1175 putint("endlab", A_ENDLABG(0));
1176 A_ENDLABP(0, 0);
1177 break;
1178 case A_MP_PARALLEL:
1179 putnzint("lop", A_LOPG(0));
1180 A_LOPP(0, 0);
1181 putnzint("ifpar", A_IFPARG(0));
1182 A_IFPARP(0, 0);
1183 putnzint("endlab", A_ENDLABG(0));
1184 A_ENDLABP(0, 0);
1185 putnzint("procbind", A_PROCBINDG(0));
1186 A_PROCBINDP(0, 0);
1187 putnzint("num_threads", A_NPARG(0));
1188 A_NPARP(0, 0);
1189 break;
1190 case A_MP_TEAMS:
1191 putnzint("lop", A_LOPG(0));
1192 A_LOPP(0, 0);
1193 putnzint("nteams", A_NTEAMSG(0));
1194 A_NTEAMSP(0, 0);
1195 putnzint("thrlimit", A_THRLIMITG(0));
1196 A_THRLIMITP(0, 0);
1197 break;
1198 case A_MP_BMPSCOPE:
1199 putnzint("stblk", A_STBLKG(0));
1200 A_STBLKP(0, 0);
1201 break;
1202 case A_MP_TASKFIRSTPRIV:
1203 putnzint("lop", A_LOPG(0));
1204 A_LOPP(0, 0);
1205 putnzint("rop", A_ROPG(0));
1206 A_ROPP(0, 0);
1207 break;
1208 case A_MP_TASK:
1209 case A_MP_TASKLOOP:
1210 putnzint("lop", A_LOPG(0));
1211 A_LOPP(0, 0);
1212 putnzint("ifpar", A_IFPARG(0));
1213 A_IFPARP(0, 0);
1214 putnzint("final", A_FINALPARG(0));
1215 A_FINALPARP(0, 0);
1216 putbit("untied", A_UNTIEDG(0));
1217 A_UNTIEDP(0, 0);
1218 putbit("mergeable", A_MERGEABLEG(0));
1219 A_MERGEABLEP(0, 0);
1220 putbit("exeimm", A_EXEIMMG(0));
1221 A_EXEIMMP(0, 0);
1222 if (atype == A_MP_TASKLOOP) {
1223 putnzint("priority", A_PRIORITYG(0));
1224 A_PRIORITYP(0, 0);
1225 putbit("nogroup", A_NOGROUPG(0));
1226 A_NOGROUPP(0, 0);
1227 putbit("grainsize", A_GRAINSIZEG(0));
1228 A_GRAINSIZEP(0, 0);
1229 putbit("num_tasks", A_NUM_TASKSG(0));
1230 A_NUM_TASKSP(0, 0);
1231 }
1232 putnzint("endlab", A_ENDLABG(0));
1233 A_ENDLABP(0, 0);
1234 break;
1235 case A_MP_TARGET:
1236 case A_MP_TARGETDATA:
1237 case A_MP_TARGETENTERDATA:
1238 case A_MP_TARGETEXITDATA:
1239 case A_MP_TARGETUPDATE:
1240 putnzint("if", A_IFPARG(0));
1241 A_IFPARP(0, 0);
1242 break;
1243 case A_MP_ENDPARALLEL:
1244 case A_MP_CRITICAL:
1245 case A_MP_ENDCRITICAL:
1246 case A_MP_ATOMIC:
1247 case A_MP_ENDATOMIC:
1248 case A_MP_MASTER:
1249 case A_MP_ENDMASTER:
1250 case A_MP_SINGLE:
1251 case A_MP_ENDSINGLE:
1252 case A_MP_ENDSECTIONS:
1253 case A_MP_WORKSHARE:
1254 case A_MP_ENDWORKSHARE:
1255 case A_MP_ENDTASK:
1256 case A_MP_ETASKLOOP:
1257 putnzint("lop", A_LOPG(0));
1258 A_LOPP(0, 0);
1259 break;
1260 case A_MP_PDO:
1261 putint("dolab", A_DOLABG(0));
1262 A_DOLABP(0, 0);
1263 putint("dovar", A_DOVARG(0));
1264 A_DOVARP(0, 0);
1265 putint("lastvar", A_LASTVALG(0));
1266 A_LASTVALP(0, 0);
1267 putint("m1g", A_M1G(0));
1268 A_M1P(0, 0);
1269 putint("m2g", A_M2G(0));
1270 A_M2P(0, 0);
1271 putint("m3g", A_M3G(0));
1272 A_M3P(0, 0);
1273 putint("m3g", A_CHUNKG(0));
1274 A_CHUNKP(0, 0);
1275 putint("sched_Type", A_SCHED_TYPEG(0));
1276 A_SCHED_TYPEP(0, 0);
1277 putbit("ordered", A_ORDEREDG(0));
1278 A_ORDEREDP(0, 0);
1279 putint("endlab", A_ENDLABG(0));
1280 A_ENDLABP(0, 0);
1281 break;
1282 case A_MP_TASKLOOPREG:
1283 putint("m1g", A_M1G(0));
1284 A_M1P(0, 0);
1285 putint("m2g", A_M2G(0));
1286 A_M2P(0, 0);
1287 putint("m3g", A_M3G(0));
1288 A_M3P(0, 0);
1289 putint("m3g", A_CHUNKG(0));
1290 break;
1291 case A_MP_ATOMICREAD:
1292 putnzint("src", A_SRCG(0));
1293 A_ROPP(0, 0);
1294 putbit("mem_order", A_MEM_ORDERG(0));
1295 A_MEM_ORDERP(0, 0);
1296 break;
1297 case A_MP_ATOMICWRITE:
1298 putnzint("lop", A_LOPG(0));
1299 A_LOPP(0, 0);
1300 putnzint("rop", A_ROPG(0));
1301 A_ROPP(0, 0);
1302 putbit("mem_order", A_MEM_ORDERG(0));
1303 A_MEM_ORDERP(0, 0);
1304 break;
1305 case A_MP_ATOMICUPDATE:
1306 case A_MP_ATOMICCAPTURE:
1307 putnzint("lop", A_LOPG(0));
1308 A_LOPP(0, 0);
1309 putnzint("rop", A_ROPG(0));
1310 A_ROPP(0, 0);
1311 putoptype("optype", A_OPTYPEG(0));
1312 A_OPTYPEP(0, 0);
1313 putbit("mem_order", A_MEM_ORDERG(0));
1314 A_MEM_ORDERP(0, 0);
1315 break;
1316 case A_MP_TASKREG:
1317 case A_MP_TASKDUP:
1318 case A_MP_BARRIER:
1319 case A_MP_TASKWAIT:
1320 case A_MP_TASKYIELD:
1321 case A_MP_ENDPDO:
1322 case A_MP_SECTION:
1323 case A_MP_LSECTION:
1324 case A_MP_BCOPYIN:
1325 case A_MP_ECOPYIN:
1326 case A_MP_BCOPYPRIVATE:
1327 case A_MP_ECOPYPRIVATE:
1328 case A_MP_BPDO:
1329 case A_MP_EPDO:
1330 case A_MP_EMPSCOPE:
1331 case A_MP_BORDERED:
1332 case A_MP_EORDERED:
1333 case A_MP_FLUSH:
1334 case A_MP_ENDTARGET:
1335 case A_MP_ENDTEAMS:
1336 case A_MP_ENDDISTRIBUTE:
1337 case A_MP_DISTRIBUTE:
1338 break;
1339 case A_MP_PRE_TLS_COPY:
1340 case A_MP_COPYIN:
1341 case A_MP_COPYPRIVATE:
1342 putsym("sptr", A_SPTRG(0));
1343 A_SPTRP(0, 0);
1344 putnzint("rop", A_ROPG(0));
1345 A_ROPP(0, 0);
1346 break;
1347 case A_PREFETCH:
1348 putnzint("lop", A_LOPG(0));
1349 A_LOPP(0, 0);
1350 putoptype("optype", A_OPTYPEG(0));
1351 A_OPTYPEP(0, 0);
1352 break;
1353 case A_PRAGMA:
1354 putnzint("lop", A_LOPG(0));
1355 A_LOPP(0, 0);
1356 putnzint("pragmatype", A_PRAGMATYPEG(0));
1357 A_PRAGMATYPEP(0, 0);
1358 putnzint("pragmascope", A_PRAGMASCOPEG(0));
1359 A_PRAGMASCOPEP(0, 0);
1360 break;
1361 default:
1362 putbit("unknown", 1);
1363 break;
1364 }
1365 putline();
1366 } /* dast */
1367
1368 void
dumpasts()1369 dumpasts()
1370 {
1371 int astx;
1372 for (astx = 1; astx < astb.stg_avail; ++astx) {
1373 dast(astx);
1374 }
1375 } /* dumpasts */
1376
1377 void
dumpshape(int shd)1378 dumpshape(int shd)
1379 {
1380 int l, nd, ii;
1381 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
1382 if (shd < 0 || shd >= astb.shd.stg_avail) {
1383 fprintf(dfile, "\nshd %d out of range [0:%d)\n", shd, astb.shd.stg_avail);
1384 return;
1385 }
1386 putint("shd", shd);
1387 nd = SHD_NDIM(shd);
1388 putint("ndim", nd);
1389 for (ii = 0; ii < nd; ++ii) {
1390 putline();
1391 putint("dim", ii);
1392 putast("lwb", SHD_LWB(shd, ii));
1393 putast("upb", SHD_UPB(shd, ii));
1394 putast("stride", SHD_STRIDE(shd, ii));
1395 }
1396 putline();
1397 } /* dumpshape */
1398
1399 void
dumpshapes()1400 dumpshapes()
1401 {
1402 int shd;
1403 for (shd = 1; shd < astb.shd.stg_avail;) {
1404 if (shd > 1) {
1405 fprintf(dfile, "\n");
1406 }
1407 dumpshape(shd);
1408 shd += 1 + SHD_NDIM(shd);
1409 }
1410 } /* dumpshapes */
1411
1412 static char prefix[500];
1413
1414 static void
dastreex(int astx,int l,int notlast)1415 dastreex(int astx, int l, int notlast)
1416 {
1417 int asdx, ndim, j, args, argcnt;
1418 if (astx == 0)
1419 return;
1420 if (l > 4)
1421 strcpy(prefix + l - 4, "+-- ");
1422 fprintf(dfile, "%s", prefix);
1423 dast(astx);
1424 if (astx <= 0 || astx >= astb.stg_avail)
1425 return;
1426 if (l) {
1427 if (notlast) {
1428 strcpy(prefix + l - 4, "| ");
1429 } else {
1430 strcpy(prefix + l - 4, " ");
1431 }
1432 }
1433 switch (A_TYPEG(astx)) {
1434 case A_NULL:
1435 case A_ID:
1436 case A_LABEL:
1437 case A_ENTRY:
1438 case A_CNST:
1439 case A_CMPLXC:
1440 case A_GOTO:
1441 case A_CGOTO:
1442 case A_AGOTO:
1443 break;
1444 case A_BINOP:
1445 dastreex(A_LOPG(astx), l + 4, 1);
1446 dastreex(A_ROPG(astx), l + 4, 0);
1447 break;
1448 case A_MEM:
1449 dastreex(A_MEMG(astx), l + 4, 1);
1450 dastreex(A_PARENTG(astx), l + 4, 0);
1451 break;
1452 case A_CONV:
1453 case A_UNOP:
1454 case A_PAREN:
1455 dastreex(A_LOPG(astx), l + 4, 0);
1456 break;
1457 case A_SUBSCR:
1458 asdx = A_ASDG(astx);
1459 ndim = ASD_NDIM(asdx);
1460 dastreex(A_LOPG(astx), l + 4, ndim > 0);
1461 for (j = 0; j < ndim; ++j) {
1462 dastreex(ASD_SUBS(asdx, j), l + 4, ndim - j - 1);
1463 }
1464 break;
1465 case A_SUBSTR:
1466 dastreex(A_LEFTG(astx), l + 4, 1);
1467 dastreex(A_RIGHTG(astx), l + 4, 1);
1468 dastreex(A_LOPG(astx), l + 4, 0);
1469 break;
1470 case A_INIT:
1471 dastreex(A_LEFTG(astx), l + 4, 1);
1472 dastreex(A_RIGHTG(astx), l + 4, 0);
1473 break;
1474 case A_TRIPLE:
1475 dastreex(A_LBDG(astx), l + 4, 1);
1476 dastreex(A_UPBDG(astx), l + 4, 1);
1477 dastreex(A_STRIDEG(astx), l + 4, 0);
1478 break;
1479 case A_FUNC:
1480 case A_INTR:
1481 case A_CALL:
1482 case A_ICALL:
1483 argcnt = A_ARGCNTG(astx);
1484 args = A_ARGSG(astx);
1485 dastreex(A_LOPG(astx), l + 4, argcnt > 0);
1486 for (j = 0; j < argcnt; ++j) {
1487 dastreex(ARGT_ARG(args, j), l + 4, argcnt - j - 1);
1488 }
1489 break;
1490 case A_ASN:
1491 case A_ASNGOTO:
1492 dastreex(A_DESTG(astx), l + 4, 1);
1493 dastreex(A_SRCG(astx), l + 4, 0);
1494 break;
1495 case A_IF:
1496 dastreex(A_IFEXPRG(astx), l + 4, 1);
1497 dastreex(A_IFSTMTG(astx), l + 4, 0);
1498 break;
1499 case A_IFTHEN:
1500 dastreex(A_IFEXPRG(astx), l + 4, 0);
1501 break;
1502 case A_ELSE:
1503 break;
1504 case A_ELSEIF:
1505 dastreex(A_IFEXPRG(astx), l + 4, 0);
1506 break;
1507 case A_ENDIF:
1508 break;
1509 case A_AIF:
1510 dastreex(A_IFEXPRG(astx), l + 4, 0);
1511 break;
1512 case A_DO:
1513 dastreex(A_M1G(astx), l + 4, 1);
1514 dastreex(A_M2G(astx), l + 4, 1);
1515 dastreex(A_M3G(astx), l + 4, 0);
1516 dastreex(A_M4G(astx), l + 4, 0);
1517 break;
1518 case A_DOWHILE:
1519 dastreex(A_IFEXPRG(astx), l + 4, 0);
1520 break;
1521 case A_ENDDO:
1522 case A_CONTINUE:
1523 case A_END:
1524 break;
1525 case A_STOP:
1526 case A_PAUSE:
1527 case A_RETURN:
1528 dastreex(A_LOPG(astx), l + 4, 0);
1529 break;
1530 case A_ALLOC:
1531 dastreex(A_LOPG(astx), l + 4, 0);
1532 dastreex(A_SRCG(astx), l + 4, 0);
1533 dastreex(A_DESTG(astx), l + 4, 0);
1534 dastreex(A_M3G(astx), l + 4, 0);
1535 dastreex(A_STARTG(astx), l + 4, 0);
1536 dastreex(A_DTYPEG(astx), l + 4, 0);
1537 break;
1538 case A_WHERE:
1539 dastreex(A_IFEXPRG(astx), l + 4, 1);
1540 dastreex(A_IFSTMTG(astx), l + 4, 0);
1541 break;
1542 case A_FORALL:
1543 break;
1544 case A_ELSEWHERE:
1545 case A_ENDWHERE:
1546 case A_ENDFORALL:
1547 case A_ELSEFORALL:
1548 break;
1549 case A_REDIM:
1550 break;
1551 case A_COMMENT:
1552 case A_COMSTR:
1553 break;
1554 case A_REALIGN:
1555 case A_REDISTRIBUTE:
1556 break;
1557 case A_HLOCALIZEBNDS:
1558 break;
1559 case A_HALLOBNDS:
1560 break;
1561 case A_HCYCLICLP:
1562 break;
1563 case A_HOFFSET:
1564 break;
1565 case A_HSECT:
1566 break;
1567 case A_HCOPYSECT:
1568 break;
1569 case A_HPERMUTESECT:
1570 break;
1571 case A_HOVLPSHIFT:
1572 break;
1573 case A_HGETSCLR:
1574 dastreex(A_DESTG(astx), l + 4, 1);
1575 dastreex(A_SRCG(astx), l + 4, A_LOPG(astx));
1576 if (A_LOPG(astx)) {
1577 dastreex(A_LOPG(astx), l + 4, 0);
1578 }
1579 break;
1580 case A_HGATHER:
1581 case A_HSCATTER:
1582 break;
1583 case A_HCSTART:
1584 break;
1585 case A_HCFINISH:
1586 case A_HCFREE:
1587 break;
1588 case A_MASTER:
1589 break;
1590 case A_ENDMASTER:
1591 argcnt = A_ARGCNTG(astx);
1592 args = A_ARGSG(astx);
1593 for (j = 0; j < argcnt; ++j) {
1594 dastreex(ARGT_ARG(args, j), l + 4, argcnt - j - 1);
1595 }
1596 break;
1597 case A_ATOMIC:
1598 case A_PREFETCH:
1599 case A_PRAGMA:
1600 dastreex(A_LOPG(astx), l + 4, 0);
1601 break;
1602 case A_CRITICAL:
1603 case A_ENDCRITICAL:
1604 case A_ENDATOMIC:
1605 case A_BARRIER:
1606 case A_NOBARRIER:
1607 break;
1608 case A_MP_TARGET:
1609 case A_MP_TARGETUPDATE:
1610 case A_MP_TARGETDATA:
1611 case A_MP_TARGETENTERDATA:
1612 case A_MP_TARGETEXITDATA:
1613 case A_MP_PARALLEL:
1614 dastreex(A_IFPARG(astx), l + 4, 0);
1615 break;
1616 case A_MP_TEAMS:
1617 dastreex(A_NTEAMSG(astx), l + 4, 0);
1618 dastreex(A_THRLIMITG(astx), l + 4, 0);
1619 break;
1620 case A_MP_BMPSCOPE:
1621 dastreex(A_STBLKG(astx), l + 4, 0);
1622 break;
1623 case A_MP_TASK:
1624 case A_MP_TASKLOOP:
1625 dastreex(A_IFPARG(astx), l + 4, 0);
1626 break;
1627 case A_MP_TASKFIRSTPRIV:
1628 case A_MP_ENDPARALLEL:
1629 case A_MP_CRITICAL:
1630 case A_MP_ENDCRITICAL:
1631 case A_MP_ATOMIC:
1632 case A_MP_ENDATOMIC:
1633 case A_MP_MASTER:
1634 case A_MP_ENDMASTER:
1635 case A_MP_SINGLE:
1636 case A_MP_ENDSINGLE:
1637 case A_MP_BARRIER:
1638 case A_MP_ETASKDUP:
1639 case A_MP_ETASKLOOPREG:
1640 case A_MP_TASKWAIT:
1641 case A_MP_TASKYIELD:
1642 case A_MP_ENDTASK:
1643 case A_MP_ETASKLOOP:
1644 case A_MP_EMPSCOPE:
1645 case A_MP_ENDTARGET:
1646 case A_MP_ENDTEAMS:
1647 case A_MP_ENDDISTRIBUTE:
1648 case A_MP_ENDTARGETDATA:
1649 case A_MP_TASKDUP:
1650 break;
1651 case A_MP_ATOMICREAD:
1652 dastreex(A_SRCG(astx), l + 4, 0);
1653 case A_MP_ATOMICWRITE:
1654 case A_MP_ATOMICUPDATE:
1655 case A_MP_ATOMICCAPTURE:
1656 dastreex(A_LOPG(astx), l + 4, 0);
1657 dastreex(A_ROPG(astx), l + 4, 0);
1658 break;
1659 case A_MP_TASKREG:
1660 dastreex(A_ENDLABG(astx), l + 4, 0);
1661 break;
1662 case A_MP_TASKLOOPREG:
1663 dastreex(A_M1G(astx), l + 4, 1);
1664 dastreex(A_M2G(astx), l + 4, 1);
1665 dastreex(A_M3G(astx), l + 4, 1);
1666 break;
1667 case A_MP_CANCEL:
1668 dastreex(A_IFPARG(astx), l + 4, 0);
1669 case A_MP_SECTIONS:
1670 case A_MP_CANCELLATIONPOINT:
1671 dastreex(A_ENDLABG(astx), l + 4, 0);
1672 break;
1673 case A_MP_PDO:
1674 dastreex(A_M1G(astx), l + 4, 1);
1675 dastreex(A_M2G(astx), l + 4, 1);
1676 dastreex(A_M3G(astx), l + 4, 1);
1677 dastreex(A_CHUNKG(astx), l + 4, 0);
1678 break;
1679 case A_MP_ENDPDO:
1680 case A_MP_ENDSECTIONS:
1681 case A_MP_SECTION:
1682 case A_MP_LSECTION:
1683 case A_MP_PRE_TLS_COPY:
1684 case A_MP_BCOPYIN:
1685 case A_MP_COPYIN:
1686 case A_MP_ECOPYIN:
1687 case A_MP_BCOPYPRIVATE:
1688 case A_MP_COPYPRIVATE:
1689 case A_MP_ECOPYPRIVATE:
1690 case A_MP_MAP:
1691 case A_MP_EMAP:
1692 case A_MP_TARGETLOOPTRIPCOUNT:
1693 case A_MP_DISTRIBUTE:
1694 case A_MP_EREDUCTION:
1695 case A_MP_BREDUCTION:
1696 case A_MP_REDUCTIONITEM:
1697 break;
1698 default:
1699 fprintf(gbl.dbgfil, "NO DUMP AVL");
1700 break;
1701 }
1702 prefix[l - 4] = '\0';
1703 } /* dastreex */
1704
1705 void
dastree(int astx)1706 dastree(int astx)
1707 {
1708 int savelonglines;
1709 savelonglines = longlines;
1710 longlines = 1;
1711 prefix[0] = ' ';
1712 prefix[1] = ' ';
1713 prefix[2] = ' ';
1714 prefix[3] = ' ';
1715 prefix[4] = '\0';
1716 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
1717 dastreex(astx, 4, 0);
1718 prefix[0] = '\0';
1719 longlines = savelonglines;
1720 } /* dastree */
1721
1722 void
past(int astx)1723 past(int astx)
1724 {
1725 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
1726 printast(astx);
1727 fprintf(dfile, "\n");
1728 } /* past */
1729
1730 static void
putflags(char * s,int flags)1731 putflags(char *s, int flags)
1732 {
1733 if (flags) {
1734 sprintf(BUF, "%s=%8.8x ", s, flags);
1735 putit();
1736 }
1737 } /* putflags */
1738
1739 void
dumpfnode(int v)1740 dumpfnode(int v)
1741 {
1742 PSI_P succ, pred;
1743 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
1744 if (opt.fgb.stg_base == NULL) {
1745 fprintf(dfile, "OPT.FGB.STG not allocated\n");
1746 return;
1747 }
1748 if (v < 0 || v > opt.num_nodes) {
1749 fprintf(dfile, "Flow graph node %d out of %d\n", v, opt.num_nodes);
1750 return;
1751 }
1752 putint("fnode", v);
1753 putint("lineno", FG_LINENO(v));
1754 putnsym("label", FG_LABEL(v));
1755 putnzint("lprev", FG_LPREV(v));
1756 putnzint("lnext", FG_LNEXT(v));
1757 putnzint("first", FG_STDFIRST(v));
1758 putnzint("last", FG_STDLAST(v));
1759 putnzint("atomic", FG_ATOMIC(v));
1760 putnzint("dfn", FG_DFN(v));
1761 putnzint("dom", FG_DOM(v));
1762 putnzint("pdom", FG_PDOM(v));
1763 putnzint("loop", FG_LOOP(v));
1764 putnzint("next", FG_NEXT(v));
1765 putnzint("natnxt", FG_NATNXT(v));
1766 putnzint("par", FG_PAR(v));
1767 putnzint("parloop", FG_PARLOOP(v));
1768 putline();
1769 pred = FG_PRED(v);
1770 if (pred == NULL) {
1771 putstring("pred", "none");
1772 } else {
1773 putstring1("pred:");
1774 for (; pred != PSI_P_NULL; pred = PSI_NEXT(pred)) {
1775 putint1star(PSI_NODE(pred), PSI_FT(pred), "(ft)");
1776 }
1777 }
1778 succ = FG_SUCC(v);
1779 if (succ == NULL) {
1780 putstring("succ", "none");
1781 } else {
1782 putstring1("succ:");
1783 for (; succ != PSI_P_NULL; succ = PSI_NEXT(succ)) {
1784 putint1star(PSI_NODE(succ), PSI_FT(succ), "(ft)");
1785 }
1786 }
1787 putline();
1788 putbit("call", FG_EX(v));
1789 putbit("cs", FG_CS(v));
1790 putbit("ctlequiv", FG_CTLEQUIV(v));
1791 putbit("entry", FG_EN(v));
1792 putbit("exit", FG_XT(v));
1793 putbit("fallthru", FG_FT(v));
1794 putbit("head", FG_HEAD(v));
1795 putbit("innermost", FG_INNERMOST(v));
1796 putbit("jumptable", FG_JMP_TBL(v));
1797 putbit("master", FG_MASTER(v));
1798 putbit("mexits", FG_MEXITS(v));
1799 putbit("parsect", FG_PARSECT(v));
1800 putbit("task", FG_TASK(v));
1801 putbit("ptrstore", FG_PTR_STORE(v));
1802 putbit("tail", FG_TAIL(v));
1803 putbit("zerotrip", FG_ZTRP(v));
1804 putline();
1805 } /* dumpfnode */
1806
1807 void
dumpfg(int v)1808 dumpfg(int v)
1809 {
1810 dumpfnode(v);
1811 } /* dumpfg */
1812
1813 void
dfg(int v)1814 dfg(int v)
1815 {
1816 dumpfnode(v);
1817 } /* dfg */
1818
1819 void
dumpfgraph()1820 dumpfgraph()
1821 {
1822 int v;
1823 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
1824 if (opt.fgb.stg_base == NULL) {
1825 fprintf(dfile, "OPT.FGB.STG not allocated\n");
1826 return;
1827 }
1828 for (v = 1; v <= opt.num_nodes; ++v) {
1829 if (v > 1)
1830 fprintf(dfile, "\n");
1831 dumpfnode(v);
1832 }
1833
1834 fprintf(dfile, "\nDepth First Order:\n");
1835 for (v = 1; v <= opt.dfn; ++v) {
1836 putint1(VTX_NODE(v));
1837 }
1838 putline();
1839
1840 fprintf(dfile, "\nRetreating Edges:\n");
1841 for (v = 0; v < opt.rteb.stg_avail; ++v) {
1842 putedge(EDGE_PRED(v), EDGE_SUCC(v));
1843 }
1844 putline();
1845 } /* dumpfgraph */
1846
1847 void
putnme(int n)1848 putnme(int n)
1849 {
1850 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
1851 if (n < 0 || n >= nmeb.stg_avail) {
1852 putint("nme", n);
1853 return;
1854 }
1855 switch (NME_TYPE(n)) {
1856 case NT_VAR:
1857 putstring1(getprint(NME_SYM(n)));
1858 break;
1859 case NT_MEM:
1860 putnme(NME_NM(n));
1861 if (NME_SYM(n) == 0) {
1862 appendstring1(".real");
1863 break;
1864 }
1865 if (NME_SYM(n) == 1) {
1866 appendstring1(".imag");
1867 break;
1868 }
1869 appendstring1(".");
1870 appendstring1(getprint(NME_SYM(n)));
1871 break;
1872 default:
1873 put2int("nme", n, NME_TYPE(n));
1874 break;
1875 }
1876 } /* putnme */
1877
1878 void
putnmetype(char * s,int t)1879 putnmetype(char *s, int t)
1880 {
1881 switch (t) {
1882 case NT_ADD:
1883 putstring(s, "add");
1884 break;
1885 case NT_UNK: /* unknown */
1886 putstring(s, "unk");
1887 break;
1888 case NT_IND: /* Indirect ref e.g. *p */
1889 putstring(s, "ind");
1890 break;
1891 case NT_VAR: /* Variable ref. (struct, array or scalar) */
1892 putstring(s, "var");
1893 break;
1894 case NT_MEM: /* Structure member ref. */
1895 putstring(s, "mem");
1896 break;
1897 case NT_ARR: /* Array element ref. */
1898 putstring(s, "arr");
1899 break;
1900 case NT_SAFE: /* special names; does not conflict with preceding refs */
1901 putstring(s, "safe");
1902 break;
1903 default:
1904 putint(s, t);
1905 break;
1906 }
1907 } /* putnmetype */
1908
1909 char *
printname(int sptr)1910 printname(int sptr)
1911 {
1912 static char b[200];
1913
1914 if (sptr <= 0 || sptr >= stb.stg_avail) {
1915 sprintf(b, "symbol %d out of %d", sptr, stb.stg_avail - 1);
1916 return b;
1917 }
1918
1919 if (STYPEG(sptr) == ST_CONST) {
1920 INT num[2];
1921 int pointee;
1922 char *bb;
1923 switch (DTY(DTYPEG(sptr))) {
1924 case TY_INT8:
1925 num[0] = CONVAL1G(sptr);
1926 num[1] = CONVAL2G(sptr);
1927 ui64toax(num, b, 22, 0, 10);
1928 break;
1929 case TY_INT:
1930 sprintf(b, "%10d", CONVAL2G(sptr));
1931 break;
1932
1933 case TY_FLOAT:
1934 num[0] = CONVAL2G(sptr);
1935 cprintf(b, "%.8e", num);
1936 break;
1937
1938 case TY_QUAD:
1939 case TY_DBLE:
1940 num[0] = CONVAL1G(sptr);
1941 num[1] = CONVAL2G(sptr);
1942 cprintf(b, "%.17le", num);
1943 break;
1944
1945 case TY_PTR:
1946 pointee = CONVAL1G(sptr);
1947 if (pointee > 0 && pointee < stb.stg_avail && STYPEG(pointee) != ST_CONST) {
1948 if (CONVAL2G(sptr) == 0) {
1949 sprintf(b, "*%s", SYMNAME(pointee));
1950 } else {
1951 sprintf(b, "*%s+%d", SYMNAME(pointee), CONVAL2G(sptr));
1952 }
1953 } else {
1954 if (CONVAL2G(sptr) == 0) {
1955 sprintf(b, "*(sym %d)", pointee);
1956 } else {
1957 sprintf(b, "*(sym %d)+%d", pointee, CONVAL2G(sptr));
1958 }
1959 }
1960 break;
1961
1962 case TY_WORD:
1963 sprintf(b, "%10d", CONVAL2G(sptr));
1964 break;
1965
1966 case TY_CHAR:
1967 return stb.n_base + CONVAL1G(sptr);
1968 break;
1969
1970 default:
1971 sprintf(b, "unknown constant %d dty %" ISZ_PF "d", sptr,
1972 DTY(DTYPEG(sptr)));
1973 break;
1974 }
1975 for (bb = b; *bb == ' '; ++bb)
1976 ;
1977 return bb;
1978 }
1979 /* default case */
1980 if (strncmp(SYMNAME(sptr), "..inline", 8) == 0) {
1981 /* append symbol number to distinguish */
1982 sprintf(b, "%s_%d", SYMNAME(sptr), sptr);
1983 return b;
1984 }
1985 return SYMNAME(sptr);
1986 } /* printname */
1987
1988 static void
_printnme(int n)1989 _printnme(int n)
1990 {
1991 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
1992 if (n < 0 || n >= nmeb.stg_avail) {
1993 putint("nme", n);
1994 return;
1995 }
1996 switch (NME_TYPE(n)) {
1997 case NT_VAR:
1998 appendstring1(printname(NME_SYM(n)));
1999 break;
2000 case NT_MEM:
2001 if (NME_NM(n)) {
2002 _printnme(NME_NM(n));
2003 } else {
2004 appendstring1("Unknown");
2005 }
2006 if (NME_SYM(n) == 0) {
2007 appendstring1(".real");
2008 } else if (NME_SYM(n) == 1) {
2009 appendstring1(".imag");
2010 } else
2011 {
2012 appendstring1(".");
2013 appendstring1(printname(NME_SYM(n)));
2014 }
2015 break;
2016 case NT_ARR:
2017 if (NME_NM(n)) {
2018 _printnme(NME_NM(n));
2019 } else {
2020 appendstring1("Unknown");
2021 }
2022 if (NME_SYM(n) == 0) {
2023 appendstring1("[");
2024 appendint1(NME_CNST(n));
2025 appendstring1("]");
2026 } else if (NME_SUB(n) != 0) {
2027 int asdx, i, ndim;
2028 appendstring1("[");
2029 asdx = NME_SUB(n);
2030 ndim = ASD_NDIM(asdx);
2031 for (i = 0; i < ndim; ++i) {
2032 int d;
2033 d = ASD_SUBS(n, i);
2034 printast(d);
2035 if (i)
2036 appendstring1(",");
2037 }
2038 appendstring1("]");
2039 } else {
2040 appendstring1("[?]");
2041 }
2042 break;
2043 case NT_IND:
2044 appendstring1("*(");
2045 if (NME_NM(n)) {
2046 _printnme(NME_NM(n));
2047 } else {
2048 appendstring1("Unknown");
2049 }
2050 if (NME_SYM(n) == NME_NULL) {
2051 } else if (NME_SYM(n) == 0) {
2052 if (NME_CNST(n)) {
2053 appendstring1("+");
2054 appendint1(NME_CNST(n));
2055 }
2056 } else {
2057 appendstring1("+?");
2058 }
2059 appendstring1(")");
2060 break;
2061 case NT_UNK:
2062 if (NME_SYM(n) == 0) {
2063 appendstring1("unknown");
2064 } else if (NME_SYM(n) == 1) {
2065 appendstring1("volatile");
2066 } else {
2067 appendstring1("unknown:");
2068 appendint1(NME_SYM(n));
2069 }
2070 break;
2071 default:
2072 appendstring1("nme(");
2073 appendint1(n);
2074 appendstring1(":");
2075 appendint1(NME_TYPE(n));
2076 appendstring1(")");
2077 break;
2078 }
2079 } /* _printnme */
2080
2081 void
printnme(int n)2082 printnme(int n)
2083 {
2084 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2085 putstring1("");
2086 _printnme(n);
2087 } /* printnme */
2088
2089 void
dumpnme(int n)2090 dumpnme(int n)
2091 {
2092 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2093 if (nmeb.stg_base == NULL) {
2094 fprintf(dfile, "NME not allocated\n");
2095 return;
2096 }
2097 if (n < 0 || n > nmeb.stg_avail) {
2098 fprintf(dfile, "NME %d out of %d\n", n, nmeb.stg_avail);
2099 return;
2100 }
2101 putint("nme", n);
2102 putnmetype("type", NME_TYPE(n));
2103 putnzint("inlarr", NME_INLARR(n));
2104 putnsym("sym", NME_SYM(n));
2105 putnzint("nm", NME_NM(n));
2106 putnzint("hshlnk", NME_HSHLNK(n));
2107 putnzint("rfptr", NME_RFPTR(n));
2108 putnzint("cnst", NME_CNST(n));
2109 putnzint("sub", NME_SUB(n));
2110 putnzint("stl", NME_STL(n));
2111 putnzint("cnt", NME_CNT(n));
2112 putline();
2113 if (NME_DEF(n)) {
2114 int d;
2115 putstring1(" defs:");
2116 for (d = NME_DEF(n); d; d = DEF_NEXT(d)) {
2117 putint1(d);
2118 }
2119 putline();
2120 }
2121 } /* dumpnme */
2122
2123 void
dumpnmes()2124 dumpnmes()
2125 {
2126 int n;
2127 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2128 if (nmeb.stg_base == NULL) {
2129 fprintf(dfile, "NME not allocated\n");
2130 return;
2131 }
2132 for (n = 0; n < nmeb.stg_avail; ++n) {
2133 if (n)
2134 fprintf(dfile, "\n");
2135 dumpnme(n);
2136 }
2137 } /* dumpnmes */
2138
2139 void
dumploop(int l)2140 dumploop(int l)
2141 {
2142 PSI_P p;
2143 Q_ITEM *q;
2144 int v;
2145 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2146 if (opt.lpb.stg_base == NULL) {
2147 fprintf(dfile, "opt.lpb not allocated\n");
2148 return;
2149 }
2150 if (l < 0 || l > opt.nloops) {
2151 fprintf(dfile, "Loop %d out of %d\n", l, opt.nloops);
2152 return;
2153 }
2154 putint("loop", l);
2155 putint("level", LP_LEVEL(l));
2156 putnzint("parent", LP_PARENT(l));
2157 putint("head", LP_HEAD(l));
2158 putint("tail", LP_TAIL(l));
2159 putnzint("child", LP_CHILD(l));
2160 putnzint("sibling", LP_SIBLING(l));
2161 put2int("lines", BIH_LINENO(FG_TO_BIH(LP_HEAD(l))),
2162 BIH_LINENO(FG_TO_BIH(LP_TAIL(l))));
2163 putnzint("parloop", LP_PARLOOP(l));
2164 putline();
2165 putstring1("nodes:");
2166 for (v = LP_FG(l); v; v = FG_NEXT(v)) {
2167 putint1(v);
2168 }
2169 p = LP_EXITS(l);
2170 if (p == NULL) {
2171 putstring("exits", "none");
2172 } else {
2173 putline();
2174 putstring1(" exits:");
2175 for (; p != PSI_P_NULL; p = PSI_NEXT(p)) {
2176 putint1(PSI_NODE(p));
2177 }
2178 }
2179 q = LP_STL_PAR(l);
2180 if (q) {
2181 putline();
2182 putstring1(" stl_par:");
2183 for (; q; q = q->next) {
2184 putnme(q->info);
2185 }
2186 }
2187
2188 putline();
2189 putbit("callfg", LP_CALLFG(l));
2190 putbit("callinternal", LP_CALLINTERNAL(l));
2191 #ifdef LP_CNCALL
2192 putbit("cncall", LP_CNCALL(l));
2193 #endif
2194 putbit("cs", LP_CS(l));
2195 putbit("csect", LP_CSECT(l));
2196 #ifdef LP_EXT_STORE
2197 putbit("ext_store", LP_EXT_STORE(l));
2198 #endif
2199 putbit("forall", LP_FORALL(l));
2200 putbit("innermost", LP_INNERMOST(l));
2201 #ifdef LP_INVARIF
2202 putbit("invarif", LP_INVARIF(l));
2203 #endif
2204 putbit("jmp_tbl", LP_JMP_TBL(l));
2205 putbit("mark", LP_MARK(l));
2206 putbit("master", LP_MASTER(l));
2207 putbit("mexits", LP_MEXITS(l));
2208 putbit("nobla", LP_NOBLA(l));
2209 putbit("parregn", LP_PARREGN(l));
2210 putbit("parsect", LP_PARSECT(l));
2211 #ifdef LP_PTR_LOAD
2212 putbit("ptr_load", LP_PTR_LOAD(l));
2213 #endif
2214 #ifdef LP_PTR_STORE
2215 putbit("ptr_store", LP_PTR_STORE(l));
2216 #endif
2217 putbit("qjsr", LP_QJSR(l));
2218 #ifdef LP_SMOVE
2219 putbit("smove", LP_SMOVE(l));
2220 #endif
2221 #ifdef LP_XTNDRNG
2222 putbit("xtndrng", LP_XTNDRNG(l));
2223 #endif
2224 #ifdef LP_ZEROTRIP
2225 putbit("zerotrip", LP_ZEROTRIP(l));
2226 #endif
2227 putline();
2228 } /* dumploop */
2229
2230 void
dumploops()2231 dumploops()
2232 {
2233 int l;
2234 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2235 if (opt.lpb.stg_base == NULL) {
2236 fprintf(dfile, "opt.lpb not allocated\n");
2237 return;
2238 }
2239 dumploop(0);
2240 fprintf(dfile, "\n");
2241 for (l = opt.nloops; l; --l) {
2242 dumploop(LP_LOOP(l));
2243 fprintf(dfile, "\n");
2244 }
2245 } /* dumploops */
2246
2247 void
dstd(int stdx)2248 dstd(int stdx)
2249 {
2250 int astx;
2251 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2252 if (stdx < 0 || stdx >= astb.std.stg_avail) {
2253 fprintf(dfile, "\nstd %d out of range [0:%d)\n", stdx, astb.std.stg_avail);
2254 return;
2255 }
2256 astx = STD_AST(stdx);
2257 putint("std", stdx);
2258 putint("ast", astx);
2259 putnzint("lineno", STD_LINENO(stdx));
2260 putnsym("label", STD_LABEL(stdx));
2261 if (STD_BLKSYM(stdx) != SPTR_NULL)
2262 putnsym("blksym", STD_BLKSYM(stdx));
2263 putint("prev", STD_PREV(stdx));
2264 putint("next", STD_NEXT(stdx));
2265 #ifdef STD_TAG
2266 putnzint("tag", STD_TAG(stdx));
2267 #endif
2268 putnzint("fg", STD_FG(stdx));
2269 putflags("flags", STD_FLAGS(stdx));
2270 putbit("ex", STD_EX(stdx));
2271 putbit("st", STD_ST(stdx));
2272 putbit("br", STD_BR(stdx));
2273 putbit("delete", STD_DELETE(stdx));
2274 putbit("ignore", STD_IGNORE(stdx));
2275 putbit("split/moved", STD_SPLIT(stdx));
2276 putbit("minfo", STD_MINFO(stdx));
2277 putbit("local", STD_LOCAL(stdx));
2278 putbit("pure", STD_PURE(stdx));
2279 putbit("par", STD_PAR(stdx));
2280 putbit("cs", STD_CS(stdx));
2281 putbit("accel", STD_ACCEL(stdx));
2282 putbit("rescope", STD_RESCOPE(stdx));
2283 putbit("indiv", STD_INDIVISIBLE(stdx));
2284 putbit("atomic", STD_ATOMIC(stdx));
2285 putbit("kernel", STD_KERNEL(stdx));
2286 putbit("task", STD_TASK(stdx));
2287 putbit("orig", STD_ORIG(stdx));
2288 putbit("parsect", STD_PARSECT(stdx));
2289 putbit("mark", STD_MARK(stdx));
2290 putbit("ast.callfg", A_CALLFGG(astx));
2291 if (astx) {
2292 putstring("atype", astb.atypes[A_TYPEG(astx)]);
2293 }
2294 putline();
2295 if (STD_LABEL(stdx)) {
2296 putstring(SYMNAME(STD_LABEL(stdx)), "");
2297 putline();
2298 }
2299 dbg_print_ast(astx, dfile);
2300 } /* dstd */
2301
2302 void
dsstd(int stdx)2303 dsstd(int stdx)
2304 {
2305 int astx;
2306 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2307 if (stdx < 0 || stdx >= astb.std.stg_avail) {
2308 fprintf(dfile, "\nstd %d out of range [0:%d)\n", stdx, astb.std.stg_avail);
2309 return;
2310 }
2311 astx = STD_AST(stdx);
2312 fprintf(dfile, "std:%-4d ast:%-5d lineno:%-5d ", stdx, astx,
2313 STD_LINENO(stdx));
2314 dbg_print_ast(astx, dfile);
2315 } /* dsstd */
2316
2317 void
dstdp(int stdx)2318 dstdp(int stdx)
2319 {
2320 dstd(stdx);
2321 if (STD_PTA(stdx)) {
2322 putstdpta(stdx);
2323 }
2324 putstdassigns(stdx);
2325 } /* dstdp */
2326
2327 void
dstdtree(int stdx)2328 dstdtree(int stdx)
2329 {
2330 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2331 if (stdx < 0 || stdx >= astb.std.stg_avail) {
2332 fprintf(dfile, "\nstd %d out of range [0:%d)\n", stdx, astb.std.stg_avail);
2333 return;
2334 }
2335 dstd(stdx);
2336 if (STD_AST(stdx)) {
2337 dastree(STD_AST(stdx));
2338 }
2339 } /* dstdtree */
2340
2341 void
dstds(int std1,int std2)2342 dstds(int std1, int std2)
2343 {
2344 int stdx;
2345 if (std1 <= 0 || std1 >= astb.std.stg_avail)
2346 std1 = STD_NEXT(0);
2347 if (std2 <= 0 || std2 >= astb.std.stg_avail)
2348 std2 = STD_PREV(0);
2349 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2350 fprintf(dfile, "subprogram %d %s:\n", gbl.func_count, SYMNAME(gbl.currsub));
2351 for (stdx = std1; stdx != 0; stdx = STD_NEXT(stdx)) {
2352 dstd(stdx);
2353 if (stdx == std2)
2354 break;
2355 }
2356 } /* dstds */
2357
2358 void
dstdps(int std1,int std2)2359 dstdps(int std1, int std2)
2360 {
2361 int stdx;
2362 if (std1 <= 0 || std1 >= astb.std.stg_avail)
2363 std1 = STD_NEXT(0);
2364 if (std2 <= 0 || std2 >= astb.std.stg_avail)
2365 std2 = STD_PREV(0);
2366 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2367 fprintf(dfile, "subprogram %d %s:\n", gbl.func_count, SYMNAME(gbl.currsub));
2368 for (stdx = std1; stdx != 0; stdx = STD_NEXT(stdx)) {
2369 dstdp(stdx);
2370 if (stdx == std2)
2371 break;
2372 }
2373 } /* dstdps */
2374
2375 /*
2376 * for simpler output
2377 */
2378 void
dsstds(int std1,int std2)2379 dsstds(int std1, int std2)
2380 {
2381 int stdx;
2382 if (std1 <= 0 || std1 >= astb.std.stg_avail)
2383 std1 = STD_NEXT(0);
2384 if (std2 <= 0 || std2 >= astb.std.stg_avail)
2385 std2 = STD_PREV(0);
2386 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2387 fprintf(dfile, "subprogram %d %s:\n", gbl.func_count, SYMNAME(gbl.currsub));
2388 for (stdx = std1; stdx != 0; stdx = STD_NEXT(stdx)) {
2389 dsstd(stdx);
2390 if (stdx == std2)
2391 break;
2392 }
2393 } /* dsstds */
2394
2395 /* dump 'count' before and after stdx */
2396 void
dstdr(int stdx,int count)2397 dstdr(int stdx, int count)
2398 {
2399 int s1, s2, c;
2400 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2401 if (stdx < 0 || stdx >= astb.std.stg_avail) {
2402 fprintf(dfile, "\nstd %d out of range [0:%d)\n", stdx, astb.std.stg_avail);
2403 return;
2404 }
2405 /* go backwards for 'count' */
2406 for (s1 = stdx, c = count; c > 0 && s1 > 0 && s1 <= astb.std.stg_avail;
2407 s1 = STD_PREV(s1), --c)
2408 ;
2409 /* go forwards for 'count' */
2410 for (s2 = stdx, c = count; c > 0 && s2 > 0 && s2 <= astb.std.stg_avail;
2411 s2 = STD_NEXT(s2), --c)
2412 ;
2413 dstds(s1, s2);
2414 } /* dstdr */
2415
2416 void
dstda()2417 dstda()
2418 {
2419 dstds(0, 0);
2420 } /* dstda */
2421
2422 void
dstdpa()2423 dstdpa()
2424 {
2425 putstdassigns(0);
2426 if (STD_PTA(0)) {
2427 putstdpta(0);
2428 }
2429 dstdps(0, 0);
2430 } /* dstdpa */
2431
2432 void
dumpstdtrees()2433 dumpstdtrees()
2434 {
2435 int stdx, std1, std2;
2436 std1 = STD_NEXT(0);
2437 for (stdx = STD_NEXT(0); stdx != 0; stdx = STD_NEXT(stdx)) {
2438 dstdtree(stdx);
2439 if (stdx == STD_PREV(0))
2440 break;
2441 fprintf(dfile, "\n");
2442 }
2443 } /* dumpstdtrees */
2444
2445 void
dsocptr(int sochead)2446 dsocptr(int sochead)
2447 {
2448 int socptr;
2449 if (sochead == 0)
2450 return;
2451 if (sochead < 0 || sochead >= soc.avail) {
2452 putline();
2453 fprintf(dfile, "SOCPTR:%d out of bounds", sochead);
2454 return;
2455 }
2456 putline();
2457 putstring1("symbol overlap list:");
2458 for (socptr = sochead; socptr; socptr = SOC_NEXT(socptr)) {
2459 putsym1(SOC_SPTR(socptr));
2460 }
2461 } /* dsocptr */
2462
2463 void
puttmpltype(char * s,int t)2464 puttmpltype(char *s, int t)
2465 {
2466 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2467 switch (t) {
2468 case REPLICATED:
2469 sprintf(BUF, "%s:replicated", s);
2470 break;
2471 case DISTRIBUTED:
2472 sprintf(BUF, "%s:distributed", s);
2473 break;
2474 case ALIGNED:
2475 sprintf(BUF, "%s:aligned", s);
2476 break;
2477 case INHERITED:
2478 sprintf(BUF, "%s:inherited", s);
2479 break;
2480 default:
2481 sprintf(BUF, "%s:%d", s, t);
2482 break;
2483 }
2484 putit();
2485 } /* puttmpltype */
2486
2487 void
puttmplsc(char * s,int t)2488 puttmplsc(char *s, int t)
2489 {
2490 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2491 switch (t) {
2492 case NONE_SC:
2493 sprintf(BUF, "%s:none", s);
2494 break;
2495 case ALLOC_SC:
2496 sprintf(BUF, "%s:alloc", s);
2497 break;
2498 case DUMMY_SC:
2499 sprintf(BUF, "%s:dummy", s);
2500 break;
2501 case STATIC_SC:
2502 sprintf(BUF, "%s:static", s);
2503 break;
2504 case COMMON_SC:
2505 sprintf(BUF, "%s:common", s);
2506 break;
2507 default:
2508 sprintf(BUF, "%s:%d", s, t);
2509 break;
2510 }
2511 putit();
2512 } /* puttmplsc */
2513
2514 void
puttmplflag(char * s,int f)2515 puttmplflag(char *s, int f)
2516 {
2517 /* single space between flags */
2518 if (f) {
2519 int l = strlen(s);
2520 if (linelen + l >= 79) {
2521 fprintf(dfile, "\n%s", s);
2522 linelen = l;
2523 } else if (linelen > 0) {
2524 fprintf(dfile, " %s", s);
2525 linelen += l + 1;
2526 } else {
2527 fprintf(dfile, "%s", s);
2528 linelen = l;
2529 }
2530 }
2531 } /* puttmplflag */
2532
2533 #ifdef IGNORE_TKRG
2534 static void
put_ignore(char * s,int tkr)2535 put_ignore(char *s, int tkr)
2536 {
2537 if (tkr) {
2538 strcpy(BUF, s);
2539 strcat(BUF, ":");
2540 if ((tkr & IGNORE_TKR_ALL) == IGNORE_TKR_ALL) {
2541 strcat(BUF, "all");
2542 if (tkr & IGNORE_D)
2543 strcat(BUF, "+D");
2544 } else {
2545 if (tkr & IGNORE_T)
2546 strcat(BUF, "T");
2547 if (tkr & IGNORE_K)
2548 strcat(BUF, "K");
2549 if (tkr & IGNORE_R)
2550 strcat(BUF, "R");
2551 if (tkr & IGNORE_D)
2552 strcat(BUF, "D");
2553 if (tkr & IGNORE_M)
2554 strcat(BUF, "M");
2555 if (tkr & IGNORE_C)
2556 strcat(BUF, "C");
2557 }
2558 putit();
2559 }
2560 } /* put_ignore */
2561 #endif
2562
2563 void
dalnd(int alnd)2564 dalnd(int alnd)
2565 {
2566 int i, f;
2567 if (alnd == 0)
2568 return;
2569 if (dtb.base == NULL)
2570 return;
2571 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2572 if (alnd < 0 || alnd >= dtb.avl) {
2573 putline();
2574 fprintf(dfile, "ALND:%d out of bounds 1:%d\n", alnd, dtb.avl);
2575 return;
2576 }
2577 putline();
2578 putint("alnd", alnd);
2579 puttmpltype("type", TMPL_TYPE(alnd));
2580 puttmplsc("alignee_sc", TMPL_ALIGNEE_SC(alnd));
2581 puttmplsc("target_sc", TMPL_TARGET_SC(alnd));
2582 putint("rank", TMPL_RANK(alnd));
2583 f = TMPL_FLAG(alnd);
2584 putbit("sequential", f & __SEQUENTIAL);
2585 f &= ~__SEQUENTIAL;
2586 putbit("assumedsize", f & __ASSUMED_SIZE);
2587 f &= ~__ASSUMED_SIZE;
2588 putbit("assumedshape", f & __ASSUMED_SHAPE);
2589 f &= ~__ASSUMED_SHAPE;
2590 putbit("save", f & __SAVE);
2591 f &= ~__SAVE;
2592 putbit("inherit", f & __INHERIT);
2593 f &= ~__INHERIT;
2594 putbit("dynamic", f & __DYNAMIC);
2595 f &= ~__DYNAMIC;
2596 putbit("pointer", f & __POINTER);
2597 f &= ~__POINTER;
2598 putbit("local", f & __LOCAL);
2599 f &= ~__LOCAL;
2600 putbit("off_template", f & __OFF_TEMPLATE);
2601 f &= ~__OFF_TEMPLATE;
2602 putbit("identify_map", f & __IDENTITY_MAP);
2603 f &= ~__IDENTITY_MAP;
2604 putbit("no_overlaps", f & __NO_OVERLAPS);
2605 f &= ~__NO_OVERLAPS;
2606 putbit("in", f & __INTENT_IN);
2607 f &= ~__INTENT_IN;
2608 putbit("out", f & __INTENT_OUT);
2609 f &= ~__INTENT_OUT;
2610
2611 if ((f & __TRANSCRIPTIVE_DIST_TARGET) == __TRANSCRIPTIVE_DIST_TARGET) {
2612 putstring("disttarget", "transcriptive");
2613 } else if (f & __PRESCRIPTIVE_DIST_TARGET) {
2614 putstring("disttarget", "prescriptive");
2615 } else if (f & __DESCRIPTIVE_DIST_TARGET) {
2616 putstring("disttarget", "descriptive");
2617 } else {
2618 putstring("disttarget", "omitted");
2619 }
2620 f &= ~__TRANSCRIPTIVE_DIST_TARGET;
2621 if ((f & __TRANSCRIPTIVE_DIST_FORMAT) == __TRANSCRIPTIVE_DIST_FORMAT) {
2622 putstring("format", "transcriptive");
2623 } else if (f & __PRESCRIPTIVE_DIST_FORMAT) {
2624 putstring("format", "prescriptive");
2625 } else if (f & __DESCRIPTIVE_DIST_FORMAT) {
2626 putstring("format", "descriptive");
2627 } else {
2628 putstring("format", "omitted");
2629 }
2630 f &= ~__TRANSCRIPTIVE_DIST_FORMAT;
2631 if (f & __PRESCRIPTIVE_ALIGN_TARGET) {
2632 putstring("aligntarget", "prescriptive");
2633 }
2634 f &= ~__PRESCRIPTIVE_ALIGN_TARGET;
2635 if (f & __DESCRIPTIVE_ALIGN_TARGET) {
2636 putstring("aligntarget", "descriptive");
2637 }
2638 f &= ~__DESCRIPTIVE_ALIGN_TARGET;
2639
2640 if (f) {
2641 putnzhex("flag", f);
2642 }
2643 putnzbits("isstar", TMPL_ISSTAR(alnd));
2644 putnzbits("collapse", TMPL_COLLAPSE(alnd));
2645 putline();
2646 putnsym("descr", TMPL_DESCR(alnd));
2647 putnsym("align_target", TMPL_ALIGN_TARGET(alnd));
2648 putnsym("target_descr", TMPL_TARGET_DESCR(alnd));
2649 putnsym("dist_target", TMPL_DIST_TARGET(alnd));
2650 putnsym("dist_target_descr", TMPL_DIST_TARGET_DESCR(alnd));
2651 putline();
2652 for (i = 0; i < TMPL_RANK(alnd); ++i) {
2653 putint("dim", i);
2654 putast("lb", TMPL_LB(alnd, i));
2655 putast("ub", TMPL_UB(alnd, i));
2656 putline();
2657 }
2658 } /* dalnd */
2659
2660 void
dsecd(int secd)2661 dsecd(int secd)
2662 {
2663 int i, any;
2664 if (secd == 0)
2665 return;
2666 if (dtb.base == NULL)
2667 return;
2668 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2669 if (secd < 0 || secd >= dtb.avl) {
2670 putline();
2671 fprintf(dfile, "SECD:%d out of bounds 1:%d\n", secd, dtb.avl);
2672 return;
2673 }
2674 putline();
2675 putint("secd", secd);
2676 putint("rank", INS_RANK(secd));
2677 putnsym("descr", INS_DESCR(secd));
2678 putnsym("template", INS_TEMPLATE(secd));
2679 putdtype("dtype", INS_DTYPE(secd));
2680 putline();
2681 } /* dsecd */
2682
2683 /* dump one symbol */
2684 void
dsym(int sptr)2685 dsym(int sptr)
2686 {
2687 static char namebuff[210], typebuff[300];
2688 int stype, dtype, alnd, secd;
2689 int i;
2690
2691 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
2692
2693 if (sptr < 0 || sptr >= stb.stg_avail) {
2694 fprintf(dfile, "\nsymbol %d out of %d\n", sptr, stb.stg_avail);
2695 return;
2696 }
2697
2698 BCOPY(stb.stg_base, stb.stg_base + sptr, SYM, 1);
2699
2700 strcpy(namebuff, getprint(sptr));
2701 stype = STYPEG(0);
2702 dtype = DTYPEG(0);
2703 typebuff[0] = '\0';
2704 if (dtype)
2705 getdtype(dtype, typebuff);
2706
2707 fprintf(dfile, "\n%-30.30s %s\n", namebuff, typebuff);
2708 linelen = 0;
2709
2710 putint("sptr", sptr);
2711 putint("dtype", DTYPEG(0));
2712 putsc("sc", SCG(0));
2713 putstype("stype", STYPEG(0));
2714 if (UNAMEG(0)) {
2715 putstring("uname", stb.n_base + UNAMEG(0));
2716 }
2717
2718 putline();
2719 DTYPEP(0, 0);
2720 NMPTRP(0, 0);
2721 SCP(0, 0);
2722 UNAMEP(0, 0);
2723
2724 putsym("enclfunc", ENCLFUNCG(0));
2725 putsym("hashlk", HASHLKG(0));
2726 putsym("scope", SCOPEG(0));
2727 putsym("symlk", SYMLKG(0));
2728 putline();
2729 ENCLFUNCP(0, 0);
2730 HASHLKP(0, 0);
2731 SCOPEP(0, 0);
2732 SYMLKP(0, 0);
2733
2734 switch (stype) {
2735 case ST_ARRAY:
2736 case ST_DESCRIPTOR:
2737 case ST_IDENT:
2738 case ST_STRUCT:
2739 case ST_UNION:
2740 case ST_UNKNOWN:
2741 case ST_VAR:
2742 /* three lines: integers, symbols, bits */
2743 if (SCG(sptr) != SC_DUMMY) {
2744 putint("address", ADDRESSG(0));
2745 ADDRESSP(0, 0);
2746 }
2747 putintent("intent", INTENTG(0));
2748 INTENTP(0, 0);
2749 putnzint("paramval", PARAMVALG(0));
2750 PARAMVALP(0, 0);
2751 #ifdef PDALNG
2752 putnzint("pdaln", PDALNG(0));
2753 b4P(0, 0);
2754 #endif
2755 putnzint("socptr", SOCPTRG(0));
2756 SOCPTRP(0, 0);
2757 putline();
2758 putnsym("autobj", AUTOBJG(0));
2759 AUTOBJP(0, 0);
2760 #ifdef BYTELENG
2761 if (DESCARRAYG(0)) {
2762 putnzint("bytelen", BYTELENG(0));
2763 BYTELENP(0, 0);
2764 }
2765 #endif
2766 putnsym("cmblk", CMBLKG(0));
2767 CMBLKP(0, 0);
2768 putnsym("cvlen", CVLENG(0));
2769 CVLENP(0, 0);
2770 putnsym("adjstrlk", ADJSTRLKG(0));
2771 ADJSTRLKP(0, 0);
2772 putnsym("descr", DESCRG(0));
2773 DESCRP(0, 0);
2774 putnsym("midnum", MIDNUMG(0));
2775 MIDNUMP(0, 0);
2776 putnsym("newarg", NEWARGG(0));
2777 NEWARGP(0, 0);
2778 if (SCG(sptr) == SC_DUMMY) {
2779 putnsym("newdsc", NEWDSCG(0));
2780 NEWDSCP(0, 0);
2781 }
2782 #ifdef DEVICECOPYG
2783 if (DEVICECOPYG(sptr)) {
2784 putsym("devcopy(of)", DEVCOPYG(0));
2785 DEVCOPYP(0, 0);
2786 } else {
2787 putnsym("devcopy", DEVCOPYG(0));
2788 DEVCOPYP(0, 0);
2789 }
2790 #endif
2791 #ifdef NMCNSTG
2792 putnsym("nmcnst", NMCNSTG(0));
2793 NMCNSTP(0, 0);
2794 #endif
2795 putnsym("ptroff", PTROFFG(0));
2796 PTROFFP(0, 0);
2797 putnsym("sdsc", SDSCG(0));
2798 SDSCP(0, 0);
2799 #ifdef IGNORE_TKRG
2800 put_ignore("ignore", IGNORE_TKRG(0));
2801 IGNORE_TKRP(0, 0);
2802 #endif
2803 putnsym("slnk", SLNKG(0));
2804 SLNKP(0, 0);
2805 putline();
2806 putbit("addrtkn", ADDRTKNG(0));
2807 ADDRTKNP(0, 0);
2808 putbit("adjarr", ADJARRG(0));
2809 ADJARRP(0, 0);
2810 putbit("adjlen", ADJLENG(0));
2811 ADJLENP(0, 0);
2812 putbit("aftent", AFTENTG(0));
2813 AFTENTP(0, 0);
2814 putbit("alloc", ALLOCG(0));
2815 ALLOCP(0, 0);
2816 #ifdef ALLOCATTRG
2817 putbit("allocattr", ALLOCATTRG(0));
2818 ALLOCATTRP(0, 0);
2819 #endif
2820 putbit("arg", ARGG(0));
2821 ARGP(0, 0);
2822 putbit("assn", ASSNG(0));
2823 ASSNP(0, 0);
2824 putbit("assumlen", ASSUMLENG(0));
2825 ASSUMLENP(0, 0);
2826 putbit("assumshp", ASSUMSHPG(0));
2827 ASSUMSHPP(0, 0);
2828 putbit("asumsz", ASUMSZG(0));
2829 ASUMSZP(0, 0);
2830 putbit("ccsym", CCSYMG(0));
2831 CCSYMP(0, 0);
2832 #ifdef CONSTANTG
2833 putbit("constant", CONSTANTG(0));
2834 CONSTANTP(0, 0);
2835 #endif
2836 putbit("dcld", DCLDG(0));
2837 DCLDP(0, 0);
2838 putbit("descarray", DESCARRAYG(0));
2839 DESCARRAYP(0, 0);
2840 putbit("descused", DESCUSEDG(0));
2841 DESCUSEDP(0, 0);
2842 #ifdef DEVICEG
2843 putbit("device", DEVICEG(0));
2844 DEVICEP(0, 0);
2845 #endif
2846 #ifdef DEVICECOPYG
2847 putbit("devicecopy", DEVICECOPYG(0));
2848 DEVICECOPYP(0, 0);
2849 putbit("devicesd", DEVICESDG(0));
2850 DEVICESDP(0, 0);
2851 #endif
2852 putbit("dinit", DINITG(0));
2853 DINITP(0, 0);
2854 putbit("dovar", DOVARG(0));
2855 DOVARP(0, 0);
2856 #ifdef DYNAMICG
2857 putbit("dynamic", DYNAMICG(0));
2858 DYNAMICP(0, 0);
2859 #endif
2860 putbit("eqv", EQVG(0));
2861 EQVP(0, 0);
2862 #ifdef ERLYSPECG
2863 putbit("erlyspec", ERLYSPECG(0));
2864 ERLYSPECP(0, 0);
2865 #endif
2866 putbit("f90pointer", F90POINTERG(0));
2867 F90POINTERP(0, 0);
2868 putbit("forallndx", FORALLNDXG(0));
2869 FORALLNDXP(0, 0);
2870 putbit("func", FUNCG(0));
2871 FUNCP(0, 0);
2872 putbit("hccsym", HCCSYMG(0));
2873 HCCSYMP(0, 0);
2874 putbit("hidden", HIDDENG(0));
2875 HIDDENP(0, 0);
2876 putbit("ignore", IGNOREG(0));
2877 IGNOREP(0, 0);
2878 #ifdef INHERITP
2879 putbit("inherit", INHERITG(0));
2880 INHERITP(0, 0);
2881 #endif
2882 putbit("internal", INTERNALG(0));
2883 INTERNALP(0, 0);
2884 #ifdef LCLMEMP
2885 putbit("lclmem", LCLMEMG(0));
2886 LCLMEMP(0, 0);
2887 #endif
2888 putbit("lnrzd", LNRZDG(0));
2889 LNRZDP(0, 0);
2890 #ifdef MANAGEDG
2891 putbit("managed", MANAGEDG(0));
2892 MANAGEDP(0, 0);
2893 #endif
2894 putbit("mdalloc", MDALLOCG(0));
2895 MDALLOCP(0, 0);
2896 #ifdef MIRROREDG
2897 putbit("mirrored", MIRROREDG(0));
2898 MIRROREDP(0, 0);
2899 putbit("acccreate", ACCCREATEG(0));
2900 ACCCREATEP(0, 0);
2901 putbit("acccopyin", ACCCOPYING(0));
2902 ACCCOPYINP(0, 0);
2903 putbit("accresident", ACCRESIDENTG(0));
2904 ACCRESIDENTP(0, 0);
2905 putbit("acclink", ACCLINKG(0));
2906 ACCLINKP(0, 0);
2907 #endif
2908 #ifdef MUSTDECLP
2909 putbit("mustdecl", MUSTDECLG(0));
2910 MUSTDECLP(0, 0);
2911 #endif
2912 putbit("nml", NMLG(0));
2913 NMLP(0, 0);
2914 putbit("nomdcom", NOMDCOMG(0));
2915 NOMDCOMP(0, 0);
2916 putbit("nodesc", NODESCG(0));
2917 NODESCP(0, 0);
2918 putbit("optarg", OPTARGG(0));
2919 OPTARGP(0, 0);
2920 putbit("param", PARAMG(0));
2921 PARAMP(0, 0);
2922 #ifdef PASSBYVALP
2923 putbit("passbyval", PASSBYVALG(0));
2924 PASSBYVALP(0, 0);
2925 #endif
2926 #ifdef PE_RESIDENTP
2927 putbit("pe_resident", PE_RESIDENTG(0));
2928 PE_RESIDENTP(0, 0);
2929 #endif
2930 #ifdef PE_PRIVATEP
2931 putbit("pe_private", PE_PRIVATEG(0));
2932 PE_PRIVATEP(0, 0);
2933 #endif
2934 putbit("pointer", POINTERG(0));
2935 POINTERP(0, 0);
2936 putbit("private", PRIVATEG(0));
2937 PRIVATEP(0, 0);
2938 #ifdef PTRRHSG
2939 putbit("ptrrhs", PTRRHSG(0));
2940 PTRRHSP(0, 0);
2941 #endif
2942 putbit("ptrv", PTRVG(0));
2943 PTRVP(0, 0);
2944 putbit("pure", PUREG(0));
2945 PUREP(0, 0);
2946 putbit("impure", IMPUREG(0));
2947 IMPUREP(0, 0);
2948 putbit("qaln", QALNG(0));
2949 QALNP(0, 0);
2950 putbit("ref", REFG(0));
2951 REFP(0, 0);
2952 #ifdef REFLECTEDG
2953 putbit("reflected", REFLECTEDG(0));
2954 REFLECTEDP(0, 0);
2955 #endif
2956 putbit("result", RESULTG(0));
2957 RESULTP(0, 0);
2958 #ifdef RUNTIMEP
2959 putbit("runtime", RUNTIMEG(0));
2960 RUNTIMEP(0, 0);
2961 #endif
2962 putbit("save", SAVEG(0));
2963 SAVEP(0, 0);
2964 #ifdef SCFXP
2965 putbit("scfx", SCFXG(0));
2966 SCFXP(0, 0);
2967 #endif
2968 #ifdef SDSCINITP
2969 putbit("sdscinit", SDSCINITG(0));
2970 SDSCINITP(0, 0);
2971 #endif
2972 #ifdef SDSCCONTIGP
2973 putbit("sdsccontig", SDSCCONTIGG(0));
2974 SDSCCONTIGP(0, 0);
2975 #endif
2976 #ifdef SDSCS1P
2977 putbit("sdscs1", SDSCS1G(0));
2978 SDSCS1P(0, 0);
2979 #endif
2980 putbit("seq", SEQG(0));
2981 SEQP(0, 0);
2982 #ifdef SHAREDP
2983 putbit("shared", SHAREDG(0));
2984 SHAREDP(0, 0);
2985 #endif
2986 #ifdef SYMMETRICP
2987 putbit("symmetric", SYMMETRICG(0));
2988 SYMMETRICP(0, 0);
2989 #endif
2990 putbit("target", TARGETG(0));
2991 TARGETP(0, 0);
2992 #ifdef TEXTUREP
2993 putbit("texture", TEXTUREG(0));
2994 TEXTUREP(0, 0);
2995 #endif
2996 putbit("thread", THREADG(0));
2997 THREADP(0, 0);
2998 #ifdef TQALNP
2999 putbit("tqaln", TQALNG(0));
3000 TQALNP(0, 0);
3001 #endif
3002 putbit("typ8", TYP8G(0));
3003 TYP8P(0, 0);
3004 putbit("vcsym", VCSYMG(0));
3005 VCSYMP(0, 0);
3006 putbit("visit", VISITG(0));
3007 VISITP(0, 0);
3008 putbit("visit2", VISIT2G(0));
3009 VISIT2P(0, 0);
3010 putbit("vol", VOLG(0));
3011 VOLP(0, 0);
3012 #ifdef PARREFP
3013 putbit("parref", PARREFG(0));
3014 PARREFP(0, 0);
3015 #endif
3016 #ifdef CLASSP
3017 putbit("class", CLASSG(0));
3018 CLASSP(0, 0);
3019 #endif
3020 /*
3021 putbit( "#", #G(0) ); #P(0,0);
3022 */
3023 if (SOCPTRG(sptr)) {
3024 dsocptr(SOCPTRG(sptr));
3025 }
3026 break;
3027
3028 case ST_ALIAS:
3029 putnsym("gsame", GSAMEG(0));
3030 GSAMEP(0, 0);
3031 #ifdef CUDAG
3032 putcuda("cuda", CUDAG(0));
3033 CUDAP(0, 0);
3034 #endif
3035 putbit("recur", RECURG(0));
3036 RECURP(0, 0);
3037 putbit("dcld", DCLDG(0));
3038 DCLDP(0, 0);
3039 putbit("ignore", IGNOREG(0));
3040 IGNOREP(0, 0);
3041 putbit("internal", INTERNALG(0));
3042 INTERNALP(0, 0);
3043 putbit("private", PRIVATEG(0));
3044 PRIVATEP(0, 0);
3045 putbit("pure", PUREG(0));
3046 PUREP(0, 0);
3047 putbit("impure", IMPUREG(0));
3048 IMPUREP(0, 0);
3049 putbit("visit", VISITG(0));
3050 VISITP(0, 0);
3051 putbit("visit2", VISIT2G(0));
3052 VISIT2P(0, 0);
3053 break;
3054
3055 case ST_ARRDSC:
3056 alnd = ALNDG(0);
3057 putint("alnd", ALNDG(0));
3058 ALNDP(0, 0);
3059 secd = SECDG(0);
3060 putint("secd", SECDG(0));
3061 SECDP(0, 0);
3062 putline();
3063 putnsym("array", ARRAYG(0));
3064 ARRAYP(0, 0);
3065 putnsym("descr", DESCRG(0));
3066 DESCRP(0, 0);
3067 putnsym("rename", RENAMEG(0));
3068 RENAMEP(0, 0);
3069 putnsym("secdsc", SECDSCG(0));
3070 SECDSCP(0, 0);
3071 putnsym("slnk", SLNKG(0));
3072 SLNKP(0, 0);
3073 putline();
3074 putbit("arg", ARGG(0));
3075 ARGP(0, 0);
3076 putbit("hccsym", HCCSYMG(0));
3077 HCCSYMP(0, 0);
3078 putbit("hidden", HIDDENG(0));
3079 HIDDENP(0, 0);
3080 putbit("ignore", IGNOREG(0));
3081 IGNOREP(0, 0);
3082 putbit("internal", INTERNALG(0));
3083 INTERNALP(0, 0);
3084 putbit("visit", VISITG(0));
3085 VISITP(0, 0);
3086 putbit("visit2", VISIT2G(0));
3087 VISIT2P(0, 0);
3088 dsecd(secd);
3089 break;
3090
3091 case ST_BLOCK:
3092 putint("startline", STARTLINEG(0));
3093 STARTLINEP(0, 0);
3094 putint("endline", ENDLINEG(0));
3095 ENDLINEP(0, 0);
3096 putint("rfcnt", RFCNTG(0));
3097 RFCNTP(0, 0);
3098 putsym("startlab", STARTLABG(0));
3099 STARTLABP(0, 0);
3100 putsym("endlab", ENDLABG(0));
3101 ENDLABP(0, 0);
3102 #ifdef PARUPLEVELG
3103 putsym("paruplevel", PARUPLEVELG(0));
3104 PARUPLEVELP(0, 0);
3105 #endif
3106 putsym("parsyms", PARSYMSG(0));
3107 PARSYMSP(0, 0);
3108 putsym("parsymsct", PARSYMSCTG(0));
3109 PARSYMSCTP(0, 0);
3110 putline();
3111 putbit("defd", DEFDG(0));
3112 DEFDP(0, 0);
3113 break;
3114
3115 case ST_CMBLK:
3116 putint("size", SIZEG(0));
3117 SIZEP(0, 0);
3118 putline();
3119 putnsym("array", ARRAYG(0));
3120 ARRAYP(0, 0);
3121 putsym("cmemf", CMEMFG(0));
3122 CMEMFP(0, 0);
3123 putsym("cmeml", CMEMLG(0));
3124 CMEMLP(0, 0);
3125 putnsym("midnum", MIDNUMG(0));
3126 MIDNUMP(0, 0);
3127 #ifdef PDALNG
3128 putnzint("pdaln", PDALNG(0));
3129 PDALNP(0, 0);
3130 #endif
3131 #ifdef DEVCOPYG
3132 putnsym("devcopy", DEVCOPYG(0));
3133 DEVCOPYP(0, 0);
3134 #endif
3135 putline();
3136 #ifdef ACCCREATEG
3137 putbit("acccreate", ACCCREATEG(0));
3138 ACCCREATEP(0, 0);
3139 putbit("acccopyin", ACCCOPYING(0));
3140 ACCCOPYINP(0, 0);
3141 putbit("accresident", ACCRESIDENTG(0));
3142 ACCRESIDENTP(0, 0);
3143 putbit("acclink", ACCLINKG(0));
3144 ACCLINKP(0, 0);
3145 #endif
3146 putbit("alloc", ALLOCG(0));
3147 ALLOCP(0, 0);
3148 putbit("blankc", BLANKCG(0));
3149 BLANKCP(0, 0);
3150 putbit("cfunc", CFUNCG(0));
3151 CFUNCP(0, 0);
3152 #ifdef CONSTANTG
3153 putbit("constant", CONSTANTG(0));
3154 CONSTANTP(0, 0);
3155 #endif
3156 putbit("dcld", DCLDG(0));
3157 DCLDP(0, 0);
3158 #ifdef DEVICEG
3159 putbit("device", DEVICEG(0));
3160 DEVICEP(0, 0);
3161 #endif
3162 putbit("dinit", DINITG(0));
3163 DINITP(0, 0);
3164 putbit("hccsym", HCCSYMG(0));
3165 HCCSYMP(0, 0);
3166 putbit("hidden", HIDDENG(0));
3167 HIDDENP(0, 0);
3168 #ifdef HOISTEDG
3169 putbit("hoisted", HOISTEDG(0));
3170 HOISTEDP(0, 0);
3171 #endif
3172 putbit("ignore", IGNOREG(0));
3173 IGNOREP(0, 0);
3174 putbit("internal", INTERNALG(0));
3175 INTERNALP(0, 0);
3176 #ifdef MAPPEDG
3177 putbit("mapped", MAPPEDG(0));
3178 MAPPEDP(0, 0);
3179 #endif
3180 #ifdef MUSTDECLP
3181 putbit("mustdecl", MUSTDECLG(0));
3182 MUSTDECLP(0, 0);
3183 #endif
3184 putbit("nodesc", NODESCG(0));
3185 NODESCP(0, 0);
3186 putbit("private", PRIVATEG(0));
3187 PRIVATEP(0, 0);
3188 putbit("qaln", QALNG(0));
3189 QALNP(0, 0);
3190 #ifdef REWRITTENG
3191 putbit("rewritten", REWRITTENG(0));
3192 REWRITTENP(0, 0);
3193 #endif
3194 putbit("save", SAVEG(0));
3195 SAVEP(0, 0);
3196 putbit("seq", SEQG(0));
3197 SEQP(0, 0);
3198 putbit("stdcall", STDCALLG(0));
3199 STDCALLP(0, 0);
3200 putbit("thread", THREADG(0));
3201 THREADP(0, 0);
3202 putbit("visit", VISITG(0));
3203 VISITP(0, 0);
3204 putbit("visit2", VISIT2G(0));
3205 VISIT2P(0, 0);
3206 putbit("vol", VOLG(0));
3207 VOLP(0, 0);
3208 putbit("frommod", FROMMODG(0));
3209 FROMMODP(0, 0);
3210 putsymlk("Members:", CMEMFG(sptr));
3211 break;
3212
3213 case ST_CONST:
3214 putint("address", ADDRESSG(0));
3215 ADDRESSP(0, 0);
3216 putint("conval1g", CONVAL1G(0));
3217 CONVAL1P(0, 0);
3218 putint("conval2g", CONVAL2G(0));
3219 CONVAL2P(0, 0);
3220 putint("conval3g", CONVAL3G(0));
3221 CONVAL3P(0, 0);
3222 putint("conval4g", CONVAL4G(0));
3223 CONVAL4P(0, 0);
3224 putline();
3225 putbit("holl", HOLLG(0));
3226 HOLLP(0, 0);
3227 putbit("internal", INTERNALG(0));
3228 INTERNALP(0, 0);
3229 putbit("private", PRIVATEG(0));
3230 PRIVATEP(0, 0);
3231 putbit("seq", SEQG(0));
3232 SEQP(0, 0);
3233 putbit("visit", VISITG(0));
3234 VISITP(0, 0);
3235 putbit("visit2", VISIT2G(0));
3236 VISIT2P(0, 0);
3237 break;
3238
3239 case ST_CONSTRUCT:
3240 putint("funcline", FUNCLINEG(0));
3241 FUNCLINEP(0, 0);
3242 putbit("visit", VISITG(0));
3243 VISITP(0, 0);
3244 putbit("visit2", VISIT2G(0));
3245 VISIT2P(0, 0);
3246 break;
3247
3248 case ST_CRAY:
3249 case ST_PD:
3250 putinkind("inkind", INKINDG(0));
3251 INKINDP(0, 0);
3252 putnzint("intast", INTASTG(0));
3253 INTASTP(0, 0);
3254 putdtype("inttyp", INTTYPG(0));
3255 INTTYPP(0, 0);
3256 put_inkwd("kwdarg", KWDARGG(0));
3257 KWDARGP(0, 0);
3258 putint("kwdcnt", KWDCNTG(0));
3259 KWDCNTP(0, 0);
3260 putint("pdnum", PDNUMG(0));
3261 PDNUMP(0, 0);
3262 putnname("pnmptr", PNMPTRG(0));
3263 PNMPTRP(0, 0);
3264 putline();
3265 putbit("dcld", DCLDG(0));
3266 DCLDP(0, 0);
3267 putbit("expst", EXPSTG(0));
3268 EXPSTP(0, 0);
3269 putbit("internal", INTERNALG(0));
3270 INTERNALP(0, 0);
3271 putbit("native", NATIVEG(0));
3272 NATIVEP(0, 0);
3273 putbit("typ8", TYP8G(0));
3274 TYP8P(0, 0);
3275 putbit("typd", TYPDG(0));
3276 TYPDP(0, 0);
3277 putbit("visit", VISITG(0));
3278 VISITP(0, 0);
3279 putbit("visit2", VISIT2G(0));
3280 VISIT2P(0, 0);
3281 break;
3282
3283 case ST_ENTRY:
3284 putnzint("bihnum", BIHNUMG(0));
3285 BIHNUMP(0, 0);
3286 putint("dpdsc", DPDSCG(0));
3287 DPDSCP(0, 0);
3288 putnzint("endline", ENDLINEG(0));
3289 ENDLINEP(0, 0);
3290 putint("entnum", ENTNUMG(0));
3291 ENTNUMP(0, 0);
3292 putint("entstd", ENTSTDG(0));
3293 ENTSTDP(0, 0);
3294 #ifdef CUDAG
3295 putcuda("cuda", CUDAG(0));
3296 CUDAP(0, 0);
3297 #endif
3298 putint("funcline", FUNCLINEG(0));
3299 FUNCLINEP(0, 0);
3300 putint("paramct", PARAMCTG(0));
3301 PARAMCTP(0, 0);
3302 putline();
3303 putnsym("gsame", GSAMEG(0));
3304 GSAMEP(0, 0);
3305 putnsym("fval", FVALG(0));
3306 FVALP(0, 0);
3307 #ifdef ACCROUTG
3308 putnzint("accrout", ACCROUTG(0));
3309 ACCROUTP(0, 0);
3310 #endif
3311 putnsym("slnk", SLNKG(0));
3312 SLNKP(0, 0);
3313 putline();
3314 putbit("adjarr", ADJARRG(0));
3315 ADJARRP(0, 0);
3316 putbit("adjlen", ADJLENG(0));
3317 ADJLENP(0, 0);
3318 putbit("aftent", AFTENTG(0));
3319 AFTENTP(0, 0);
3320 putbit("assumlen", ASSUMLENG(0));
3321 ASSUMLENP(0, 0);
3322 putbit("assumshp", ASSUMSHPG(0));
3323 ASSUMSHPP(0, 0);
3324 putbit("asumsz", ASUMSZG(0));
3325 ASUMSZP(0, 0);
3326 putbit("ccsym", CCSYMG(0));
3327 CCSYMP(0, 0);
3328 putbit("cfunc", CFUNCG(0));
3329 CFUNCP(0, 0);
3330 putbit("dcld", DCLDG(0));
3331 DCLDP(0, 0);
3332 putbit("decorate", DECORATEG(0));
3333 DECORATEP(0, 0);
3334 putbit("elemental", ELEMENTALG(0));
3335 ELEMENTALP(0, 0);
3336 putbit("f90pointer", F90POINTERG(0));
3337 F90POINTERP(0, 0);
3338 putbit("func", FUNCG(0));
3339 FUNCP(0, 0);
3340 putbit("hidden", HIDDENG(0));
3341 HIDDENP(0, 0);
3342 putbit("inmodule", INMODULEG(0));
3343 INMODULEP(0, 0);
3344 putbit("ancestor", ANCESTORG(0));
3345 ANCESTORP(0, 0);
3346 putbit("internal", INTERNALG(0));
3347 INTERNALP(0, 0);
3348 putbit("mscall", MSCALLG(0));
3349 MSCALLP(0, 0);
3350 putbit("pointer", POINTERG(0));
3351 POINTERP(0, 0);
3352 putbit("private", PRIVATEG(0));
3353 PRIVATEP(0, 0);
3354 putbit("ptrarg", PTRARGG(0));
3355 PTRARGP(0, 0);
3356 putbit("pure", PUREG(0));
3357 PUREP(0, 0);
3358 putbit("impure", IMPUREG(0));
3359 IMPUREP(0, 0);
3360 putbit("recur", RECURG(0));
3361 RECURP(0, 0);
3362 putbit("result", RESULTG(0));
3363 RESULTP(0, 0);
3364 putbit("seq", SEQG(0));
3365 SEQP(0, 0);
3366 putbit("stdcall", STDCALLG(0));
3367 STDCALLP(0, 0);
3368 putbit("typ8", TYP8G(0));
3369 TYP8P(0, 0);
3370 putbit("typd", TYPDG(0));
3371 TYPDP(0, 0);
3372 putbit("visit", VISITG(0));
3373 VISITP(0, 0);
3374 putbit("visit2", VISIT2G(0));
3375 VISIT2P(0, 0);
3376 putline();
3377 putparam(DPDSCG(sptr), PARAMCTG(sptr));
3378 break;
3379
3380 case ST_GENERIC:
3381 putinkind("inkind", INKINDG(0));
3382 INKINDP(0, 0);
3383 putnzint("intast", INTASTG(0));
3384 INTASTP(0, 0);
3385 putint("kindpos", KINDPOSG(0));
3386 KINDPOSP(0, 0);
3387 putint("kwdarg", KWDARGG(0));
3388 KWDARGP(0, 0);
3389 putint("kwdcnt", KWDCNTG(0));
3390 KWDCNTP(0, 0);
3391 putline();
3392 putnsym("gcmplx", GCMPLXG(0));
3393 GCMPLXP(0, 0);
3394 putnsym("gdble", GDBLEG(0));
3395 GDBLEP(0, 0);
3396 putnsym("gdcmplx", GDCMPLXG(0));
3397 GDCMPLXP(0, 0);
3398 putnsym("gint", GINTG(0));
3399 GINTP(0, 0);
3400 putnsym("gint8", GINT8G(0));
3401 GINT8P(0, 0);
3402 putnsym("gqcmplx", GQCMPLXG(0));
3403 GQCMPLXP(0, 0);
3404 putnsym("gquad", GQUADG(0));
3405 GQUADP(0, 0);
3406 putnsym("greal", GREALG(0));
3407 GREALP(0, 0);
3408 putnsym("gsame", GSAMEG(0));
3409 GSAMEP(0, 0);
3410 putnsym("gsint", GSINTG(0));
3411 GSINTP(0, 0);
3412 putline();
3413 putbit("arg", ARGG(0));
3414 ARGP(0, 0);
3415 putbit("dcld", DCLDG(0));
3416 DCLDP(0, 0);
3417 putbit("expst", EXPSTG(0));
3418 EXPSTP(0, 0);
3419 putbit("typd", TYPDG(0));
3420 TYPDP(0, 0);
3421 putbit("visit", VISITG(0));
3422 VISITP(0, 0);
3423 putbit("visit2", VISIT2G(0));
3424 VISIT2P(0, 0);
3425 break;
3426
3427 case ST_INTRIN:
3428 putdtype("argtyp", ARGTYPG(0));
3429 ARGTYPP(0, 0);
3430 putnzint("arrayf", ARRAYFG(0));
3431 ARRAYFP(0, 0);
3432 putnzint("ilm", ILMG(0));
3433 ILMP(0, 0);
3434 putinkind("inkind", INKINDG(0));
3435 INKINDP(0, 0);
3436 putnzint("intast", INTASTG(0));
3437 INTASTP(0, 0);
3438 putdtype("inttyp", INTTYPG(0));
3439 INTTYPP(0, 0);
3440 put_inkwd("kwdarg", KWDARGG(0));
3441 KWDARGP(0, 0);
3442 putint("kwdcnt", KWDCNTG(0));
3443 KWDCNTP(0, 0);
3444 putnname("pnmptr", PNMPTRG(0));
3445 PNMPTRP(0, 0);
3446 putint("paramct", PARAMCTG(0));
3447 PARAMCTP(0, 0);
3448 putline();
3449 putbit("addrtkn", ADDRTKNG(0));
3450 ADDRTKNP(0, 0);
3451 putbit("arg", ARGG(0));
3452 ARGP(0, 0);
3453 putbit("dcld", DCLDG(0));
3454 DCLDP(0, 0);
3455 putbit("expst", EXPSTG(0));
3456 EXPSTP(0, 0);
3457 putbit("native", NATIVEG(0));
3458 NATIVEP(0, 0);
3459 #ifdef PTRRHSG
3460 putbit("ptrrhs", PTRRHSG(0));
3461 PTRRHSP(0, 0);
3462 #endif
3463 putbit("target", TARGETG(0));
3464 TARGETP(0, 0);
3465 putbit("typd", TYPDG(0));
3466 TYPDP(0, 0);
3467 putbit("visit", VISITG(0));
3468 VISITP(0, 0);
3469 putbit("visit2", VISIT2G(0));
3470 VISIT2P(0, 0);
3471 break;
3472
3473 case ST_MODULE:
3474 putint("base", CMEMFG(0));
3475 CMEMFP(0, 0);
3476 putnzint("endline", ENDLINEG(0));
3477 ENDLINEP(0, 0);
3478 #ifdef CUDAG
3479 putcuda("cuda", CUDAG(0));
3480 CUDAP(0, 0);
3481 #endif
3482 putint("funcline", FUNCLINEG(0));
3483 FUNCLINEP(0, 0);
3484 putline();
3485 putbit("dcld", DCLDG(0));
3486 DCLDP(0, 0);
3487 putbit("dinit", DINITG(0));
3488 DINITP(0, 0);
3489 putbit("needmod", NEEDMODG(0));
3490 NEEDMODP(0, 0);
3491 putbit("ancestor", ANCESTORG(0));
3492 ANCESTORP(0, 0);
3493 putbit("typd", TYPDG(0));
3494 TYPDP(0, 0);
3495 putbit("visit", VISITG(0));
3496 VISITP(0, 0);
3497 putbit("visit2", VISIT2G(0));
3498 VISIT2P(0, 0);
3499 break;
3500
3501 case ST_PROC:
3502 putnzint("address", ADDRESSG(0));
3503 ADDRESSP(0, 0);
3504 putint("dpdsc", DPDSCG(0));
3505 DPDSCP(0, 0);
3506 putnzint("endline", ENDLINEG(0));
3507 ENDLINEP(0, 0);
3508 #ifdef CUDAG
3509 putcuda("cuda", CUDAG(0));
3510 CUDAP(0, 0);
3511 #endif
3512 putnzint("funcline", FUNCLINEG(0));
3513 FUNCLINEP(0, 0);
3514 putintent("intent", INTENTG(0));
3515 INTENTP(0, 0);
3516 putint("paramct", PARAMCTG(0));
3517 PARAMCTP(0, 0);
3518 putline();
3519 putnsym("gsame", GSAMEG(0));
3520 GSAMEP(0, 0);
3521 putnsym("fval", FVALG(0));
3522 FVALP(0, 0);
3523 #ifdef ACCROUTG
3524 putnzint("accrout", ACCROUTG(0));
3525 ACCROUTP(0, 0);
3526 #endif
3527 putnsym("altname", ALTNAMEG(0));
3528 ALTNAMEP(0, 0);
3529 putnsym("slnk", SLNKG(0));
3530 SLNKP(0, 0);
3531 #ifdef VTOFFP
3532 putnzint("vtoff", VTOFFG(0));
3533 VTOFFP(0, 0);
3534 #endif
3535 #ifdef TBPLNKP
3536 putnzint("tbplnk", TBPLNKG(0));
3537 TBPLNKP(0, 0);
3538 #endif
3539 #ifdef INVOBJP
3540 putnzint("invobj", INVOBJG(0));
3541 INVOBJP(0, 0);
3542 #endif
3543 putline();
3544 putbit("adjarr", ADJARRG(0));
3545 ADJARRP(0, 0);
3546 putbit("adjlen", ADJLENG(0));
3547 ADJLENP(0, 0);
3548 putbit("arg", ARGG(0));
3549 ARGP(0, 0);
3550 putbit("asumsz", ASUMSZG(0));
3551 ASUMSZP(0, 0);
3552 putbit("assumlen", ASSUMLENG(0));
3553 ASSUMLENP(0, 0);
3554 putbit("assumshp", ASSUMSHPG(0));
3555 ASSUMSHPP(0, 0);
3556 putbit("cfunc", CFUNCG(0));
3557 CFUNCP(0, 0);
3558 putbit("ccsym", CCSYMG(0));
3559 CCSYMP(0, 0);
3560 putbit("dcld", DCLDG(0));
3561 DCLDP(0, 0);
3562 putbit("decorate", DECORATEG(0));
3563 DECORATEP(0, 0);
3564 putbit("func", FUNCG(0));
3565 FUNCP(0, 0);
3566 putbit("hccsym", HCCSYMG(0));
3567 HCCSYMP(0, 0);
3568 putbit("hidden", HIDDENG(0));
3569 HIDDENP(0, 0);
3570 putbit("ignore", IGNOREG(0));
3571 IGNOREP(0, 0);
3572 putbit("indep", INDEPG(0));
3573 INDEPP(0, 0);
3574 putbit("inmodule", INMODULEG(0));
3575 INMODULEP(0, 0);
3576 putbit("ancestor", ANCESTORG(0));
3577 ANCESTORP(0, 0);
3578 putbit("internal", INTERNALG(0));
3579 INTERNALP(0, 0);
3580 #ifdef L3FG
3581 putbit("l3f", L3FG(0));
3582 L3FP(0, 0);
3583 #endif
3584 #ifdef LIBMP
3585 putbit("libm", LIBMG(0));
3586 LIBMP(0, 0);
3587 #endif
3588 putbit("mscall", MSCALLG(0));
3589 MSCALLP(0, 0);
3590 #ifdef MUSTDECLP
3591 putbit("mustdecl", MUSTDECLG(0));
3592 MUSTDECLP(0, 0);
3593 #endif
3594 putbit("nocomm", NOCOMMG(0));
3595 NOCOMMP(0, 0);
3596 putbit("nodesc", NODESCG(0));
3597 NODESCP(0, 0);
3598 putbit("optarg", OPTARGG(0));
3599 OPTARGP(0, 0);
3600 #ifdef PASSBYREFP
3601 putbit("passbyref", PASSBYREFG(0));
3602 PASSBYREFP(0, 0);
3603 #endif
3604 #ifdef PASSBYVALP
3605 putbit("passbyval", PASSBYVALG(0));
3606 PASSBYVALP(0, 0);
3607 #endif
3608 putbit("pointer", POINTERG(0));
3609 POINTERP(0, 0);
3610 putbit("private", PRIVATEG(0));
3611 PRIVATEP(0, 0);
3612 putbit("ptrarg", PTRARGG(0));
3613 PTRARGP(0, 0);
3614 putbit("pure", PUREG(0));
3615 PUREP(0, 0);
3616 putbit("impure", IMPUREG(0));
3617 IMPUREP(0, 0);
3618 putbit("recur", RECURG(0));
3619 RECURP(0, 0);
3620 putbit("ref", REFG(0));
3621 REFP(0, 0);
3622 putbit("result", RESULTG(0));
3623 RESULTP(0, 0);
3624 putbit("sdscsafe", SDSCSAFEG(0));
3625 SDSCSAFEP(0, 0);
3626 putbit("sequent", SEQUENTG(0));
3627 SEQUENTP(0, 0);
3628 putbit("stdcall", STDCALLG(0));
3629 STDCALLP(0, 0);
3630 putbit("typ8", TYP8G(0));
3631 TYP8P(0, 0);
3632 putbit("typd", TYPDG(0));
3633 TYPDP(0, 0);
3634 putbit("visit", VISITG(0));
3635 VISITP(0, 0);
3636 putbit("visit2", VISIT2G(0));
3637 VISIT2P(0, 0);
3638 #ifdef CLASSP
3639 putbit("class", CLASSG(0));
3640 CLASSP(0, 0);
3641 #endif
3642 putparam(DPDSCG(sptr), PARAMCTG(sptr));
3643 break;
3644
3645 case ST_LABEL:
3646 putint("address", ADDRESSG(0));
3647 ADDRESSP(0, 0);
3648 putnzint("iliblk", ILIBLKG(0));
3649 ILIBLKP(0, 0);
3650 putnzint("fmtpt", FMTPTG(0));
3651 FMTPTP(0, 0);
3652 putint("rfcnt", RFCNTG(0));
3653 RFCNTP(0, 0);
3654 putline();
3655 putbit("assn", ASSNG(0));
3656 ASSNP(0, 0);
3657 putbit("ccsym", CCSYMG(0));
3658 CCSYMP(0, 0);
3659 putbit("dcld", DCLDG(0));
3660 DCLDP(0, 0);
3661 putbit("defd", DEFDG(0));
3662 DEFDP(0, 0);
3663 putbit("internal", INTERNALG(0));
3664 INTERNALP(0, 0);
3665 putbit("target", TARGETG(0));
3666 TARGETP(0, 0);
3667 putbit("visit", VISITG(0));
3668 VISITP(0, 0);
3669 putbit("visit2", VISIT2G(0));
3670 VISIT2P(0, 0);
3671 putbit("vol", VOLG(0));
3672 VOLP(0, 0);
3673 break;
3674
3675 case ST_MEMBER:
3676 putint("address", ADDRESSG(0));
3677 ADDRESSP(0, 0);
3678 #ifdef BYTELENG
3679 if (DESCARRAYG(0)) {
3680 putnzint("bytelen", BYTELENG(0));
3681 BYTELENP(0, 0);
3682 }
3683 #endif
3684 putnzint("encldtype", ENCLDTYPEG(0));
3685 ENCLDTYPEP(0, 0);
3686 putline();
3687 putnsym("descr", DESCRG(0));
3688 DESCRP(0, 0);
3689 putnsym("midnum", MIDNUMG(0));
3690 MIDNUMP(0, 0);
3691 putsym("psmem", PSMEMG(0));
3692 PSMEMP(0, 0);
3693 putnsym("ptroff", PTROFFG(0));
3694 PTROFFP(0, 0);
3695 putnsym("sdsc", SDSCG(0));
3696 SDSCP(0, 0);
3697 putsym("variant", VARIANTG(0));
3698 VARIANTP(0, 0);
3699 #ifdef BINDP
3700 putnsym("bind", BINDG(0));
3701 BINDP(0, 0);
3702 #endif
3703 #ifdef VTABLEP
3704 putnsym("vtable", VTABLEG(0));
3705 VTABLEP(0, 0);
3706 #endif
3707 #ifdef PASSP
3708 putnsym("pass", PASSG(0));
3709 PASSP(0, 0);
3710 #endif
3711 putline();
3712 /*putbit( "adjarr", ADJARRG(0) ); ADJARRP(0,0);*/
3713 putbit("alloc", ALLOCG(0));
3714 ALLOCP(0, 0);
3715 #ifdef ALLOCATTRG
3716 putbit("allocattr", ALLOCATTRG(0));
3717 ALLOCATTRP(0, 0);
3718 #endif
3719 putbit("arg", ARGG(0));
3720 ARGP(0, 0);
3721 putbit("assn", ASSNG(0));
3722 ASSNP(0, 0);
3723 putbit("ccsym", CCSYMG(0));
3724 CCSYMP(0, 0);
3725 putbit("dcld", DCLDG(0));
3726 DCLDP(0, 0);
3727 putbit("descarray", DESCARRAYG(0));
3728 DESCARRAYP(0, 0);
3729 putbit("descused", DESCUSEDG(0));
3730 DESCUSEDP(0, 0);
3731 putbit("dinit", DINITG(0));
3732 DINITP(0, 0);
3733 putbit("end", ENDG(0));
3734 ENDP(0, 0);
3735 putbit("f90pointer", F90POINTERG(0));
3736 F90POINTERP(0, 0);
3737 putbit("fnml", FNMLG(0));
3738 FNMLP(0, 0);
3739 putbit("hccsym", HCCSYMG(0));
3740 HCCSYMP(0, 0);
3741 putbit("hidden", HIDDENG(0));
3742 HIDDENP(0, 0);
3743 putbit("ignore", IGNOREG(0));
3744 IGNOREP(0, 0);
3745 #ifdef INHERITP
3746 putbit("inherit", INHERITG(0));
3747 INHERITP(0, 0);
3748 #endif
3749 putbit("internal", INTERNALG(0));
3750 INTERNALP(0, 0);
3751 putbit("lnrzd", LNRZDG(0));
3752 LNRZDP(0, 0);
3753 putbit("nodesc", NODESCG(0));
3754 NODESCP(0, 0);
3755 putbit("pointer", POINTERG(0));
3756 POINTERP(0, 0);
3757 putbit("private", PRIVATEG(0));
3758 PRIVATEP(0, 0);
3759 putbit("ptrv", PTRVG(0));
3760 PTRVP(0, 0);
3761 putbit("ref", REFG(0));
3762 REFP(0, 0);
3763 #ifdef SDSCCONTIGP
3764 putbit("sdsccontig", SDSCCONTIGG(0));
3765 SDSCCONTIGP(0, 0);
3766 #endif
3767 #ifdef SDSCS1P
3768 putbit("sdscs1", SDSCS1G(0));
3769 SDSCS1P(0, 0);
3770 #endif
3771 #ifdef CLASSP
3772 putbit("class", CLASSG(0));
3773 CLASSP(0, 0);
3774 #endif
3775 putbit("visit", VISITG(0));
3776 VISITP(0, 0);
3777 putbit("visit2", VISIT2G(0));
3778 VISIT2P(0, 0);
3779 break;
3780
3781 case ST_MODPROC:
3782 putint("funcline", FUNCLINEG(0));
3783 FUNCLINEP(0, 0);
3784 putint("symi", SYMIG(0));
3785 SYMIP(0, 0);
3786 putnsym("gsame", GSAMEG(0));
3787 GSAMEP(0, 0);
3788 putbit("dcld", DCLDG(0));
3789 DCLDP(0, 0);
3790 putbit("private", PRIVATEG(0));
3791 PRIVATEP(0, 0);
3792 putbit("typd", TYPDG(0));
3793 TYPDP(0, 0);
3794 putbit("visit", VISITG(0));
3795 VISITP(0, 0);
3796 putbit("visit2", VISIT2G(0));
3797 VISIT2P(0, 0);
3798 putline();
3799 putsymilist(SYMIG(sptr));
3800 break;
3801
3802 case ST_NML:
3803 putsym("plist", ADDRESSG(0));
3804 ADDRESSP(0, 0);
3805 putsym("cmemf", CMEMFG(0));
3806 CMEMFP(0, 0);
3807 putsym("cmeml", CMEMLG(0));
3808 CMEMLP(0, 0);
3809 putline();
3810 putbit("dcld", DCLDG(0));
3811 DCLDP(0, 0);
3812 putbit("internal", INTERNALG(0));
3813 INTERNALP(0, 0);
3814 putbit("ref", REFG(0));
3815 REFP(0, 0);
3816 putbit("visit", VISITG(0));
3817 VISITP(0, 0);
3818 putbit("visit2", VISIT2G(0));
3819 VISIT2P(0, 0);
3820 putline();
3821 for (i = CMEMFG(sptr); i; i = NML_NEXT(i)) {
3822 putsym1(NML_SPTR(i));
3823 }
3824 break;
3825
3826 case ST_OPERATOR:
3827 putnzint("gncnt", GNCNTG(0));
3828 GNCNTP(0, 0);
3829 putnzint("gndsc", GNDSCG(0));
3830 GNDSCP(0, 0);
3831 putinkind("inkind", INKINDG(0));
3832 INKINDP(0, 0);
3833 putnname("pdnum", PDNUMG(0));
3834 PDNUMP(0, 0);
3835 putline();
3836 putbit("dcld", DCLDG(0));
3837 DCLDP(0, 0);
3838 putbit("private", PRIVATEG(0));
3839 PRIVATEP(0, 0);
3840 putbit("visit", VISITG(0));
3841 VISITP(0, 0);
3842 putbit("visit2", VISIT2G(0));
3843 VISIT2P(0, 0);
3844 putline();
3845 putsymilist(GNDSCG(sptr));
3846 break;
3847
3848 case ST_PARAM:
3849 putint("conval1g", CONVAL1G(0));
3850 CONVAL1P(0, 0);
3851 putint("conval2g", CONVAL2G(0));
3852 CONVAL2P(0, 0);
3853 putint("paramval", PARAMVALG(0));
3854 PARAMVALP(0, 0);
3855 putnsym("slnk", SLNKG(0));
3856 SLNKP(0, 0);
3857 putline();
3858 #ifdef CONSTANTG
3859 putbit("constant", CONSTANTG(0));
3860 CONSTANTP(0, 0);
3861 #endif
3862 putbit("dcld", DCLDG(0));
3863 DCLDP(0, 0);
3864 putbit("end", ENDG(0));
3865 ENDP(0, 0);
3866 putbit("hccsym", HCCSYMG(0));
3867 HCCSYMP(0, 0);
3868 putbit("hidden", HIDDENG(0));
3869 HIDDENP(0, 0);
3870 putbit("ignore", IGNOREG(0));
3871 IGNOREP(0, 0);
3872 putbit("internal", INTERNALG(0));
3873 INTERNALP(0, 0);
3874 putbit("nodesc", NODESCG(0));
3875 NODESCP(0, 0);
3876 putbit("param", PARAMG(0));
3877 PARAMP(0, 0);
3878 putbit("private", PRIVATEG(0));
3879 PRIVATEP(0, 0);
3880 putbit("ref", REFG(0));
3881 REFP(0, 0);
3882 #ifdef RUNTIMEP
3883 putbit("runtime", RUNTIMEG(0));
3884 RUNTIMEP(0, 0);
3885 #endif
3886 putbit("typd", TYPDG(0));
3887 TYPDP(0, 0);
3888 putbit("vax", VAXG(0));
3889 VAXP(0, 0);
3890 putbit("visit", VISITG(0));
3891 VISITP(0, 0);
3892 putbit("visit2", VISIT2G(0));
3893 VISIT2P(0, 0);
3894 break;
3895
3896 case ST_PLIST:
3897 putint("address", ADDRESSG(0));
3898 ADDRESSP(0, 0);
3899 putnzint("deflab", DEFLABG(0));
3900 DEFLABP(0, 0);
3901 putint("pllen", PLLENG(0));
3902 PLLENP(0, 0);
3903 putnzint("swel", SWELG(0));
3904 SWELP(0, 0);
3905 putnsym("cmblk", CMBLKG(0));
3906 CMBLKP(0, 0);
3907 putline();
3908 putbit("ccsym", CCSYMG(0));
3909 CCSYMP(0, 0);
3910 putbit("dcld", DCLDG(0));
3911 DCLDP(0, 0);
3912 putbit("dinit", DINITG(0));
3913 DINITP(0, 0);
3914 putbit("hccsym", HCCSYMG(0));
3915 HCCSYMP(0, 0);
3916 putbit("hidden", HIDDENG(0));
3917 HIDDENP(0, 0);
3918 putbit("ignore", IGNOREG(0));
3919 IGNOREP(0, 0);
3920 putbit("internal", INTERNALG(0));
3921 INTERNALP(0, 0);
3922 putbit("ref", REFG(0));
3923 REFP(0, 0);
3924 putbit("visit", VISITG(0));
3925 VISITP(0, 0);
3926 putbit("visit2", VISIT2G(0));
3927 VISIT2P(0, 0);
3928 break;
3929
3930 case ST_STAG:
3931 putbit("dcld", DCLDG(0));
3932 DCLDP(0, 0);
3933 putbit("ignore", IGNOREG(0));
3934 IGNOREP(0, 0);
3935 putbit("internal", INTERNALG(0));
3936 INTERNALP(0, 0);
3937 putbit("nest", NESTG(0));
3938 NESTP(0, 0);
3939 putbit("visit", VISITG(0));
3940 VISITP(0, 0);
3941 putbit("visit2", VISIT2G(0));
3942 VISIT2P(0, 0);
3943 break;
3944
3945 case ST_STFUNC:
3946 putint("excvlen", EXCVLENG(0));
3947 EXCVLENP(0, 0);
3948 putint("paramct", PARAMCTG(0));
3949 PARAMCTP(0, 0);
3950 putint("sfast", SFASTG(0));
3951 SFASTP(0, 0);
3952 putint("sfdsc", SFDSCG(0));
3953 SFDSCP(0, 0);
3954 putline();
3955 putbit("dcld", DCLDG(0));
3956 DCLDP(0, 0);
3957 putbit("ignore", IGNOREG(0));
3958 IGNOREP(0, 0);
3959 putbit("internal", INTERNALG(0));
3960 INTERNALP(0, 0);
3961 putbit("typ8", TYP8G(0));
3962 TYP8P(0, 0);
3963 putbit("visit", VISITG(0));
3964 VISITP(0, 0);
3965 putbit("visit2", VISIT2G(0));
3966 VISIT2P(0, 0);
3967 break;
3968
3969 case ST_TYPEDEF:
3970 putnsym("typdef_init", TYPDEF_INITG(0));
3971 TYPDEF_INITP(0, 0);
3972 #ifdef PARENTG
3973 putnsym("parent", PARENTG(0));
3974 PARENTP(0, 0);
3975 #endif
3976 #ifdef VTOFFP
3977 putnzint("vtoff", VTOFFG(0));
3978 VTOFFP(0, 0);
3979 #endif
3980 putnsym("sdsc", SDSCG(0));
3981 SDSCP(0, 0);
3982 putline();
3983 putbit("dcld", DCLDG(0));
3984 DCLDP(0, 0);
3985 putbit("dinit", DINITG(0));
3986 DINITP(0, 0);
3987 putbit("distmem", DISTMEMG(0));
3988 DISTMEMP(0, 0);
3989 putbit("ignore", IGNOREG(0));
3990 IGNOREP(0, 0);
3991 putbit("internal", INTERNALG(0));
3992 INTERNALP(0, 0);
3993 putbit("pointer", POINTERG(0));
3994 POINTERP(0, 0);
3995 putbit("private", PRIVATEG(0));
3996 PRIVATEP(0, 0);
3997 putbit("seq", SEQG(0));
3998 SEQP(0, 0);
3999 putbit("visit", VISITG(0));
4000 VISITP(0, 0);
4001 putbit("visit2", VISIT2G(0));
4002 VISIT2P(0, 0);
4003 putbit("frommod", FROMMODG(0));
4004 FROMMODP(0, 0);
4005 #ifdef ALLOCFLDG
4006 putbit("allocfld", ALLOCFLDG(0));
4007 ALLOCFLDP(0, 0);
4008 #endif
4009 #ifdef CLASSP
4010 putbit("class", CLASSG(0));
4011 CLASSP(0, 0);
4012 #endif
4013 putbit("descused", DESCUSEDG(0));
4014 DESCUSEDP(0, 0);
4015 break;
4016
4017 case ST_USERGENERIC:
4018 putnzint("gncnt", GNCNTG(0));
4019 GNCNTP(0, 0);
4020 putnzint("gndsc", GNDSCG(0));
4021 GNDSCP(0, 0);
4022 putnsym("gsame", GSAMEG(0));
4023 GSAMEP(0, 0);
4024 putline();
4025 putbit("dcld", DCLDG(0));
4026 DCLDP(0, 0);
4027 putbit("expst", EXPSTG(0));
4028 EXPSTP(0, 0);
4029 putbit("private", PRIVATEG(0));
4030 PRIVATEP(0, 0);
4031 putbit("visit", VISITG(0));
4032 VISITP(0, 0);
4033 putbit("visit2", VISIT2G(0));
4034 VISIT2P(0, 0);
4035 putline();
4036 putsymilist(GNDSCG(sptr));
4037 break;
4038
4039 } /* switch(stype) */
4040 putline();
4041
4042 STYPEP(0, 0);
4043 check("b3", stb.stg_base[0].b3);
4044 check("b4", stb.stg_base[0].b4);
4045 check("f1", stb.stg_base[0].f1);
4046 check("f1", stb.stg_base[0].f2);
4047 check("f3", stb.stg_base[0].f3);
4048 check("f4", stb.stg_base[0].f4);
4049 check("f5", stb.stg_base[0].f5);
4050 check("f6", stb.stg_base[0].f6);
4051 check("f7", stb.stg_base[0].f7);
4052 check("f8", stb.stg_base[0].f8);
4053 check("f9", stb.stg_base[0].f9);
4054 check("f10", stb.stg_base[0].f10);
4055 check("f11", stb.stg_base[0].f11);
4056 check("f12", stb.stg_base[0].f12);
4057 check("f13", stb.stg_base[0].f13);
4058 check("f14", stb.stg_base[0].f14);
4059 check("f15", stb.stg_base[0].f15);
4060 check("f16", stb.stg_base[0].f16);
4061 check("f17", stb.stg_base[0].f17);
4062 check("f18", stb.stg_base[0].f18);
4063 check("f19", stb.stg_base[0].f19);
4064 check("f20", stb.stg_base[0].f20);
4065 check("f21", stb.stg_base[0].f21);
4066 check("f22", stb.stg_base[0].f22);
4067 check("f23", stb.stg_base[0].f23);
4068 check("f24", stb.stg_base[0].f24);
4069 check("f25", stb.stg_base[0].f25);
4070 check("f26", stb.stg_base[0].f26);
4071 check("f27", stb.stg_base[0].f27);
4072 check("f28", stb.stg_base[0].f28);
4073 check("f29", stb.stg_base[0].f29);
4074 check("f30", stb.stg_base[0].f30);
4075 check("f31", stb.stg_base[0].f31);
4076 check("f32", stb.stg_base[0].f32);
4077 check("f33", stb.stg_base[0].f33);
4078 check("f34", stb.stg_base[0].f34);
4079 check("f35", stb.stg_base[0].f35);
4080 check("f36", stb.stg_base[0].f36);
4081 check("f37", stb.stg_base[0].f37);
4082 check("f38", stb.stg_base[0].f38);
4083 check("f39", stb.stg_base[0].f39);
4084 check("f40", stb.stg_base[0].f40);
4085 check("f41", stb.stg_base[0].f41);
4086 check("f42", stb.stg_base[0].f42);
4087 check("f43", stb.stg_base[0].f43);
4088 check("f44", stb.stg_base[0].f44);
4089 check("f45", stb.stg_base[0].f45);
4090 check("f46", stb.stg_base[0].f46);
4091 check("f47", stb.stg_base[0].f47);
4092 check("f48", stb.stg_base[0].f48);
4093 check("f49", stb.stg_base[0].f49);
4094 check("f50", stb.stg_base[0].f50);
4095 check("f51", stb.stg_base[0].f51);
4096 check("f52", stb.stg_base[0].f52);
4097 check("f53", stb.stg_base[0].f53);
4098 check("f54", stb.stg_base[0].f54);
4099 check("f55", stb.stg_base[0].f55);
4100 check("f56", stb.stg_base[0].f56);
4101 check("f57", stb.stg_base[0].f57);
4102 check("f58", stb.stg_base[0].f58);
4103 check("f59", stb.stg_base[0].f59);
4104 check("f60", stb.stg_base[0].f60);
4105 check("f61", stb.stg_base[0].f61);
4106 check("f62", stb.stg_base[0].f62);
4107 check("f63", stb.stg_base[0].f63);
4108 check("f64", stb.stg_base[0].f64);
4109 check("f65", stb.stg_base[0].f65);
4110 check("f66", stb.stg_base[0].f66);
4111 check("f67", stb.stg_base[0].f67);
4112 check("f68", stb.stg_base[0].f68);
4113 check("f69", stb.stg_base[0].f69);
4114 check("f70", stb.stg_base[0].f70);
4115 check("f71", stb.stg_base[0].f71);
4116 check("f72", stb.stg_base[0].f72);
4117 check("f73", stb.stg_base[0].f73);
4118 check("f74", stb.stg_base[0].f74);
4119 check("f75", stb.stg_base[0].f75);
4120 check("f76", stb.stg_base[0].f76);
4121 check("f77", stb.stg_base[0].f77);
4122 check("f78", stb.stg_base[0].f78);
4123 check("f79", stb.stg_base[0].f79);
4124 check("f80", stb.stg_base[0].f80);
4125 check("f81", stb.stg_base[0].f81);
4126 check("f82", stb.stg_base[0].f82);
4127 check("f83", stb.stg_base[0].f83);
4128 check("f84", stb.stg_base[0].f84);
4129 check("f85", stb.stg_base[0].f85);
4130 check("f86", stb.stg_base[0].f86);
4131 check("f87", stb.stg_base[0].f87);
4132 check("f88", stb.stg_base[0].f88);
4133 check("f89", stb.stg_base[0].f89);
4134 check("f90", stb.stg_base[0].f90);
4135 check("f91", stb.stg_base[0].f91);
4136 check("f92", stb.stg_base[0].f92);
4137 check("f93", stb.stg_base[0].f93);
4138 check("f94", stb.stg_base[0].f94);
4139 check("f95", stb.stg_base[0].f95);
4140 check("f96", stb.stg_base[0].f96);
4141 check("w9", stb.stg_base[0].w9);
4142 check("w10", stb.stg_base[0].w10);
4143 check("w11", stb.stg_base[0].w11);
4144 check("w12", stb.stg_base[0].w12);
4145 check("w13", stb.stg_base[0].w13);
4146 check("w14", stb.stg_base[0].w14);
4147 check("w15", stb.stg_base[0].w15);
4148 check("w16", stb.stg_base[0].w16);
4149 check("w17", stb.stg_base[0].w17);
4150 check("w18", stb.stg_base[0].w18);
4151 check("w19", stb.stg_base[0].w19);
4152 check("w20", stb.stg_base[0].w20);
4153 check("w21", stb.stg_base[0].w21);
4154 check("w22", stb.stg_base[0].w22);
4155 check("w23", stb.stg_base[0].w23);
4156 check("w24", stb.stg_base[0].w24);
4157 check("w25", stb.stg_base[0].w25);
4158 check("w26", stb.stg_base[0].w26);
4159 check("w27", stb.stg_base[0].w27);
4160 check("w28", stb.stg_base[0].w28);
4161 check("uname", stb.stg_base[0].uname);
4162 check("w30", stb.stg_base[0].w30);
4163 check("w31", stb.stg_base[0].w31);
4164 check("w32", stb.stg_base[0].w32);
4165 check("w34", stb.stg_base[0].w34);
4166 check("w35", stb.stg_base[0].w35);
4167 check("w36", stb.stg_base[0].w36);
4168 } /* dsym */
4169
4170 void
dsyms(int l,int u)4171 dsyms(int l, int u)
4172 {
4173 int i;
4174 if (l <= 0)
4175 l = stb.firstusym;
4176 if (u <= 0)
4177 u = stb.stg_avail - 1;
4178 if (u >= stb.stg_avail)
4179 u = stb.stg_avail - 1;
4180 for (i = l; i <= u; ++i) {
4181 dsym(i);
4182 }
4183 } /* dsyms */
4184
4185 void
ds(int sptr)4186 ds(int sptr)
4187 {
4188 dsym(sptr);
4189 } /* ds */
4190
4191 void
dsa()4192 dsa()
4193 {
4194 dsyms(0, 0);
4195 } /* dsa */
4196
4197 void
dss(int l,int u)4198 dss(int l, int u)
4199 {
4200 dsyms(l, u);
4201 } /* dss */
4202
4203 void
dumphashlk(int sptr)4204 dumphashlk(int sptr)
4205 {
4206 int s, n;
4207 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4208 fprintf(dfile, "hash link for %d:%s\n", sptr, SYMNAME(sptr));
4209 n = NMPTRG(sptr);
4210 for (s = first_hash(sptr); s > 1; s = HASHLKG(s)) {
4211 if (NMPTRG(s) == n) {
4212 putline();
4213 }
4214 putsym1(s);
4215 }
4216 putline();
4217 } /* dumphashlk */
4218
4219 void
dcommon(int c)4220 dcommon(int c)
4221 {
4222 int m;
4223 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4224 if (c <= NOSYM || c >= stb.stg_avail) {
4225 fprintf(dfile, "\ncommon block symbol %d out of %d\n", c, stb.stg_avail);
4226 return;
4227 }
4228 fprintf(dfile, "common/%d:%s/ ", c, SYMNAME(c));
4229 for (m = CMEMFG(c); m > NOSYM; m = SYMLKG(m)) {
4230 if (m != CMEMFG(c))
4231 fprintf(dfile, ", ");
4232 fprintf(dfile, "%d:%s", m, SYMNAME(m));
4233 }
4234 fprintf(dfile, "\n");
4235 } /* dcommon */
4236
4237 void
dcommons()4238 dcommons()
4239 {
4240 int cmn, any;
4241 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4242 if (gbl.cmblks <= NOSYM) {
4243 fprintf(dfile, "Common Block List is Empty\n");
4244 } else {
4245 fprintf(dfile, "Common Block List:\n");
4246 for (cmn = gbl.cmblks; cmn > NOSYM; cmn = SYMLKG(cmn)) {
4247 dcommon(cmn);
4248 }
4249 }
4250 any = 0;
4251 for (cmn = 2; cmn < stb.stg_avail; ++cmn) {
4252 if (STYPEG(cmn) == ST_CMBLK) {
4253 /* find it on the list */
4254 int c;
4255 for (c = gbl.cmblks; c != cmn && c > NOSYM; c = SYMLKG(c))
4256 ;
4257 if (c != cmn) {
4258 /* not found */
4259 if (!any) {
4260 fprintf(dfile, "Not on Common Block List:\n");
4261 }
4262 dcommon(c);
4263 ++any;
4264 }
4265 }
4266 }
4267 } /* dcommons */
4268
4269 void
dumpdt(int dt)4270 dumpdt(int dt)
4271 {
4272 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4273 if (dt <= 0 || dt >= stb.dt.stg_avail) {
4274 fprintf(dfile, "\ndatatype %d out of %d\n", dt, stb.dt.stg_avail);
4275 return;
4276 }
4277 putint("dtype", dt);
4278 putdty("ty", DTY(dt));
4279 putline();
4280
4281 switch (DTY(dt)) {
4282 case TY_CHAR:
4283 case TY_NCHAR:
4284 putast("len", DTY(dt + 1));
4285 break;
4286 case TY_PTR:
4287 putint("pointee", DTY(dt + 1));
4288 break;
4289 case TY_ARRAY:
4290 putint("element", DTY(dt + 1));
4291 putint("desc", DTY(dt + 2));
4292 if (DTY(dt + 2)) {
4293 int numdim, i;
4294 numdim = ADD_NUMDIM(dt);
4295 putint("numdim", numdim);
4296 putbit("adjarr", ADD_ADJARR(dt));
4297 putbit("assumedsize", ADD_ASSUMSZ(dt));
4298 putbit("assumedshape", ADD_ASSUMSHP(dt));
4299 putbit("defer", ADD_DEFER(dt));
4300 putbit("nobounds", ADD_NOBOUNDS(dt));
4301 putast("zbase", ADD_ZBASE(dt));
4302 putast("numelm", ADD_NUMELM(dt));
4303 if (numdim < 1 || numdim > 7) {
4304 numdim = 0;
4305 }
4306 for (i = 0; i < numdim; ++i) {
4307 putline();
4308 putint("dim", i);
4309 putast("lwbd", ADD_LWBD(dt, i));
4310 putast("upbd", ADD_UPBD(dt, i));
4311 putast("lwast", ADD_LWAST(dt, i));
4312 putast("upast", ADD_UPAST(dt, i));
4313 putast("extntast", ADD_EXTNTAST(dt, i));
4314 putast("mlpyr", ADD_MLPYR(dt, i));
4315 }
4316 }
4317 break;
4318 case TY_STRUCT:
4319 case TY_UNION:
4320 case TY_DERIVED:
4321 putsym("sptr", DTY(dt + 1));
4322 putint("size", DTY(dt + 2));
4323 putsym("tag", DTY(dt + 3));
4324 putint("align", DTY(dt + 4));
4325 putint("ict", DTY(dt + 5));
4326 putline();
4327 putsymlk("members", DTY(dt + 1));
4328 break;
4329 }
4330 putline();
4331 if (dt > 0 && dt < stb.dt.stg_avail && DTY(dt) > 0)
4332 putdtype("type", dt);
4333 putline();
4334 } /* dumpdt */
4335
4336 void
dumpdts()4337 dumpdts()
4338 {
4339 int dt;
4340 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4341 fprintf(dfile, "\n********** DATATYPE TABLE **********\n");
4342 for (dt = 1; dt < stb.dt.stg_avail; dt += dlen(DTY(dt))) {
4343 if (dt) {
4344 fprintf(dfile, "\n");
4345 }
4346 dumpdt(dt);
4347 }
4348 } /* dumpdts */
4349
4350 void
ddt(int dt)4351 ddt(int dt)
4352 {
4353 dumpdt(dt);
4354 } /* ddt */
4355
4356 void
dumpdtypes()4357 dumpdtypes()
4358 {
4359 dumpdts();
4360 }
4361
4362 /* hlvect.h */
4363 char *
getdddir(DDEDGE * dd)4364 getdddir(DDEDGE *dd)
4365 {
4366 static char buf[99];
4367 char *p;
4368 int i, dir;
4369 p = buf;
4370 dir = DD_DIRVEC(dd);
4371 for (i = MAX_LOOPS - 1; i >= 0; --i) {
4372 DIRVEC t;
4373 if (p != buf)
4374 *p++ = ',';
4375 t = DIRV_ENTRYG(dir, i);
4376 if (t == DIRV_LT) {
4377 *p++ = '<';
4378 } else if (t == DIRV_EQ) {
4379 *p++ = '=';
4380 } else if (t == DIRV_GT) {
4381 *p++ = '>';
4382 } else if (t == (DIRV_LT | DIRV_EQ)) {
4383 *p++ = '<';
4384 *p++ = '=';
4385 } else if (t == (DIRV_GT | DIRV_EQ)) {
4386 *p++ = '>';
4387 *p++ = '=';
4388 } else if (t == (DIRV_LT | DIRV_GT)) {
4389 *p++ = '<';
4390 *p++ = '>';
4391 } else if (t == (DIRV_LT | DIRV_EQ | DIRV_GT)) {
4392 *p++ = '*';
4393 }
4394 if (t & DIRV_RD)
4395 *p++ = 'R';
4396 }
4397 if (dir & DIRV_ALLEQ) {
4398 *p++ = ',';
4399 *p++ = '=';
4400 *p++ = '=';
4401 }
4402 *p++ = '\0';
4403 return buf;
4404 } /* getdddir */
4405
4406 void
putdd(DDEDGE * dd)4407 putdd(DDEDGE *dd)
4408 {
4409 static char *types[] = {"flow", "anti", "output", "?3",
4410 "?4", "?5", "?6", "?7"};
4411 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4412 if (dd == NULL) {
4413 fprintf(dfile, "null-dd-edge");
4414 return;
4415 }
4416
4417 sprintf(BUF, "%s (%s) %d", types[DD_TYPE(dd)], getdddir(dd), DD_SINK(dd));
4418 putit();
4419 } /* putdd */
4420
4421 void
putddlist(char * s,DDEDGE * ddlist)4422 putddlist(char *s, DDEDGE *ddlist)
4423 {
4424 DDEDGE *dd;
4425 if (ddlist == NULL)
4426 return;
4427 putstring1(s);
4428 for (dd = ddlist; dd; dd = DD_NEXT(dd)) {
4429 putdd(dd);
4430 }
4431 putline();
4432 } /* putddlist */
4433
4434 void
dumpvind(int i)4435 dumpvind(int i)
4436 {
4437 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4438 if (hlv.indbase == NULL) {
4439 fprintf(dfile, "HLV.INDBASE not allocated\n");
4440 return;
4441 }
4442 if (i <= 0 || i >= hlv.indavail) {
4443 fprintf(dfile, "\nvind %d out of %d\n", i, hlv.indavail);
4444 return;
4445 }
4446 putint("vind", i);
4447 putint("nme", VIND_NM(i));
4448 putnme(VIND_NM(i));
4449 putast("load", VIND_LOAD(i));
4450 putast("init", VIND_INIT(i));
4451 putast("originit", VIND_ORIGINIT(i));
4452 putast("skip", VIND_SKIP(i));
4453 putast("totskip", VIND_TOTSKIP(i));
4454 putasttype("opc", VIND_OPC(i));
4455 putline();
4456 putbit("ptr", VIND_PTR(i));
4457 putbit("delete", VIND_DELETE(i));
4458 putbit("niu", VIND_NIU(i));
4459 putbit("midf", VIND_MIDF(i));
4460 putbit("alias", VIND_ALIAS(i));
4461 putbit("noinv", VIND_NOINV(i));
4462 putbit("omit", VIND_OMIT(i));
4463 putbit("visit", VIND_VISIT(i));
4464 putbit("alast", VIND_ALAST(i));
4465 putbit("save", VIND_SAVE(i));
4466 putline();
4467 } /* dumpvind */
4468
4469 void
dumpvinds(int start,int end)4470 dumpvinds(int start, int end)
4471 {
4472 int i;
4473 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4474 if (hlv.indbase == NULL) {
4475 fprintf(dfile, "HLV.INDBASE not allocated\n");
4476 return;
4477 }
4478 for (i = start; i <= end; ++i) {
4479 dumpvind(i);
4480 }
4481 } /* dumpvinds */
4482
4483 void
dumpmr(int mr)4484 dumpmr(int mr)
4485 {
4486 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4487 if (hlv.mrbase == NULL) {
4488 fprintf(dfile, "HLV.MRBASE not allocated\n");
4489 return;
4490 }
4491 if (mr <= 0 || mr >= hlv.mravail) {
4492 fprintf(dfile, "memref %d should be between 1 and %d\n", mr,
4493 hlv.mravail - 1);
4494 return;
4495 }
4496 putint("memref", mr);
4497 putcharacter("type", MR_TYPE(mr));
4498 putast("ast", MR_ILI(mr));
4499 putint("nme", MR_NME(mr));
4500 putnme(MR_NME(mr));
4501 putint("std", MR_ILT(mr));
4502 putint("fg", MR_FG(mr));
4503 putnzint("loop", MR_LOOP(mr));
4504 putnzint("stmt", MR_STMT(mr));
4505 putint("nest", MR_NEST(mr));
4506 putint("subst", MR_SUBST(mr));
4507 putnzint("subcnt", MR_SUBCNT(mr));
4508 putnzint("fsubs", MR_FSUBS(mr));
4509 putnzint("cseili", MR_CSEILI(mr));
4510 putnzint("rg", MR_RG(mr));
4511 putnzint("prev", MR_PREV(mr));
4512 putnzint("next", MR_NEXT(mr));
4513 if (MR_IVUSE(mr)) {
4514 putnzint("iv", MR_IV(mr));
4515 } else if (MR_SCALR(mr)) {
4516 putnzint("sclr", MR_SCLR(mr));
4517 } else {
4518 putnzint("exparr", MR_EXPARR(mr));
4519 }
4520 putast("rewr", MR_REWR(mr));
4521 putline();
4522 putbit("array", MR_ARRAY(mr));
4523 putbit("based", MR_BASED(mr));
4524 putbit("exp", MR_EXP(mr));
4525 putbit("indir", MR_INDIR(mr));
4526 putbit("induc", MR_INDUC(mr));
4527 putbit("init", MR_INIT(mr));
4528 putbit("inval", MR_INVAL(mr));
4529 putbit("invar", MR_INVAR(mr));
4530 putbit("invec", MR_INVEC(mr));
4531 putbit("ivuse", MR_IVUSE(mr));
4532 putbit("scalr", MR_SCALR(mr));
4533 putline();
4534 putddlist("succ:", MR_SUCC(mr));
4535 } /* dumpmr */
4536
4537 void
dumpmemref(int mr)4538 dumpmemref(int mr)
4539 {
4540 dumpmr(mr);
4541 } /* dumpmemref */
4542
4543 void
dumpmemrefs(int m1,int m2)4544 dumpmemrefs(int m1, int m2)
4545 {
4546 int mr;
4547 for (mr = m1; mr <= m2; ++mr) {
4548 dumpmr(mr);
4549 }
4550 } /* dumpmemrefs */
4551
4552 void
putmrlist(char * s,int ivlist)4553 putmrlist(char *s, int ivlist)
4554 {
4555 if (ivlist) {
4556 int i;
4557 putstring1(s);
4558 for (i = ivlist; i; i = MR_NEXT(i)) {
4559 putint1(i);
4560 }
4561 putline();
4562 }
4563 } /* putmrlist */
4564
4565 void
putsclist(char * s,int sclist)4566 putsclist(char *s, int sclist)
4567 {
4568 if (sclist) {
4569 int sc;
4570 putstring1(s);
4571 for (sc = sclist; sc; sc = SCLR_NEXT(sc)) {
4572 putint("sclr", sc);
4573 putnme(SCLR_NME(sc));
4574 putbit("flag", SCLR_FLAG(sc));
4575 putbit("span", SCLR_SPAN(sc));
4576 putnsym("arrsym", SCLR_ARRSYM(sc));
4577 putnsym("masksym", SCLR_MASKSYM(sc));
4578 }
4579 putline();
4580 }
4581 } /* putsclist */
4582
4583 void
dumpvloop(int l)4584 dumpvloop(int l)
4585 {
4586 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4587 if (hlv.lpbase == NULL) {
4588 fprintf(dfile, "VL not allocated\n");
4589 return;
4590 }
4591 if (l <= 0 || l >= hlv.lpavail) {
4592 fprintf(dfile, "\nvloop %d out of %d\n", l, hlv.lpavail);
4593 return;
4594 }
4595 putint("vloop", l);
4596 putint("nest", VL_NEST(l));
4597 putnzint("sibling", VL_SIBLING(l));
4598 putnzint("mrstart", VL_MRSTART(l));
4599 putnzint("mrcnt", VL_MRCNT(l));
4600 putnzint("mrecnt", VL_MRECNT(l));
4601 putnzint("istart", VL_ISTART(l));
4602 putnzint("icnt", VL_ICNT(l));
4603 putnzint("lbnd", VL_LBND(l));
4604 putnzint("ubnd", VL_UBND(l));
4605 putnzint("ilbnd", VL_ILBND(l));
4606 putnzint("albnd", VL_ALBND(l));
4607 putnzint("iubnd", VL_IUBND(l));
4608 putnzint("aubnd", VL_AUBND(l));
4609 putnzint("sclist", VL_SCLIST(l));
4610 putnzint("ealist", VL_EALIST(l));
4611 putnzint("prebih", VL_PREBIH(l));
4612 putast("lpcnt", VL_LPCNT(l));
4613 putline();
4614 putbit("assoc", VLP_ASSOC(l));
4615 putbit("cand", VL_CAND(l));
4616 putbit("del", VL_DEL(l));
4617 putbit("depchk", VLP_DEPCHK(l));
4618 putbit("eqvchk", VLP_EQVCHK(l));
4619 putbit("lastval", VLP_LSTVAL(l));
4620 putbit("ldstsplit", VLP_LDSTSPLIT(l));
4621 putbit("mincnt", VLP_MINCNT(l));
4622 putbit("opsplit", VLP_OPSPLIT(l));
4623 putbit("perf", VL_PERF(l));
4624 putbit("recog", VLP_RECOG(l));
4625 putbit("safecall", VLP_SAFECALL(l));
4626 putbit("shortlp", VLP_SHORTLP(l));
4627 putbit("trans", VLP_TRANS(l));
4628 putbit("ztrip", VL_ZTRIP(l));
4629 putline();
4630 dumpvinds(VL_ISTART(l), VL_ISTART(l) + VL_ICNT(l) - 1);
4631 dumpmemrefs(VL_MRSTART(l), VL_MRSTART(l) + VL_MRCNT(l) - 1);
4632 putmrlist("ivlist: ", VL_IVLIST(l));
4633 putsclist("sclist: ", VL_SCLIST(l));
4634 } /* dumpvloop */
4635
4636 void
dumpvnest(int l)4637 dumpvnest(int l)
4638 {
4639 int inner;
4640 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4641 if (hlv.lpbase == NULL) {
4642 fprintf(dfile, "VL not allocated\n");
4643 return;
4644 }
4645 dumpvloop(l);
4646 fprintf(dfile, "\n");
4647 for (inner = VL_CHILD(l); inner > 0; inner = VL_SIBLING(inner)) {
4648 dumpvnest(inner);
4649 }
4650 } /* dumpvnest */
4651
4652 void
dumpvloops()4653 dumpvloops()
4654 {
4655 int l;
4656 if (hlv.lpbase == NULL) {
4657 fprintf(dfile, "VL not allocated\n");
4658 return;
4659 }
4660 for (l = hlv.looplist; l > 0; l = VL_SIBLING(l)) {
4661 dumpvnest(l);
4662 }
4663 } /* dumpvloops */
4664
4665 void
dumpvnest2(int l)4666 dumpvnest2(int l)
4667 {
4668 int inner;
4669 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4670 if (hlv.lpbase == NULL) {
4671 fprintf(dfile, "VL not allocated\n");
4672 return;
4673 }
4674 if (opt.lpb.stg_base == NULL) {
4675 fprintf(dfile, "opt.lpb not allocated\n");
4676 return;
4677 }
4678 dumploop(l);
4679 dumpvloop(l);
4680 fprintf(dfile, "\n");
4681 for (inner = VL_CHILD(l); inner > 0; inner = VL_SIBLING(inner)) {
4682 dumpvnest2(inner);
4683 }
4684 } /* dumpvnest2 */
4685
4686 void
dumpvloops2()4687 dumpvloops2()
4688 {
4689 int l;
4690 if (hlv.lpbase == NULL) {
4691 fprintf(dfile, "VL not allocated\n");
4692 return;
4693 }
4694 if (opt.lpb.stg_base == NULL) {
4695 fprintf(dfile, "opt.lpb not allocated\n");
4696 return;
4697 }
4698 for (l = hlv.looplist; l > 0; l = VL_SIBLING(l)) {
4699 dumpvnest2(l);
4700 }
4701 } /* dumpvloops2 */
4702
4703 void
dumpdef(int def)4704 dumpdef(int def)
4705 {
4706 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4707 if (def <= 0 || def > opt.ndefs) {
4708 fprintf(dfile, "\ndef %d out of %d\n", def, opt.ndefs);
4709 return;
4710 }
4711 putint("def", def);
4712 putnzint("fg", DEF_FG(def));
4713 putnzint("std", DEF_STD(def));
4714 putnzint("next", DEF_NEXT(def));
4715 putnzint("lnext", DEF_LNEXT(def));
4716 putint("nme", DEF_NM(def));
4717 putint("lhs", DEF_LHS(def));
4718 putint("rhs", DEF_RHS(def));
4719 putint("addr", DEF_ADDR(def));
4720 if (DEF_NM(def))
4721 printnme(DEF_NM(def));
4722 putbit("arg", DEF_ARG(def));
4723 putbit("confl", DEF_CONFL(def));
4724 putbit("const", DEF_CONST(def));
4725 putbit("delete", DEF_DELETE(def));
4726 putbit("doinit", DEF_DOINIT(def));
4727 putbit("doend", DEF_DOEND(def));
4728 putbit("gen", DEF_GEN(def));
4729 putbit("other", DEF_OTHER(def));
4730 putbit("precise", DEF_PRECISE(def));
4731 putbit("self", DEF_SELF(def));
4732 #ifdef DEF_LOOPENTRY
4733 putbit("loopentry", DEF_LOOPENTRY(def));
4734 #endif
4735 putline();
4736 if (DEF_DU(def)) {
4737 DU *du;
4738 putstring1(" uses:");
4739 for (du = DEF_DU(def); du != NULL; du = du->next) {
4740 putint1(du->use);
4741 }
4742 putline();
4743 }
4744 if (DEF_CSEL(def)) {
4745 DU *du;
4746 putstring1(" cse:");
4747 for (du = DEF_CSEL(def); du != NULL; du = du->next) {
4748 putint1(du->use);
4749 }
4750 putline();
4751 }
4752 } /* dumpdef */
4753
4754 void
dumpdefs(void)4755 dumpdefs(void)
4756 {
4757 int def;
4758 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4759 fprintf(dfile, "\n********** DEF TABLE **********\n");
4760 for (def = FIRST_DEF; def <= opt.ndefs; ++def) {
4761 dumpdef(def);
4762 fprintf(dfile, "\n");
4763 }
4764 fprintf(dfile, "\n");
4765 } /* dumpdefs */
4766
4767 void
dumpdeflist(int d)4768 dumpdeflist(int d)
4769 {
4770 int def;
4771 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4772 for (def = d; def <= opt.ndefs && def > 0; def = DEF_NEXT(def)) {
4773 dumpdef(def);
4774 fprintf(dfile, "\n");
4775 }
4776 fprintf(dfile, "\n");
4777 } /* dumpdeflist */
4778
4779 void
dumpuse(int use)4780 dumpuse(int use)
4781 {
4782 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4783 if (use <= 0 || use > opt.useb.stg_avail) {
4784 fprintf(dfile, "use %d out of %d\n", use, opt.useb.stg_avail - 1);
4785 return;
4786 }
4787 putint("use", use);
4788 putnzint("fg", USE_FG(use));
4789 putnzint("std", USE_STD(use));
4790 putnzint("ast", USE_AST(use));
4791 putnzint("nme", USE_NM(use));
4792 if (USE_NM(use))
4793 printnme(USE_NM(use));
4794 putint("addr", USE_ADDR(use));
4795 putbit("arg", USE_ARG(use));
4796 putbit("cse", USE_CSE(use));
4797 putbit("doinit", USE_DOINIT(use));
4798 putbit("exposed", USE_EXPOSED(use));
4799 putbit("precise", USE_PRECISE(use));
4800 #ifdef USE_MARK1
4801 putbit("mark1", USE_MARK1(use));
4802 #endif
4803 #ifdef USE_MARK2
4804 putbit("mark2", USE_MARK2(use));
4805 #endif
4806 #ifdef USE_LOOPENTRY
4807 putbit("loopentry", USE_LOOPENTRY(use));
4808 #endif
4809 putline();
4810 if (USE_UD(use) != NULL) {
4811 UD *ud;
4812 putstring1(" defs:");
4813 for (ud = USE_UD(use); ud != NULL; ud = ud->next) {
4814 putint1(ud->def);
4815 }
4816 putline();
4817 }
4818 } /* dumpuse */
4819
4820 void
dumpuses(void)4821 dumpuses(void)
4822 {
4823 int use;
4824 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4825 fprintf(dfile, "\n********** USE TABLE **********\n");
4826 for (use = 1; use < opt.useb.stg_avail; ++use) {
4827 dumpuse(use);
4828 fprintf(dfile, "\n");
4829 }
4830 fprintf(dfile, "\n");
4831 } /* dumpuses */
4832
4833 #ifdef FIH_NAME
4834 void
dfih(int f)4835 dfih(int f)
4836 {
4837 dfile = gbl.dbgfil ? gbl.dbgfil : stderr;
4838 if (fihb.stg_base == NULL) {
4839 fprintf(dfile, "fihb.stg_base not allocated\n");
4840 return;
4841 }
4842 putint("fih", f);
4843 if (f <= 0 || f >= fihb.stg_size) {
4844 fprintf(dfile, "\nfile %d out of %d\n", f, fihb.stg_size - 1);
4845 return;
4846 }
4847 putstring("name", FIH_NAME(f));
4848 if (FIH_FUNCNAME(f) != NULL) {
4849 putstring("funcname", FIH_FUNCNAME(f));
4850 }
4851 putint("functag", FIH_FUNCTAG(f));
4852 putint("srcline", FIH_SRCLINE(f));
4853 putnzint("level", FIH_LEVEL(f));
4854 putnzint("parent", FIH_PARENT(f));
4855 putnzint("lineno", FIH_LINENO(f));
4856 putnzint("next", FIH_NEXT(f));
4857 putnzint("child", FIH_CHILD(f));
4858 putbit("included", FIH_INC(f));
4859 putbit("inlined", FIH_INL(f));
4860 putbit("ipainlined", FIH_IPAINL(f));
4861 putbit("ccff", FIH_FLAGS(f) & FIH_CCFF);
4862 putbit("ccffinfo", (FIH_CCFFINFO(f) != NULL));
4863 putline();
4864 } /* dfih */
4865
4866 void
dumpfile(int f)4867 dumpfile(int f)
4868 {
4869 dfih(f);
4870 } /* dumpfile */
4871
4872 void
dumpfiles(void)4873 dumpfiles(void)
4874 {
4875 int f;
4876 for (f = 1; f < fihb.stg_avail; ++f) {
4877 dfih(f);
4878 }
4879 } /* dumpfiles */
4880 #endif
4881
4882 #endif
4883