Annotation of researchv9/jerq/sgs/ld/dump.c, revision 1.1.1.1

1.1       root        1: static char ID[] = "@(#) dump.c: 1.1 1/7/82";
                      2: #include "system.h"
                      3: 
                      4: #include <stdio.h>
                      5: #include "structs.h"
                      6: #include "extrns.h"
                      7: /*eject*/
                      8: dmpacts()
                      9: {
                     10: #if DEBUG
                     11:        register ACTITEM *p;
                     12:        register REGION *r;
                     13:        register MEMTYPE *m;
                     14: 
                     15:        if( (m = (MEMTYPE *) memlist.head) )
                     16:                fprintf(stderr, "\n\nMEMLIST\n\n");
                     17:        while (m) {
                     18:                fprintf(stderr, "name=%-8.8s  orig=%08.2lx  len=%08.2lx  attr=%04.2x\n",
                     19:                        m->mtname, m->mtorig, m->mtlength, m->mtattr);
                     20:                m = m->mtnext;
                     21:                }
                     22:        if( (r = (REGION *) reglist.head) )
                     23:                fprintf(stderr, "\n\nREGLIST\n\n");
                     24:        while (r) {
                     25:                fprintf(stderr, "name=%-8.8s  orig=%08.2lx  len=%08.2lx  vaddr=%08.2lx\n",
                     26:                        r->rgname, r->rgorig, r->rglength, r->rgvaddr);
                     27:                r = r->rgnext;
                     28:                }
                     29: 
                     30:        if( (p = (ACTITEM *) ldfilist.head) )
                     31:                fprintf(stderr, "\n\nLDFILLIST\n\n");
                     32:        while (p) {
                     33:                fprintf(stderr, "load file %s\n", p->ldlbry.aifilnam);
                     34:                p=p->ldlbry.ainext;
                     35:                }
                     36: 
                     37:        if( (p = (ACTITEM *) bldoutsc.head) )
                     38:                fprintf(stderr, "\n\nBLDOUTSC\n\n");
                     39:        while (p) {
                     40:                dmpsecspc(p);
                     41:                p = p->dfnscn.ainext;
                     42:                }
                     43: 
                     44: #endif
                     45: }
                     46: /*eject*/
                     47: dmpsecspc(p)
                     48: ACTITEM *p;
                     49: {
                     50: #if DEBUG
                     51:        register ACTITEM *q;
                     52: 
                     53:        if (p->dfnscn.aitype == AIDFNGRP)
                     54:                fprintf(stderr, "GROUP:  owner=(%.8s)  bondadr=%08.2lx  align=%08.2lx  block=%06.2lx\n",
                     55:                        p->dfnscn.aiowname,p->dfnscn.aibndadr,p->dfnscn.aialign, p->dfnscn.aiblock);
                     56:        else
                     57:                fprintf(stderr, "section %.8s:  fill=%06.2x  owner=(%.8s)  bond=%08.2lx\n\t\talign=%08.2lx  block=%06.2lx  attown=%06.2x\n",
                     58:                        p->dfnscn.ainame,p->dfnscn.aifill,p->dfnscn.aiowname,p->dfnscn.aibndadr,
                     59:                        p->dfnscn.aialign, p->dfnscn.aiblock, p->dfnscn.aiattown);
                     60: 
                     61:        q = (ACTITEM *) p->dfnscn.sectspec.head;
                     62:        while (q) {
                     63:                if (q->dfnscn.aitype == AIDFNSCN)
                     64:                        dmpsecspc(q);
                     65:                else if (q->dfnscn.aitype == AIADFILE) {
                     66:                        fprintf(stderr, "\tadd file %s\n", q->adfile.aifilnam);
                     67:                        }
                     68:                else if (q->dfnscn.aitype == AIADDSCN)
                     69:                        fprintf(stderr, "\tadd %s(%.8s)  fill=%06.2x\n",
                     70:                             q->addscn.aiscfile, q->addscn.ainame, q->addscn.aifill);
                     71:                q = q->dfnscn.ainext;
                     72:                }
                     73: #endif
                     74: }
                     75: /*eject*/
                     76: dump_mem()
                     77: {
                     78: #if DEBUG
                     79: 
                     80: /*
                     81:  * List the configured memory, available memory, and the
                     82:  * regions and the pointers between them.
                     83:  * Strictly for debugging purposes.
                     84:  */
                     85: 
                     86:        register MEMTYPE *mp;
                     87:        register REGION *rp;
                     88:        register ANODE *ap;
                     89: 
                     90:        fprintf(stderr, "\n\n\tCONFIGURED MEMORY\n");
                     91:        fprintf(stderr, "addr\torigin\tlength\thead\ttail\tattr\tname\n");
                     92:        for( mp = (MEMTYPE *) memlist.head; mp; mp = mp->mtnext )
                     93:                fprintf(stderr, "%4x\t%6lx\t%6lx\t%4x\t%4x\t%x\t%.8s\n",
                     94:                        mp,mp->mtorig,mp->mtlength,
                     95:                        mp->mtaddrhd,mp->mtaddrtl,
                     96:                        mp->mtattr,mp->mtname);
                     97: 
                     98:        fprintf(stderr, "\n\tREGIONS\n");
                     99:        fprintf(stderr, "addr\torigin\tlength\thead\ttail\tname\n");
                    100:        for( rp = (REGION *) reglist.head; rp; rp = rp->rgnext )
                    101:                fprintf(stderr, "%4x\t%6lx\t%6lx\t%4x\t%4x\t%.8s\n",
                    102:                        rp,rp->rgorig,rp->rglength,rp->rgaddrhd,
                    103:                        rp->rgaddrtl,rp->rgname);
                    104: 
                    105:        fprintf(stderr, "\n\tAVAIL NODES\n");
                    106:        fprintf(stderr, "addr\tprev\tnext\taddr\tsize\ttype\tmemp\tregp\toutsect\n");
                    107:        for( ap = (ANODE *) avlist.head; ap; ap = ap->adnext ) {
                    108:                fprintf(stderr, "%4x\t%4x\t%4x\t%6lx\t%6lx\t%4x\t%4x\t%4x",
                    109:                        ap,ap->adprev, ap->adnext, ap->adpaddr,ap->adsize,
                    110:                        ap->adtype,ap->admemp,ap->adregp);
                    111:                if(ap->adtype != ADAVAIL)
                    112:                        fprintf(stderr, "\t%.8s",ap->adscnptr->oshdr.s_name);
                    113:                fprintf(stderr, "\n");
                    114:                }
                    115: 
                    116:        fflush(stderr);
                    117: #endif
                    118: }
                    119: /*eject*/
                    120: dmp_own(aip)
                    121: ACTITEM *aip;
                    122: {
                    123: #if DEBUG
                    124:        fprintf(stderr, "\nOwner:  %.8s\nOutsec:  %.8s, size %x, vaddr %x, paddr %lx\n",
                    125:        aip->dfownr.ainamown,aip->dfownr.aioutsec->oshdr.s_name,aip->dfownr.aioutsec->oshdr.s_size,
                    126:        aip->dfownr.aioutsec->oshdr.s_vaddr,aip->dfownr.aioutsec->oshdr.s_paddr);
                    127: 
                    128:        fflush(stderr);
                    129: #endif
                    130: }
                    131: 
                    132: 
                    133: 
                    134: 
                    135: 
                    136: dmp_att(aip)
                    137: ACTITEM *aip;
                    138: {
                    139: #if DEBUG
                    140:        fprintf(stderr, "Attown:  %x\nOutsec:  %.8s, size %x\n",
                    141:        aip->ownatr.aiownatt,aip->ownatr.aioutsec->oshdr.s_name,
                    142:        aip->ownatr.aioutsec->oshdr.s_size);
                    143: 
                    144:        fflush(stderr);
                    145: #endif
                    146: }
                    147: /*eject*/
                    148: dmp_outsects()
                    149: {
                    150: #if DEBUG
                    151:        register OUTSECT *p, *q;
                    152: 
                    153:        for( p = (OUTSECT *) outsclst.head; p; p = p->osnext ) {
                    154:                if (p->oshdr.s_flags & STYP_GROUP) {
                    155:                        fprintf(stderr, "GROUP: size %lx, paddr %lx, vaddr %lx\n",
                    156:                                p->oshdr.s_size, p->oshdr.s_paddr, 
                    157:                                p->oshdr.s_vaddr);
                    158:                        for( q = (OUTSECT *) p->osinclhd; q; q = q->osnext ) {
                    159:                                fprintf(stderr, "  %.8s: size %lx, paddr %lx, vaddr %lx\n",
                    160:                                        q->oshdr.s_name, q->oshdr.s_size,  
                    161:                                        q->oshdr.s_paddr, q->oshdr.s_vaddr);
                    162:                                }
                    163:                        }
                    164:                else
                    165:                        fprintf(stderr, "%.8s: size %lx, paddr %lx, vaddr %lx\n",
                    166:                                p->oshdr.s_name, p->oshdr.s_size,  
                    167:                                p->oshdr.s_paddr, p->oshdr.s_vaddr);
                    168:                }
                    169: #endif
                    170: }

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.