# 2.11BSD#431 - /usr/src/ucb/PORT/pascal/pdx/machine/printinst.c

##### Functions

    docase            X
    printinst         X
    printninst        X
    printop           X

       1: /*
       2:  * Copyright (c) 1980 Regents of the University of California.
       3:  * All rights reserved.  The Berkeley software License Agreement
       4:  * specifies the terms and conditions for redistribution.
       5:  */
       6:
       7: #ifndef lint
       8: static char sccsid[] = "@(#)printinst.c	5.1 (Berkeley) 6/6/85";
       9: #endif not lint
      10: /*
      11:  * decode and print the instructions
      12:  */
      13:
      14: #include "defs.h"
      15: #include "machine.h"
      16: #include "process.h"
      17: #include "pxops.h"
      18: #include "optab.h"
      19: #include "object.h"
      20:
      21: LOCAL ADDRESS printop(), docase();
      22:
      23: /*
      24:  * print instructions within the given address range
      25:  */
      26:
      27: printinst(lowaddr, highaddr)
      28: ADDRESS lowaddr;
      29: ADDRESS highaddr;
      30: {
      31:     register ADDRESS addr;
      32:
      33:     for (addr = lowaddr; addr <= highaddr; ) {
      34:     addr = printop(addr);
      35:     }
      36: }
      37:
      38: /*
      39:  * print count instructions from given address
      40:  */
      41:
      42: printninst(count, addr)
      43: int count;
      44: ADDRESS addr;
      45: {
      46:     int i;
      47:
      48:     for (i = 0; i < count; i++) {
      49:     addr = printop(addr);
      50:     }
      51: }
      52:
      53: /*
      54:  * print the opcode at the given address, return the address
      55:  * of the next instruction
      56:  */
      57:
      58: LOCAL ADDRESS printop(addr)
      59: register ADDRESS addr;
      60: {
      61:     int i;
      62:     PXOP op;
      63:     OPTAB *o;
      64:     char subop;
      65:     short arg;
      66:     long longarg;
      67:     union {
      68:     short i;
      69:     struct { char c1, c2; } opword;
      70:     } u;
      71:
      72:     iread(&u.i, addr, sizeof(u.i));
      73:     op = (PXOP) u.opword.c1;
      74:     subop = u.opword.c2;
      75:     o = &optab[op];
      76:     printf("%5d   %s", addr, o->opname);
      77:     addr += sizeof(u);
      78:     for (i = 0; o->argtype[i] != 0; i++) {
      79:     if (i == 0) {
      80:         putchar('\t');
      81:     } else {
      82:         putchar(',');
      83:     }
      84:     switch(o->argtype[i]) {
      85:         case ADDR4:
      86:         case LWORD:
      87:         iread(&longarg, addr, sizeof(longarg));
      88:         printf("%d", longarg);
      89:         addr += sizeof(long);
      90:         break;
      91:
      92:         case SUBOP:
      93:         printf("%d", subop);
      94:         break;
      95:
      96:         case ADDR2:
      97:         case DISP:
      98:         case PSUBOP:
      99:         case VLEN:
     100:         case HWORD:
     101:         if (i != 0 || subop == 0) {
     102:             iread(&arg, addr, sizeof(arg));
     103:             addr += sizeof(short);
     104:         } else {
     105:             arg = subop;
     106:         }
     107:         printf("%d", arg);
     108:         break;
     109:
     110:         case STRING: {
     111:         char c;
     112:
     113:         putchar('\'');
     114:         while (subop > 0) {
     115:             iread(&c, addr, sizeof(c));
     116:             if (c == '\0') {
     117:             break;
     118:             }
     119:             putchar(c);
     120:             subop--;
     121:             addr++;
     122:         }
     123:         addr++;
     124:         putchar('\'');
     125:         if ((addr&1) != 0) {
     126:             addr++;
     127:         }
     128:         break;
     129:         }
     130:
     131:         default:
     132:         panic("bad argtype %d", o->argtype[i]);
     133:         /*NOTREACHED*/
     134:     }
     135:     }
     136:     switch(op) {
     137:     case O_CON:
     138:         addr += arg;
     139:         break;
     140:
     141:     case O_CASE1OP:
     142:         addr = docase(addr, 1, subop);
     143:         break;
     144:
     145:     case O_CASE2OP:
     146:         addr = docase(addr, 2, subop);
     147:         break;
     148:
     149:     case O_CASE4OP:
     150:         addr = docase(addr, 4, subop);
     151:         break;
     152:     }
     153:     putchar('\n');
     154:     return(addr);
     155: }
     156:
     157: /*
     158:  * print out the destinations and cases
     159:  */
     160:
     161: LOCAL ADDRESS docase(addr, size, n)
     162: ADDRESS addr;
     163: int size;
     164: int n;
     165: {
     166:     register int i;
     167:     char c;
     168:     short arg;
     169:     long longarg;
     170:
     171:     iread(&arg, addr, sizeof(arg));
     172:     printf("\n\t%5d", arg);
     173:     addr += 2;
     174:     for (i = 1; i < n; i++) {
     175:     iread(&arg, addr, sizeof(arg));
     176:     printf(", %5d", arg);
     177:     addr += 2;
     178:     }
     179:     printf("\n\t");
     180:     for (i = 0; i < n; i++) {
     181:     switch(size) {
     182:         case 1:
     183:         iread(&c, addr, sizeof(c));
     184:         printf("%5d", c);
     185:         break;
     186:
     187:         case 2:
     188:         iread(&arg, addr, sizeof(arg));
     189:         printf("%5d", arg);
     190:         break;
     191:
     192:         case 4:
     193:         iread(&longarg, addr, sizeof(longarg));
     194:         printf("%5d", longarg);
     195:         break;
     196:     }
     197:     addr += size;
     198:     if (i < n - 1) {
     199:         printf(", ");
     200:     }
     201:     }
     202:     if ((addr&01) == 01) {
     203:     addr++;
     204:     }
     205:     return(addr);
     206: }

#### Defined functions

docase defined in line 161; used 4 times

- in line 21, 142-150(3)

printinst defined in line 27; never used
printninst defined in line 42; never used
printop defined in line 58; used 3 times

- in line 21, 34, 49

#### Defined variables

sccsid defined in line 8; never used

Last modified: 1985-06-06 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 803 |