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