![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bundled CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcomp|
Return to bundled CVS log | Up to [Research Unix] / researchv10no / cmd / lcomp |
1.1 ! root 1: # To unbundle, sh this file ! 2: echo 3binstr.c 1>&2 ! 3: sed 's/.//' >3binstr.c <<'//GO.SYSIN DD 3binstr.c' ! 4: -From research!whuxld!bjb Thu Mar 8 13:23 EST 1984* ! 5: -To: research!seki!pjw ! 6: - ! 7: -/* ! 8: - * static char *ID_opsout = "@(#) ops.out: 1.5 4/26/83"; ! 9: - */ ! 10: -{"mcomb", IS25|INSTRB, DYAOP1-256, 8, 0x8bL}, ! 11: -{"mcomh", IS25|INSTRH, DYAOP1-256, 8, 0x8aL}, ! 12: -{"mcomw", IS25|INSTRW, DYAOP1-256, 8, 0x88L}, ! 13: -{"movzbh", IS25|INSTRBH, DYAOP7-256, 8, 0x87L}, ! 14: -{"movzbw", IS25|INSTRBW, DYAOP7-256, 8, 0x87L}, ! 15: -{"movzhw", IS25|INSTRHW, DYAOP7-256, 8, 0x86L}, ! 16: -{"pushzb", IS25|INSTRB, PUSHOP1-256, 8, 0x87L}, ! 17: -{"pushzh", IS25|INSTRHW, PUSHOP1-256, 8, 0x84L}, ! 18: -{"movaw", IS25|INSTRW, DYAOP2-256, 8, 0x4L}, ! 19: -{"pushaw", IS25|INSTRW, MONOP2-256, 8, 0xe0L}, ! 20: -{"andb2", IS25|INSTRB, DYAOP1-256, 8, 0xbbL}, ! 21: -{"andh2", IS25|INSTRH, DYAOP1-256, 8, 0xbaL}, ! 22: -{"andw2", IS25|INSTRW, DYAOP1-256, 8, 0xb8L}, ! 23: -{"andb3", IS25|INSTRB, TRIOP1-256, 8, 0xfbL}, ! 24: -{"andh3", IS25|INSTRH, TRIOP1-256, 8, 0xfaL}, ! 25: -{"andw3", IS25|INSTRW, TRIOP1-256, 8, 0xf8L}, ! 26: -{"orb2", IS25|INSTRB, DYAOP1-256, 8, 0xb3L}, ! 27: -{"orh2", IS25|INSTRH, DYAOP1-256, 8, 0xb2L}, ! 28: -{"orw2", IS25|INSTRW, DYAOP1-256, 8, 0xb0L}, ! 29: -{"orb3", IS25|INSTRB, TRIOP1-256, 8, 0xf3L}, ! 30: -{"orh3", IS25|INSTRH, TRIOP1-256, 8, 0xf2L}, ! 31: -{"orw3", IS25|INSTRW, TRIOP1-256, 8, 0xf0L}, ! 32: -{"xorb2", IS25|INSTRB, DYAOP1-256, 8, 0xb7L}, ! 33: -{"xorh2", IS25|INSTRH, DYAOP1-256, 8, 0xb6L}, ! 34: -{"xorw2", IS25|INSTRW, DYAOP1-256, 8, 0xb4L}, ! 35: -{"xorb3", IS25|INSTRB, TRIOP1-256, 8, 0xf7L}, ! 36: -{"xorh3", IS25|INSTRH, TRIOP1-256, 8, 0xf6L}, ! 37: -{"xorw3", IS25|INSTRW, TRIOP1-256, 8, 0xf4L}, ! 38: -{"bitb", IS25|INSTRB, CMPOP2-256, 8, 0x3bL}, ! 39: -{"bith", IS25|INSTRH, CMPOP2-256, 8, 0x3aL}, ! 40: -{"bitw", IS25|INSTRW, CMPOP2-256, 8, 0x38L}, ! 41: -{"llsw2", IS25|INSTRW, DYAOP3-256, 16, 0xd0L}, ! 42: -{"llsw3", IS25|INSTRW, SHFTOP1-256, 16, 0xd0L}, ! 43: -{"lrsw2", IS25|INSTRBW, DYAOP3-256, 16, 0xd4L}, ! 44: -{"lrsw3", IS25|INSTRBW, SHFTOP1-256, 16, 0xd4L}, ! 45: -{"movb", IS25|INSTRB, DYAOP4-256, 16, 0x8387L}, ! 46: -{"movh", IS25|INSTRH, DYAOP4-256, 16, 0x8286L}, ! 47: -{"movw", IS25|INSTRW, DYAOP4-256, 16, 0x8084L}, ! 48: -{"movbbh", IS25|INSTRBH, DYAOP5-256, 16, 0x87E7L}, ! 49: -{"movbbw", IS25|INSTRBW, DYAOP5-256, 16, 0x87E7L}, ! 50: -{"movbhw", IS25|INSTRHW, DYAOP5-256, 8, 0x86L}, ! 51: -{"movthb", IS25|INSTRHB, DYAOP5-256, 8, 0x86L}, ! 52: -{"movtwb", IS25|INSTRWB, DYAOP5-256, 8, 0x84L}, ! 53: -{"movtwh", IS25|INSTRWH, DYAOP5-256, 8, 0x84L}, ! 54: -{"mnegh", IS25|INSTRH, DYAOP1-256, 8, 0x8eL}, ! 55: -{"mnegw", IS25|INSTRW, DYAOP1-256, 8, 0x8cL}, ! 56: -{"pushbb", IS25|INSTRBW, PUSHOP1-256, 8, 0x87L}, ! 57: -{"pushbh", IS25|INSTRH, PUSHOP1-256, 8, 0x86L}, ! 58: -{"pushw", IS25|INSTRW, MONOP1-256, 8, 0xa0L}, ! 59: -{"addb2", IS25|INSTRB, DYAOP6-256, 16, 0x939fL}, ! 60: -{"addh2", IS25|INSTRH, DYAOP6-256, 16, 0x929eL}, ! 61: -{"addw2", IS25|INSTRW, DYAOP6-256, 16, 0x909cL}, ! 62: -{"addb3", IS25|INSTRB, TRIOP1-256, 8, 0xdfL}, ! 63: -{"addh3", IS25|INSTRH, TRIOP1-256, 8, 0xdeL}, ! 64: -{"addw3", IS25|INSTRW, TRIOP1-256, 8, 0xdcL}, ! 65: -{"subb2", IS25|INSTRB, DYAOP6-256, 16, 0x97bfL}, ! 66: -{"subh2", IS25|INSTRH, DYAOP6-256, 16, 0x96beL}, ! 67: -{"subw2", IS25|INSTRW, DYAOP6-256, 16, 0x94bcL}, ! 68: -{"subb3", IS25|INSTRB, TRIOP1-256, 8, 0xffL}, ! 69: -{"subh3", IS25|INSTRH, TRIOP1-256, 8, 0xfeL}, ! 70: -{"subw3", IS25|INSTRW, TRIOP1-256, 8, 0xfcL}, ! 71: -{"mulw2", IS25|INSTRW, DYAOP1-256, 8, 0xa8L}, ! 72: -{"umulw2", IS25|INSTRW, DYAOP8-256, 8, 0xa8L}, ! 73: -{"mulw3", IS25|INSTRW, TRIOP1-256, 8, 0xe8L}, ! 74: -{"umulw3", IS25|INSTRW, TRIOP2-256, 8, 0xe8L}, ! 75: -{"divw2", IS25|INSTRW, DYAOP1-256, 8, 0xacL}, ! 76: -{"udivw2", IS25|INSTRW, DYAOP8-256, 8, 0xacL}, ! 77: -{"divw3", IS25|INSTRW, TRIOP1-256, 8, 0xecL}, ! 78: -{"udivw3", IS25|INSTRW, TRIOP2-256, 8, 0xecL}, ! 79: -{"modw2", IS25|INSTRW, DYAOP1-256, 8, 0xa4L}, ! 80: -{"umodw2", IS25|INSTRW, DYAOP8-256, 8, 0xa4L}, ! 81: -{"modw3", IS25|INSTRW, TRIOP1-256, 8, 0xe4L}, ! 82: -{"umodw3", IS25|INSTRW, TRIOP2-256, 8, 0xe4L}, ! 83: -#if FLOAT ! 84: -{"fadds2", INSTRW, FPDYAOP1-256, 8, 0x31L}, ! 85: -{"fsubs2", INSTRW, FPDYAOP1-256, 8, 0x41L}, ! 86: -{"fmuls2", INSTRW, FPDYAOP1-256, 8, 0x51L}, ! 87: -{"fdivs2", INSTRW, FPDYAOP1-256, 8, 0x61L}, ! 88: -{"movhs", INSTRHW, FPDYAOP2-256, 8, 0x71L}, ! 89: -{"movws", INSTRW, FPDYAOP2-256, 8, 0x81L}, ! 90: -{"movss", INSTRW, FPDYAOP1-256, 8, 0x91L}, ! 91: -{"movsd", INSTRW, FPDYAOP1-256, 8, 0xa1L}, ! 92: -{"movsh", INSTRW, FPDYAOP1-256, 8, 0xb1L}, ! 93: -{"movtsh", INSTRW, FPDYAOP1-256, 8, 0xc1L}, ! 94: -{"movsw", INSTRW, FPDYAOP1-256, 8, 0xd1L}, ! 95: -{"movtsw", INSTRW, FPDYAOP1-256, 8, 0xe1L}, ! 96: -{"fcmps", INSTRW, FPCMPOP1-256, 8, 0xf1L}, ! 97: -{"faddd2", INSTRD, FPDYAOP1-256, 8, 0x35L}, ! 98: -{"fsubd2", INSTRD, FPDYAOP1-256, 8, 0x45L}, ! 99: -{"fmuld2", INSTRD, FPDYAOP1-256, 8, 0x55L}, ! 100: -{"fdivd2", INSTRD, FPDYAOP1-256, 8, 0x65L}, ! 101: -{"movhd", INSTRH, FPDYAOP2-256, 8, 0x75L}, ! 102: -{"movwd", INSTRW, FPDYAOP2-256, 8, 0x85L}, ! 103: -{"movds", INSTRD, FPDYAOP1-256, 8, 0x95L}, ! 104: -{"movdd", INSTRD, FPDYAOP1-256, 8, 0xa5L}, ! 105: -{"movdh", INSTRD, FPDYAOP1-256, 8, 0xb5}, ! 106: -{"movtdh", INSTRD, FPDYAOP1-256, 8, 0xc5}, ! 107: -{"movdw", INSTRD, FPDYAOP1-256, 8, 0xd5L}, ! 108: -{"movtdw", INSTRD, FPDYAOP1-256, 8, 0xe5L}, ! 109: -{"fcmpd", INSTRD, FPCMPOP1-256, 8, 0xf5L}, ! 110: -{"fadds3", INSTRW, FPTRIOP1-256, 8, 0x39L}, ! 111: -{"fsubs3", INSTRW, FPTRIOP1-256, 8, 0x49L}, ! 112: -{"fmuls3", INSTRW, FPTRIOP1-256, 8, 0x59L}, ! 113: -{"fdivs3", INSTRW, FPTRIOP1-256, 8, 0x69L}, ! 114: -{"faddd3", INSTRD, FPTRIOP1-256, 8, 0x79L}, ! 115: -{"fsubd3", INSTRD, FPTRIOP1-256, 8, 0x89L}, ! 116: -{"fmuld3", INSTRD, FPTRIOP1-256, 8, 0x99L}, ! 117: -{"fdivd3", INSTRD, FPTRIOP1-256, 8, 0xa9L}, ! 118: -#endif ! 119: -{"alsw2", IS25|INSTRBW, DYAOP3-256, 16, 0xc0L}, ! 120: -{"alsw3", IS25|INSTRBW, SHFTOP1-256, 16, 0xc0L}, ! 121: -{"arsw2", IS25|INSTRW, DYAOP3-256, 16, 0xc4L}, ! 122: -{"arsw3", IS25|INSTRW, SHFTOP1-256, 16, 0xc4L}, ! 123: -{"cmpb", IS25|INSTRB, CMPOP1-256, 16, 0x2b3fL}, ! 124: -{"cmph", IS25|INSTRH, CMPOP1-256, 16, 0x2a3eL}, ! 125: -{"cmpw", IS25|INSTRW, CMPOP1-256, 16, 0x283cL}, ! 126: -{"jbc", IS25|INSTRW, JMBOP1-256, 8, 0x38L}, ! 127: -{"jbs", IS25|INSTRW, JMBOP1-256, 8, 0x38L}, ! 128: -{"rsb", IS25|INSTRW, ZEROP1-256, 8, 0x78L}, ! 129: -{"acjl", IS25|INSTRW, LOOPOP1-256, 24, 0xb83c4bL}, ! 130: -{"acjlu", IS25|INSTRW, LOOPOP1-256, 24, 0xb83c5bL}, ! 131: -{"acjle", IS25|INSTRW, LOOPOP1-256, 24, 0xb83c4fL}, ! 132: -{"acjleu", IS25|INSTRW, LOOPOP1-256, 24, 0xb83c5fL}, ! 133: -{"atjnzb", IS25|INSTRW, LOOPOP2-256, 8, 0x2bL}, ! 134: -{"atjnzh", IS25|INSTRW, LOOPOP2-256, 8, 0x2aL}, ! 135: -{"atjnzw", IS25|INSTRW, LOOPOP2-256, 8, 0x28L}, ! 136: -{"movblb", IS25|INSTRB, BLOCKOP-256, 8, 0x87L}, ! 137: -{"movblh", IS25|INSTRH, BLOCKOP-256, 8, 0x86L}, ! 138: -{"movblw", IS25|INSTRW, ZEROP1-256, 16, 0x3019L}, ! 139: -{"call", IS25|INSTRW, CALOP1-256, 8, 0x2cL}, ! 140: -{"save", IS25|INSTRW, SAVOP1-256, 8, 0x10L}, ! 141: -{"ret", IS25|INSTRW, RETOP1-256, 16, 0x0818L}, ! 142: -{"insv", IS25|INSTRW, FLDOP1-256, 8, 0xc8L}, ! 143: -{"extzv", IS25|INSTRW, FLDOP2-256, 8, 0xccL}, ! 144: -{"jz", IS25|INSTRW, JMPOP1-256, 16, 0x777fL}, ! 145: -{"jnz", IS25|INSTRW, JMPOP1-256, 16, 0x7f77L}, ! 146: -{"jpos", IS25|INSTRW, JMPOP1-256, 16, 0x4f47L}, ! 147: -{"jnpos", IS25|INSTRW, JMPOP1-256, 16, 0x474fL}, ! 148: -{"jneg", IS25|INSTRW, JMPOP1-256, 16, 0x434bL}, ! 149: -{"jnneg", IS25|INSTRW, JMPOP1-256, 16, 0x4b43L}, ! 150: -{"je", IS25|INSTRW, JMPOP1-256, 16, 0x777fL}, ! 151: -{"jne", IS25|INSTRW, JMPOP1-256, 16, 0x7f77L}, ! 152: -{"jl", IS25|INSTRW, JMPOP1-256, 16, 0x434bL}, ! 153: -{"jle", IS25|INSTRW, JMPOP1-256, 16, 0x474fL}, ! 154: -{"jg", IS25|INSTRW, JMPOP1-256, 16, 0x4f47L}, ! 155: -{"jge", IS25|INSTRW, JMPOP1-256, 16, 0x4b43L}, ! 156: -{"jlu", IS25|INSTRW, JMPOP1-256, 16, 0x535bL}, ! 157: -{"jleu", IS25|INSTRW, JMPOP1-256, 16, 0x575fL}, ! 158: -{"jgu", IS25|INSTRW, JMPOP1-256, 16, 0x5f57L}, ! 159: -{"jgeu", IS25|INSTRW, JMPOP1-256, 16, 0x5b53L}, ! 160: -{"jmp", IS25|INSTRW, JMPOP1-256, 8, 0x7bL}, ! 161: -{"jsb", IS25|INSTRW, JSBOP1-256, 16, 0x3437L}, ! 162: -{"BEB", INSTRB, JMPOP1-256, 8, 0x7fL}, ! 163: -{"BNEB", INSTRB, JMPOP1-256, 8, 0x77L}, ! 164: -{"BLB", INSTRB, JMPOP1-256, 8, 0x4bL}, ! 165: -{"BLEB", INSTRB, JMPOP1-256, 8, 0x4fL}, ! 166: -{"BGB", INSTRB, JMPOP1-256, 8, 0x47L}, ! 167: -{"BGEB", INSTRB, JMPOP1-256, 8, 0x43L}, ! 168: -{"BLUB", INSTRB, JMPOP1-256, 8, 0x5bL}, ! 169: -{"BLEUB", INSTRB, JMPOP1-256, 8, 0x5fL}, ! 170: -{"BGUB", INSTRB, JMPOP1-256, 8, 0x57L}, ! 171: -{"BGEUB", INSTRB, JMPOP1-256, 8, 0x53L}, ! 172: -{"BRB", INSTRB, JMPOP1-256, 8, 0x7bL}, ! 173: -{"BSBB", INSTRB, BSBOP1-256, 8, 0x37L}, ! 174: -{"BEH", INSTRH, JMPOP1-256, 8, 0x7eL}, ! 175: -{"BNEH", INSTRH, JMPOP1-256, 8, 0x76L}, ! 176: -{"BLH", INSTRH, JMPOP1-256, 8, 0x4aL}, ! 177: -{"BLEH", INSTRH, JMPOP1-256, 8, 0x4eL}, ! 178: -{"BGH", INSTRH, JMPOP1-256, 8, 0x46L}, ! 179: -{"BGEH", INSTRH, JMPOP1-256, 8, 0x42L}, ! 180: -{"BLUH", INSTRH, JMPOP1-256, 8, 0x5aL}, ! 181: -{"BLEUH", INSTRH, JMPOP1-256, 8, 0x5eL}, ! 182: -{"BGUH", INSTRH, JMPOP1-256, 8, 0x56L}, ! 183: -{"BGEUH", INSTRH, JMPOP1-256, 8, 0x52L}, ! 184: -{"BRH", INSTRH, JMPOP1-256, 8, 0x7aL}, ! 185: -{"BSBH", INSTRH, BSBOP1-256, 8, 0x36L}, ! 186: -{"CALL", INSTRW, CALOP2-256, 8, 0x2cL}, ! 187: -{"SAVE", INSTRW, SAVOP2-256, 8, 0x10L}, ! 188: -{"RESTORE", INSTRW, SAVOP2-256, 8, 0x18L}, ! 189: -{"RET", INSTRW, ZEROP1-256, 8, 0x08L}, ! 190: -{"GATE", INSTRW, ZEROP1-256, 16, 0x3061L}, ! 191: -{"RETG", INSTRW, ZEROP1-256, 16, 0x3045L}, ! 192: -{"CALLPS", INSTRW, ZEROP1-256, 16, 0x30acL}, ! 193: -{"RETPS", INSTRW, ZEROP1-256, 16, 0x30c8L}, ! 194: -{"MVERNO", INSTRW, ZEROP1-256, 16, 0x3009L}, /* 12 */ ! 195: -{"DISVJMP", INSTRW, ZEROP1-256, 16, 0x3013L}, ! 196: -{"ENBVJMP", INSTRW, ZEROP1-256, 16, 0x300dL}, ! 197: -{"STREND", INSTRW, ZEROP1-256, 16, 0x301fL}, ! 198: -{"STRCPY", INSTRW, ZEROP1-256, 16, 0x3035L}, ! 199: -{"SLFTST", INSTRW, ZEROP1-256, 16, 0x303cL}, ! 200: -{"WAIT", INSTRW, ZEROP1-256, 8, 0x2fL}, ! 201: -{"BPT", INSTRW, ZEROP1-256, 8, 0x2eL}, ! 202: -{"SWAPWI", INSTRW, MONOP1-256, 8, 0x1cL}, ! 203: -{"SWAPHI", INSTRH, MONOP1-256, 8, 0x1eL}, ! 204: -{"SWAPBI", INSTRB, MONOP1-256, 8, 0x1fL}, ! 205: -{"POPW", INSTRW, MONOP3-256, 8, 0x20L}, ! 206: -{"TSTW", INSTRW, MONOP1-256, 8, 0x28L}, ! 207: -{"TSTH", INSTRH, MONOP1-256, 8, 0x2aL}, ! 208: -{"TSTB", INSTRB, MONOP1-256, 8, 0x2bL}, ! 209: -{"RGEQ", INSTRW, ZEROP1-256, 8, 0x40L}, ! 210: -{"RGEQU", INSTRW, ZEROP1-256, 8, 0x50L}, ! 211: -{"RGTR", INSTRW, ZEROP1-256, 8, 0x44L}, ! 212: -{"RLSS", INSTRW, ZEROP1-256, 8, 0x48L}, ! 213: -{"RLSSU", INSTRW, ZEROP1-256, 8, 0x58L}, ! 214: -{"RLEQ", INSTRW, ZEROP1-256, 8, 0x4cL}, ! 215: -{"RCC", INSTRW, ZEROP1-256, 8, 0x50L}, ! 216: -{"RGTRU", INSTRW, ZEROP1-256, 8, 0x54L}, ! 217: -{"RCS", INSTRW, ZEROP1-256, 8, 0x58L}, ! 218: -{"RLEQU", INSTRW, ZEROP1-256, 8, 0x5cL}, ! 219: -{"RVC", INSTRW, ZEROP1-256, 8, 0x60L}, ! 220: -{"BVCH", INSTRH, JMPOP1-256, 8, 0x62L}, ! 221: -{"BVCB", INSTRB, JMPOP1-256, 8, 0x63L}, ! 222: -{"RVS", INSTRW, ZEROP1-256, 8, 0x68L}, ! 223: -{"BVSH", INSTRH, JMPOP1-256, 8, 0x6aL}, ! 224: -{"BVSB", INSTRB, JMPOP1-256, 8, 0x6bL}, ! 225: -{"BCCB", INSTRB, JMPOP1-256, 8, 0x53L}, ! 226: -{"BCSB", INSTRB, JMPOP1-256, 8, 0x5bL}, ! 227: -{"BCCH", INSTRH, JMPOP1-256, 8, 0x52L}, ! 228: -{"BCSH", INSTRH, JMPOP1-256, 8, 0x5aL}, ! 229: -{"BEQLBX", INSTRB, JMPOP1-256, 8, 0x6fL}, ! 230: -{"BEQLHX", INSTRH, JMPOP1-256, 8, 0x6eL}, ! 231: -{"BNEQBX", INSTRB, JMPOP1-256, 8, 0x67L}, ! 232: -{"BNEQHX", INSTRH, JMPOP1-256, 8, 0x66L}, ! 233: -{"JMP", INSTRW, JMPOP1-256, 8, 0x24L}, ! 234: -{"JSB", INSTRW, JSBOP2-256, 8, 0x34L}, ! 235: -{"RNEQ", INSTRW, ZEROP1-256, 8, 0x74L}, ! 236: -{"RNEQU", INSTRW, ZEROP1-256, 8, 0x64L}, ! 237: -{"NOP", INSTRW, ZEROP1-256, 8, 0x70L}, ! 238: -{"NOP3", INSTRW, ZEROP1-256, 24, 0x720000L}, ! 239: -{"NOP2", INSTRW, ZEROP1-256, 16, 0x7300L}, ! 240: -{"REQL", INSTRW, ZEROP1-256, 8, 0x7cL}, ! 241: -{"REQLU", INSTRW, ZEROP1-256, 8, 0x6cL}, ! 242: -{"CLRW", INSTRW, MONOP1-256, 8, 0x80L}, ! 243: -{"CLRH", INSTRH, MONOP1-256, 8, 0x82L}, ! 244: -{"CLRB", INSTRB, MONOP1-256, 8, 0x83L}, ! 245: -{"MNEGB", INSTRB, DYAOP1-256, 8, 0x8fL}, ! 246: -{"INCW", INSTRW, MONOP1-256, 8, 0x90L}, ! 247: -{"INCH", INSTRH, MONOP1-256, 8, 0x92L}, ! 248: -{"INCB", INSTRB, MONOP1-256, 8, 0x93L}, ! 249: -{"DECW", INSTRW, MONOP1-256, 8, 0x94L}, ! 250: -{"DECH", INSTRH, MONOP1-256, 8, 0x96L}, ! 251: -{"DECB", INSTRB, MONOP1-256, 8, 0x97L}, ! 252: -{"MODH2", INSTRH, DYAOP1-256, 8, 0xa6L}, ! 253: -{"MODB2", INSTRB, DYAOP1-256, 8, 0xa7L}, ! 254: -{"MULH2", INSTRH, DYAOP1-256, 8, 0xaaL}, ! 255: -{"MULB2", INSTRB, DYAOP1-256, 8, 0xabL}, ! 256: -{"DIVH2", INSTRH, DYAOP1-256, 8, 0xaeL}, ! 257: -{"DIVB2", INSTRB, DYAOP1-256, 8, 0xafL}, ! 258: -{"ALSW3", INSTRW, TRIOP1-256, 8, 0xc0L}, ! 259: -{"ARSW3", INSTRW, TRIOP1-256, 8, 0xc4L}, ! 260: -{"ARSH3", INSTRH, TRIOP1-256, 8, 0xc6L}, ! 261: -{"ARSB3", INSTRB, TRIOP1-256, 8, 0xc7L}, ! 262: -{"LLSW3", INSTRW, TRIOP1-256, 8, 0xd0L}, ! 263: -{"LLSH3", INSTRH, TRIOP1-256, 8, 0xd2L}, ! 264: -{"LLSB3", INSTRB, TRIOP1-256, 8, 0xd3L}, ! 265: -{"LRSW3", INSTRW, TRIOP1-256, 8, 0xd4L}, ! 266: -{"ROTW", INSTRW, TRIOP1-256, 8, 0xd8L}, ! 267: -{"MODH3", INSTRH, TRIOP1-256, 8, 0xe6L}, ! 268: -{"MODB3", INSTRB, TRIOP1-256, 8, 0xe7L}, ! 269: -{"MULH3", INSTRH, TRIOP1-256, 8, 0xeaL}, ! 270: -{"MULB3", INSTRB, TRIOP1-256, 8, 0xebL}, ! 271: -{"DIVH3", INSTRH, TRIOP1-256, 8, 0xeeL}, ! 272: -{"DIVB3", INSTRB, TRIOP1-256, 8, 0xefL}, ! 273: -{"MCOMB", INSTRB, DYAOP1-256, 8, 0x8bL}, ! 274: -{"MCOMH", INSTRH, DYAOP1-256, 8, 0x8aL}, ! 275: -{"MCOMW", INSTRW, DYAOP1-256, 8, 0x88L}, ! 276: -{"MOVTRW", INSTRW, DYAOP2-256, 8, 0xcL}, ! 277: -{"MOVAW", INSTRW, DYAOP2-256, 8, 0x4L}, ! 278: -{"PUSHAW", INSTRW, MONOP2-256, 8, 0xe0L}, ! 279: -{"ANDB2", INSTRB, DYAOP1-256, 8, 0xbbL}, ! 280: -{"ANDH2", INSTRH, DYAOP1-256, 8, 0xbaL}, ! 281: -{"ANDW2", INSTRW, DYAOP1-256, 8, 0xb8L}, ! 282: -{"ANDB3", INSTRB, TRIOP1-256, 8, 0xfbL}, ! 283: -{"ANDH3", INSTRH, TRIOP1-256, 8, 0xfaL}, ! 284: -{"ANDW3", INSTRW, TRIOP1-256, 8, 0xf8L}, ! 285: -{"ORB2", INSTRB, DYAOP1-256, 8, 0xb3L}, ! 286: -{"ORH2", INSTRH, DYAOP1-256, 8, 0xb2L}, ! 287: -{"ORW2", INSTRW, DYAOP1-256, 8, 0xb0L}, ! 288: -{"ORB3", INSTRB, TRIOP1-256, 8, 0xf3L}, ! 289: -{"ORH3", INSTRH, TRIOP1-256, 8, 0xf2L}, ! 290: -{"ORW3", INSTRW, TRIOP1-256, 8, 0xf0L}, ! 291: -{"XORB2", INSTRB, DYAOP1-256, 8, 0xb7L}, ! 292: -{"XORH2", INSTRH, DYAOP1-256, 8, 0xb6L}, ! 293: -{"XORW2", INSTRW, DYAOP1-256, 8, 0xb4L}, ! 294: -{"XORB3", INSTRB, TRIOP1-256, 8, 0xf7L}, ! 295: -{"XORH3", INSTRH, TRIOP1-256, 8, 0xf6L}, ! 296: -{"XORW3", INSTRW, TRIOP1-256, 8, 0xf4L}, ! 297: -{"BITB", INSTRB, CMPOP2-256, 8, 0x3bL}, ! 298: -{"BITH", INSTRH, CMPOP2-256, 8, 0x3aL}, ! 299: -{"BITW", INSTRW, CMPOP2-256, 8, 0x38L}, ! 300: -{"MOVB", INSTRB, DYAOP4-256, 8, 0x87L}, ! 301: -{"MOVH", INSTRH, DYAOP4-256, 8, 0x86L}, ! 302: -{"MOVW", INSTRW, DYAOP4-256, 8, 0x84L}, ! 303: -{"MNEGH", INSTRH, DYAOP1-256, 8, 0x8eL}, ! 304: -{"MNEGW", INSTRW, DYAOP1-256, 8, 0x8cL}, ! 305: -{"PUSHW", INSTRW, MONOP1-256, 8, 0xa0L}, ! 306: -{"ADDB2", INSTRB, DYAOP6-256, 8, 0x9fL}, ! 307: -{"ADDH2", INSTRH, DYAOP6-256, 8, 0x9eL}, ! 308: -{"ADDW2", INSTRW, DYAOP6-256, 8, 0x9cL}, ! 309: -{"ADDB3", INSTRB, TRIOP1-256, 8, 0xdfL}, ! 310: -{"ADDH3", INSTRH, TRIOP1-256, 8, 0xdeL}, ! 311: -{"ADDW3", INSTRW, TRIOP1-256, 8, 0xdcL}, ! 312: -{"SUBB2", INSTRB, DYAOP6-256, 8, 0xbfL}, ! 313: -{"SUBH2", INSTRH, DYAOP6-256, 8, 0xbeL}, ! 314: -{"SUBW2", INSTRW, DYAOP6-256, 8, 0xbcL}, ! 315: -{"SUBB3", INSTRB, TRIOP1-256, 8, 0xffL}, ! 316: -{"SUBH3", INSTRH, TRIOP1-256, 8, 0xfeL}, ! 317: -{"SUBW3", INSTRW, TRIOP1-256, 8, 0xfcL}, ! 318: -{"MULW2", INSTRW, DYAOP1-256, 8, 0xa8L}, ! 319: -{"MULW3", INSTRW, TRIOP1-256, 8, 0xe8L}, ! 320: -{"DIVW2", INSTRW, DYAOP1-256, 8, 0xacL}, ! 321: -{"DIVW3", INSTRW, TRIOP1-256, 8, 0xecL}, ! 322: -{"MODW2", INSTRW, DYAOP1-256, 8, 0xa4L}, ! 323: -{"MODW3", INSTRW, TRIOP1-256, 8, 0xe4L}, ! 324: -{"CMPB", INSTRB, CMPOP1-256, 8, 0x3fL}, ! 325: -{"CMPH", INSTRH, CMPOP1-256, 8, 0x3eL}, ! 326: -{"CMPW", INSTRW, CMPOP1-256, 8, 0x3cL}, ! 327: -{"RSB", INSTRW, ZEROP1-256, 8, 0x78L}, ! 328: -{"MOVBLW", INSTRW, ZEROP1-256, 16, 0x3019L}, ! 329: -{"INSFW", INSTRW, FLDOP4-256, 8, 0xc8L}, ! 330: -{"INSFH", INSTRH, FLDOP4-256, 8, 0xcaL}, ! 331: -{"INSFB", INSTRB, FLDOP4-256, 8, 0xcbL}, ! 332: -{"EXTFW", INSTRW, FLDOP4-256, 8, 0xccL}, ! 333: -{"EXTFH", INSTRH, FLDOP4-256, 8, 0xceL}, ! 334: -{"EXTFB", INSTRB, FLDOP4-256, 8, 0xcfL}, ! 335: -{"EXTOP", INSTRX, SIMOP-256, 8, 0x14L}, ! 336: -{"getsm", INSTRX, ZEROP1-256, 8, 0x1L}, ! 337: -{"putsm", INSTRX, ZEROP1-256, 8, 0x11L}, ! 338: -{"ungetsm", INSTRX, ZEROP1-256, 8, 0x21L}, ! 339: -{"r0", DUMMY, REGISTER-256, 4, 0x0L}, ! 340: -{"r1", DUMMY, REGISTER-256, 4, 0x1L}, ! 341: -{"r2", DUMMY, REGISTER-256, 4, 0x2L}, ! 342: -{"r3", DUMMY, REGISTER-256, 4, 0x3L}, ! 343: -{"r4", DUMMY, REGISTER-256, 4, 0x4L}, ! 344: -{"r5", DUMMY, REGISTER-256, 4, 0x5L}, ! 345: -{"r6", DUMMY, REGISTER-256, 4, 0x6L}, ! 346: -{"r7", DUMMY, REGISTER-256, 4, 0x7L}, ! 347: -{"r8", DUMMY, REGISTER-256, 4, 0x8L}, ! 348: -{"fp", DUMMY, REGISTER-256, 4, 0x9L}, ! 349: -{"ap", DUMMY, REGISTER-256, 4, 0xaL}, ! 350: -{"psw", DUMMY, REGISTER-256, 4, 0xbL}, ! 351: -{"sp", DUMMY, REGISTER-256, 4, 0xcL}, ! 352: -{"pcbp", DUMMY, REGISTER-256, 4, 0xdL}, ! 353: -{"isp", DUMMY, REGISTER-256, 4, 0xeL}, ! 354: -{".globl", PSEUDO, PSGLOBAL-256, 0, 0x0L}, ! 355: -{".comm", PSEUDO, PSCOMM-256, 0, 0x0L}, ! 356: -{".set", PSEUDO, PSSET-256, 0, 0x0L}, ! 357: -{".zero", PSEUDO, PSZERO-256, 0, 0x0L}, ! 358: -{".bss", BSS, PSBSS-256, 0, 0x0L}, ! 359: -{".file", PSEUDO, PSFILE-256, 0, 0x0L}, ! 360: -{".align", PSEUDO, PSALIGN-256, 0, 0x0L}, ! 361: -{".byte", PSEUDO, PSBYTE-256, 0, 0x0L}, ! 362: -{".half", PSEUDO, PSHALF-256, 0, 0x0L}, ! 363: -{".word", PSEUDO, PSWORD-256, 0, 0x0L}, ! 364: -#if FLOAT ! 365: -{".float", PSEUDO, PSFLOAT-256, 0, 0x0L}, ! 366: -{".double", PSEUDO, PSDOUBLE-256, 0, 0x0L}, ! 367: -#endif ! 368: -{".def", PSEUDO, PSDEF-256, 0, 0x0L}, ! 369: -{".val", PSEUDO, PSVAL-256, 0, 0x0L}, ! 370: -{".scl", PSEUDO, PSSCL-256, 0, 0x0L}, ! 371: -{".type", PSEUDO, PSTYPE-256, 0, 0x0L}, ! 372: -{".tag", PSEUDO, PSTAG-256, 0, 0x0L}, ! 373: -{".line", PSEUDO, PSLINE-256, 0, 0x0L}, ! 374: -{".size", PSEUDO, PSSIZE-256, 0, 0x0L}, ! 375: -{".dim", PSEUDO, PSDIM-256, 0, 0x0L}, ! 376: -{".endef", PSEUDO, PSENDEF-256, 0, 0x0L}, ! 377: -{".ln", PSEUDO, PSLN-256, 0, 0x0L}, ! 378: -{".text", TXT, SECTIONN-256, 0, 0x0L}, ! 379: -{".data", DAT, SECTIONN-256, 0, 0x0L}, ! 380: -{"sbyte", DUMMY, EXPTYPE-256, 8, 0x7L}, ! 381: -{"ubyte", DUMMY, EXPTYPE-256, 8, 0x3L}, ! 382: -{"byte", DUMMY, EXPTYPE-256, 8, 0x7L}, ! 383: -{"shalf", DUMMY, EXPTYPE-256, 8, 0x6L}, ! 384: -{"half", DUMMY, EXPTYPE-256, 8, 0x6L}, ! 385: -{"uhalf", DUMMY, EXPTYPE-256, 8, 0x2L}, ! 386: -{"sword", DUMMY, EXPTYPE-256, 8, 0x4L}, ! 387: -{"word", DUMMY, EXPTYPE-256, 8, 0x4L}, ! 388: -{"uword", DUMMY, EXPTYPE-256, 8, 0x0L}, ! 389: - ! 390: //GO.SYSIN DD 3binstr.c ! 391: echo 5bb.c 1>&2 ! 392: sed 's/.//' >5bb.c <<'//GO.SYSIN DD 5bb.c' ! 393: -#define unsafe 1 /* pretend killing all but C is as good as killing ! 394: - * all condition codes */ ! 395: -#ifdef unsafe ! 396: -#define E (C|K) ! 397: -#else ! 398: -#define E K ! 399: -#endif ! 400: -#include "stdio.h" ! 401: -#include "instr.c" ! 402: -#include "ctype.h" ! 403: -struct inst *index[128]; ! 404: - ! 405: -#define SBBLK 1 /* looking for the start of a basic block */ ! 406: -#define SINST 2 /* thinking about generating a tally */ ! 407: -#define SPRO 3 /* thinking about generating prolog code */ ! 408: -#define SMAYBE 4 /* seen _, thinking about SPRO */ ! 409: - ! 410: -#define MAXLA 5 /* max no. of lines that can be read for lookahead */ ! 411: - ! 412: -FILE *outs, *fd, *outl; /* outs goes to assembler, outl is for listing */ ! 413: -extern FILE *popen(); ! 414: -char line[256], fname[256]; /* file names must fit in fname */ ! 415: - ! 416: -char labuf[5][256]; /* look ahead needed for 5.0 stab entries */ ! 417: -int lastla, lookahead; ! 418: -char begfcn[] = " .def .bf"; /* 5.0 stab entry */ ! 419: - ! 420: -int lineno, lastline; ! 421: -int base=0; ! 422: - ! 423: -int cnt; ! 424: -int state = SBBLK; ! 425: -char *ptr, *curarg; ! 426: -char curdir[256]; ! 427: - ! 428: -main(argc, argv) ! 429: -char **argv; ! 430: -{ int i; ! 431: - if(argc <= 1) { ! 432: - fprintf(stderr, "no files given\n"); ! 433: - exit(1); ! 434: - } ! 435: - for(i = 0; insts[i].iname; i++) ! 436: - ; ! 437: - for(; i >= 0; i--) ! 438: - index[insts[i].iname[0]] = insts + i; ! 439: - fd = popen("pwd", "r"); ! 440: - for(i = 0; i < sizeof(curdir) && !feof(fd); i++) ! 441: - curdir[i] = getc(fd); ! 442: - curdir[i-2] = 0; /* thisdir\n */ ! 443: - fclose(fd); ! 444: - for(i = 1; i < argc; i++) { ! 445: - if(setfd(argv[i])) /* fix fd, outs, outl */ ! 446: - doarg(); /* do the work */ ! 447: - } ! 448: - exit(0); ! 449: -} ! 450: - ! 451: -setfd(s) ! 452: -char *s; ! 453: -{ char outnams[24], outnaml[24]; ! 454: - fname[0] = 0; ! 455: - cnt = 3; ! 456: - if(fd != NULL) ! 457: - fclose(fd); ! 458: - if(outs != NULL) ! 459: - fclose(outs); ! 460: - if(outl != NULL) ! 461: - fclose(outl); ! 462: - sprintf(outnams, "X%s", s); ! 463: - sprintf(outnaml, "%sL", s); ! 464: - lastline = lineno = 0; ! 465: - fd = fopen(s, "r"); ! 466: - if(fd == NULL) { ! 467: - perror(s); ! 468: - return(0); ! 469: - } ! 470: - outs = fopen(outnams, "w"); ! 471: - if(outs == NULL) { ! 472: - perror(outnams); ! 473: - return(0); ! 474: - } ! 475: - outl = fopen(outnaml, "w"); ! 476: - if(outl == NULL) { ! 477: - perror(outnaml); ! 478: - return(0); ! 479: - } ! 480: - curarg = s; ! 481: - return(1); ! 482: -} ! 483: - ! 484: -doarg() ! 485: -{ struct inst *x, *firstword(); ! 486: - ! 487: - state = SBBLK; ! 488: - lookahead = 0; /* empty buffer */ ! 489: - lastla = 0; ! 490: - for(;;) { ! 491: - if (lookahead != lastla){ ! 492: - strcpy(line,labuf[ (lookahead++) % MAXLA ] ); ! 493: - if (lookahead == lastla) lookahead = lastla = 0; ! 494: - } ! 495: - else ! 496: - (void) fgets(line, sizeof(line), fd); ! 497: - if(feof(fd)) ! 498: - break; ! 499: - for(ptr = line; isspace(*ptr); *ptr++) ! 500: - ; ! 501: - if(*ptr == 0 || *ptr == '#') ! 502: - continue; ! 503: - testlabel(); ! 504: - /* deal with symbol table info */ ! 505: - if(*ptr == '.') { ! 506: - stab(); ! 507: - fprintf(outs, " %s", ptr); ! 508: - continue; ! 509: - } ! 510: - if(*ptr == 0 || *ptr == '\n') ! 511: - continue; ! 512: - x = firstword(); ! 513: - if(x == 0){ ! 514: - printf("unknown inst: %s\n",ptr); ! 515: - continue; ! 516: - } ! 517: -#ifdef u3b ! 518: - if ((state == SMAYBE) && !strncmp(ptr,"save",4)){ ! 519: - state = SPRO; ! 520: - getlnum(); /* 5.0 true line # */ ! 521: - } ! 522: -#endif ! 523: - if(state == SPRO) ! 524: - prolog(x); ! 525: - if(state == SINST) ! 526: - tally(x); ! 527: - if(state == SBBLK && (x->type & JUMP)) ! 528: - state = SINST; ! 529: - outinstr(); ! 530: - if(x->type & BYTE) ! 531: - fixinstr(x); ! 532: - fprintf(outs, " %s", ptr); ! 533: - } ! 534: - finish(); ! 535: -} ! 536: - ! 537: - ! 538: -getlnum(){ /* get true line number from 5.0 sdb info */ ! 539: - char *la; ! 540: - int l; ! 541: - ! 542: - /* get true line number by looking ahead */ ! 543: - /* this is necessary for 5.0 sdb output */ ! 544: - do ! 545: - (void) fgets(labuf[l = ((lastla++)%MAXLA)], sizeof(line), fd); ! 546: - while (!feof(fd) && strncmp(begfcn, labuf[l], ! 547: - 9) && (lookahead != (lastla)%MAXLA )); ! 548: - if ( strncmp(begfcn, labuf[l], 9) ) ! 549: - return; /* bad input or not 5.0 */ ! 550: - la = labuf[l]; ! 551: - while ( *la != '\0' ){ ! 552: - while ( *la != ';' && *la != '\0') la++; ! 553: - if ( *la == ';' ) la++; ! 554: - while ( isspace(*la) ) la++; ! 555: - if ( !strncmp(la, ".line" , 5) ){ ! 556: - lineno = base = atoi( la + 5 ); ! 557: - return; ! 558: - } ! 559: - } ! 560: -} ! 561: - ! 562: - ! 563: -/* unbelievable variability in sdb info */ ! 564: -stab() ! 565: -{ char buf[128]; ! 566: - int i, j, k; ! 567: - ! 568: -#ifndef u3b ! 569: - if(state == SMAYBE && strncmp(ptr, ".word", 5) == 0) { ! 570: - state = SPRO; ! 571: - getlnum(); ! 572: - return; ! 573: - } ! 574: -#endif ! 575: - ! 576: - if((i = *(ptr + 1)) != 's' && i != 'f' && i != 'l') ! 577: - return; ! 578: - /* real compiler output */ ! 579: - if(sscanf(ptr, ".stabs \"%[^\"]\", %o", buf, &i) == 2 && i == 0144) ! 580: - strcat(fname, buf); ! 581: - else if(sscanf(ptr, ".stabd %o,%o,%o", &i, &j, &k) == 3 && i == 0104) ! 582: - lineno = k; ! 583: - /* pwb 3.0 */ ! 584: - else if(sscanf(ptr, ".stab %[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%d", ! 585: - buf, buf+2, buf+4, buf+6, buf+8, buf+10, buf+12, buf+14, &i) ! 586: - == 9 && i == 144) { ! 587: - for(i = k = 0; buf[i] ; i++) ! 588: - if(buf[i] == '\'') ! 589: - buf[k++] = buf[++i]; ! 590: - buf[k] = 0; ! 591: - strcat(fname, buf); ! 592: - } ! 593: - else if(sscanf(ptr, ".stab %[0,]%d,%d,%d", buf,&i, &j, &k) == 4 ! 594: - && i == 104) ! 595: - lineno = k; ! 596: - /* pwb 5.0 */ ! 597: - else if(sscanf(ptr," .file \"%[^\"]\"", buf) == 1) ! 598: - strcat(fname, buf); ! 599: - else if(sscanf(ptr, " .ln %d",&k) == 1) ! 600: - lineno = k + base - 1; ! 601: -} ! 602: - ! 603: -testlabel() ! 604: -{ char *p; ! 605: - int i; ! 606: - ! 607: -for(;;){ ! 608: - for(p = ptr; *p; p++) { ! 609: - if(*p == ':') ! 610: - break; ! 611: - if(!isalnum(*p) && *p != '_' && *p != '.') ! 612: - return; ! 613: - } ! 614: - if(*p == 0) ! 615: - return; ! 616: - *p++ = 0; /* that is overwriting the : */ ! 617: - fprintf(outs, "%s:\n", ptr); ! 618: - if (lineno != lastline){ ! 619: - for (i=lastline+1; i < lineno ; i++) /* allign label with right inst */ ! 620: - fprintf(outl, "0 %s: %d\n", fname, i); ! 621: - lastline = lineno - 1; ! 622: - } ! 623: - fprintf(outl, "%d %s:\n", 4*(cnt - 1), ptr); ! 624: -#ifdef u3b ! 625: - if(*ptr != '.') ! 626: -#else ! 627: - if(*ptr == '_' ) ! 628: -#endif ! 629: - state = SMAYBE; ! 630: - else ! 631: - if(state != SPRO) ! 632: - state = SINST; ! 633: - for(ptr = p; isspace(*ptr); ptr++) ! 634: - ; ! 635: - } /* L68:L70: ... */ ! 636: -} ! 637: - ! 638: -struct inst * ! 639: -firstword() ! 640: -{ char buf[sizeof(line)], *p, *q; ! 641: - struct inst *x; ! 642: - for(p = buf, q = ptr; isalnum(*q); ) ! 643: - *p++ = *q++; ! 644: - if(p == buf) ! 645: - return((struct inst *)0); ! 646: - *p = 0; ! 647: - for(x = index[buf[0]]; x && x->iname[0] == buf[0]; x++) ! 648: - if(strcmp(buf, x->iname) == 0) ! 649: - return(x); ! 650: - return(0); ! 651: -} ! 652: - ! 653: -outinstr() ! 654: -{ int i; ! 655: - for(i = lastline + 1; i < lineno; i++) ! 656: - fprintf(outl, "0 %s: %d\n", fname, i); ! 657: - if (lastline != lineno){ ! 658: - fprintf(outl, "%d %s: %d\n", 4*(cnt - 1), fname, lineno); ! 659: - lastline = lineno; ! 660: - } ! 661: - fprintf(outl, "%d %s", 4*(cnt - 1), ptr); ! 662: -} ! 663: - ! 664: -#ifdef u3b ! 665: - ! 666: -/* 3b code ***********************************/ ! 667: -tally(x) ! 668: -struct inst *x; ! 669: -{ ! 670: - if(x->type & E) ! 671: - fprintf(outs, " addw2 &1,locprof+%d\n", 4*cnt++); ! 672: - else { ! 673: - fprintf(outs, " stsm &1,savecc\n"); ! 674: - fprintf(outs, " gcc %%r0\n"); ! 675: - fprintf(outs, " addw2 &1,locprof+%d\n", 4*cnt++); ! 676: - fprintf(outs, " scc %%r0\n"); ! 677: - fprintf(outs, " lsm &1,savecc\n"); ! 678: - } ! 679: - state = SBBLK; ! 680: -} ! 681: - ! 682: -prolog(x) /* no liveness test, presumes can't get here by jump */ ! 683: -struct inst *x; ! 684: -{ int i; ! 685: - fprintf(outs, " .data\n"); ! 686: - fprintf(outs, " .globl proFptr\n"); /* the global chain */ ! 687: - fprintf(outs, " .globl savecc\n"); ! 688: - fprintf(outs, " .text\n"); ! 689: - fprintf(outs, " cmpw &0,locprof+4\n"); ! 690: - fprintf(outs, " jne L%da\n", i = cnt); ! 691: - fprintf(outs, " movw proFptr,locprof+4\n"); ! 692: - fprintf(outs, " movaw locprof,proFptr\n"); ! 693: - fprintf(outs, "L%da: addw2 &1,locprof+%d\n", i, 4*cnt++); ! 694: - state = SBBLK; ! 695: -} ! 696: - ! 697: -finish() ! 698: -{ int i; ! 699: - fprintf(outs, " .data\n"); ! 700: - fprintf(outs, " .align 4\n"); ! 701: - fprintf(outs, "locprof:\n"); ! 702: - fprintf(outs, " .word %d\n", cnt); ! 703: - fprintf(outs, " .word 0\n"); ! 704: - fprintf(outs, " .word L%db\n", cnt); ! 705: - fprintf(outs, " .zero %d\n", 4 * cnt); ! 706: - fprintf(outs, "L%db: .byte ", cnt); ! 707: - for(i = 0; curdir[i]; i++) ! 708: - fprintf(outs, " 0x%x,", curdir[i]); ! 709: - fprintf(outs, " 0x%x\n", '/'); ! 710: - fprintf(outs, " .byte "); ! 711: - if(fname[0]) ! 712: - for(i = 0; fname[i]; i++) ! 713: - fprintf(outs, " 0x%x,", fname[i]); ! 714: - else ! 715: - for(i = 0; curarg[i]; i++) ! 716: - fprintf(outs, " 0x%x,", curarg[i]); ! 717: - fprintf(outs, "0\n"); ! 718: -} ! 719: - ! 720: -#else ! 721: - ! 722: -/* Vax code **************************/ ! 723: -tally(x) ! 724: -struct inst *x; ! 725: -{ ! 726: - if(x->type & E) ! 727: - fprintf(outs, " incl locprof+%d\n", 4*cnt++); ! 728: - else { ! 729: - fprintf(outs, " movpsl -(sp)\n"); ! 730: - fprintf(outs, " incl locprof+%d\n", 4*cnt++); ! 731: - fprintf(outs, " movw (sp)+,(sp)\n"); ! 732: - fprintf(outs, " bicpsw $0xff\n"); ! 733: - fprintf(outs, " bispsw (sp)+\n"); ! 734: - /* thanks to kirk mckusick */ ! 735: - } ! 736: - state = SBBLK; ! 737: -} ! 738: - ! 739: - ! 740: -prolog(x) /* no liveness test, presumes can't get here by jump */ ! 741: -struct inst *x; ! 742: -{ int i; ! 743: - fprintf(outs, " .data\n"); ! 744: - fprintf(outs, " .comm _proFptr,4\n"); /* the global chain */ ! 745: - fprintf(outs, " .text\n"); ! 746: - /*if(!(x->type & E)) ! 747: - fprintf(outs, " movpsl -(sp)\n");*/ ! 748: - fprintf(outs, " tstl locprof+4\n"); ! 749: - fprintf(outs, " bneq L%da\n", i = cnt); ! 750: - fprintf(outs, " movl _proFptr,locprof+4\n"); ! 751: - fprintf(outs, " moval locprof,_proFptr\n"); ! 752: - fprintf(outs, "L%da: incl locprof+%d\n", i, 4*cnt++); ! 753: - /*if(!(x->type & E)) { ! 754: - fprintf(outs, " movw (sp)+,(sp)\n"); ! 755: - fprintf(outs, " bicpsw $0xff\n"); ! 756: - fprintf(outs, " bispsw (sp)+\n"); ! 757: - }*/ ! 758: - state = SBBLK; ! 759: -} ! 760: - ! 761: -finish() ! 762: -{ int i; ! 763: - fprintf(outs, " .data\n"); ! 764: - fprintf(outs, "locprof: .long %d\n", cnt); ! 765: - fprintf(outs, " .long 0\n"); ! 766: - fprintf(outs, " .long L%db\n", cnt); ! 767: - fprintf(outs, " .space %d\n", 4 * cnt); ! 768: - fprintf(outs, "L%db: .byte ", cnt); ! 769: - for(i = 0; curdir[i]; i++) ! 770: - fprintf(outs, "0x%x,", curdir[i]); ! 771: - fprintf(outs, "0x%x\n", '/'); ! 772: - fprintf(outs, " .byte "); ! 773: - if(fname[0]) ! 774: - for(i = 0; fname[i]; i++) ! 775: - fprintf(outs, "0x%x,", fname[i]); ! 776: - else ! 777: - for(i = 0; curarg[i]; i++) ! 778: - fprintf(outs, "0x%x,", curarg[i]); ! 779: - fprintf(outs, "0\n"); ! 780: -} ! 781: - ! 782: -#endif ! 783: - ! 784: - ! 785: -fixinstr(x) ! 786: -struct inst *x; ! 787: -{ ! 788: -#ifndef u3b ! 789: - if(x->iname[0] == 'b') ! 790: - *ptr = 'j'; /* let assembler worry about branches */ ! 791: - /* this is where the code for aob and sob goes */ ! 792: -#endif ! 793: -} ! 794: - ! 795: - ! 796: - ! 797: - ! 798: - ! 799: //GO.SYSIN DD 5bb.c ! 800: echo 68k-instr.c 1>&2 ! 801: sed 's/.//' >68k-instr.c <<'//GO.SYSIN DD 68k-instr.c' ! 802: -#define K 1 /* kills all condition codes */ ! 803: -#define JUMP 2 /* ends a basic block */ ! 804: -#define BYTE 4 /* target is byte offset */ ! 805: -#define C 8 /* kills all condition codes but for C bit*/ ! 806: -/* if((p->type & EXPAND) && p->iname[0] == 'b') replace first char with j */ ! 807: -/* aob and sob get replaced by two instructions */ ! 808: - ! 809: -struct inst { ! 810: - char *iname; ! 811: - short type; ! 812: -} insts[] = { ! 813: -{ "abcd", K}, ! 814: -{ "add", K}, ! 815: -{ "addx", K}, ! 816: -{ "and", K}, ! 817: -{ "asl", K}, ! 818: -{ "asr", K}, ! 819: -{ "bcc", 0}, ! 820: -{ "bchg", 0}, ! 821: -{ "bclr", 0}, ! 822: -{ "bcs", 0}, ! 823: -{ "beq", 0}, ! 824: -{ "bge", 0}, ! 825: -{ "bgt", 0}, ! 826: -{ "bhi", 0}, ! 827: -{ "bhs", 0}, ! 828: -{ "ble", 0}, ! 829: -{ "blo", 0}, ! 830: -{ "bls", 0}, ! 831: -{ "blt", 0}, ! 832: -{ "bmi", 0}, ! 833: -{ "bne", 0}, ! 834: -{ "bpl", 0}, ! 835: -{ "br", 0}, ! 836: -{ "bra", 0}, ! 837: -{ "bset", 0}, ! 838: -{ "bsr", 0}, ! 839: -{ "btst", 0}, ! 840: -{ "bvc", 0}, ! 841: -{ "bvs", 0}, ! 842: -{ "chk", K}, ! 843: -{ "clr", K}, ! 844: -{ "cmp", K}, ! 845: -{ "dbcc", 0}, ! 846: -{ "dbcs", 0}, ! 847: -{ "dbeq", 0}, ! 848: -{ "dbge", 0}, ! 849: -{ "dbgt", 0}, ! 850: -{ "dbhi", 0}, ! 851: -{ "dbhs", 0}, ! 852: -{ "dble", 0}, ! 853: -{ "dblo", 0}, ! 854: -{ "dbls", 0}, ! 855: -{ "dblt", 0}, ! 856: -{ "dbmi", 0}, ! 857: -{ "dbne", 0}, ! 858: -{ "dbpl", 0}, ! 859: -{ "dbr", 0}, ! 860: -{ "dbra", 0}, ! 861: -{ "dbvc", 0}, ! 862: -{ "dbvs", 0}, ! 863: -{ "divs", K}, ! 864: -{ "divu", K}, ! 865: -{ "eor", K}, ! 866: -{ "exg", 0}, ! 867: -{ "ext", K}, ! 868: -{ "jmp", 0}, ! 869: -{ "jsr", 0}, ! 870: -{ "lea", 0}, ! 871: -{ "link", 0}, ! 872: -{ "lsl", K}, ! 873: -{ "lsr", K}, ! 874: -{ "mov", K}, ! 875: -{ "movea", 0}, ! 876: -{ "movm", 0}, ! 877: -{ "muls", K}, ! 878: -{ "mulu", K}, ! 879: -{ "nbcd", K}, ! 880: -{ "neg", K}, ! 881: -{ "negx", K}, ! 882: -{ "nop", 0}, ! 883: -{ "not", K}, ! 884: -{ "or", K}, ! 885: -{ "pea", 0}, ! 886: -{ "reset", 0}, ! 887: -{ "rol", K}, ! 888: -{ "ror", K}, ! 889: -{ "roxl", K}, ! 890: -{ "roxr", K}, ! 891: -{ "rte", K}, ! 892: -{ "rtr", K}, ! 893: -{ "rts", 0}, ! 894: -{ "sbcd", K}, ! 895: -{ "scc", 0}, ! 896: -{ "scs", 0}, ! 897: -{ "seq", 0}, ! 898: -{ "sf", 0}, ! 899: -{ "sge", 0}, ! 900: -{ "sgt", 0}, ! 901: -{ "shi", 0}, ! 902: -{ "shs", 0}, ! 903: -{ "sle", 0}, ! 904: -{ "slo", 0}, ! 905: -{ "sls", 0}, ! 906: -{ "slt", 0}, ! 907: -{ "smi", 0}, ! 908: -{ "sne", 0}, ! 909: -{ "spl", 0}, ! 910: -{ "st", 0}, ! 911: -{ "stop", K}, ! 912: -{ "sub", K}, ! 913: -{ "suba", 0}, ! 914: -{ "subx", K}, ! 915: -{ "svc", 0}, ! 916: -{ "svs", 0}, ! 917: -{ "swap", K}, ! 918: -{ "tas", K}, ! 919: -{ "trap", 0}, ! 920: -{ "trapv", 0}, ! 921: -{ "tst", K}, ! 922: -{ "unlk", 0}, ! 923: -{ 0, 0}, ! 924: -}; ! 925: //GO.SYSIN DD 68k-instr.c ! 926: echo README 1>&2 ! 927: sed 's/.//' >README <<'//GO.SYSIN DD README' ! 928: -There's no makefile. Compile bb.c (or 5bb.c if you've unix V) and put ! 929: -the output in bb. fix the shell scripts lcomp, lcc. good luck. [instr.c is ! 930: -included in bb.c, so doesn't get compiled. ! 931: -cc -c nexit.c -o nexit.o; cc -o lprint lprint.c, and that's it] ! 932: -. ! 933: //GO.SYSIN DD README ! 934: echo bb.c 1>&2 ! 935: sed 's/.//' >bb.c <<'//GO.SYSIN DD bb.c' ! 936: -#define unsafe 1 /* pretend killing all but C is as good as killing ! 937: - * all condition codes */ ! 938: -#ifdef unsafe ! 939: -#define E (C|K) ! 940: -#else ! 941: -#define E K ! 942: -#endif ! 943: -#include "stdio.h" ! 944: -#include "instr.c" ! 945: -#include "ctype.h" ! 946: -struct inst *index[128]; ! 947: - ! 948: -#define SBBLK 1 /* looking for the start of a basic block */ ! 949: -#define SINST 2 /* thinking about generating a tally */ ! 950: -#define SPRO 3 /* thinking about generating prolog code */ ! 951: -#define SMAYBE 4 /* seen _, thinking about SPRO */ ! 952: - ! 953: -FILE *outs, *fd, *outl; /* outs goes to assembler, outl is for listing */ ! 954: -extern FILE *popen(); ! 955: -char line[256], fname[256]; /* file names must fit in fname */ ! 956: -char curfunc[256]; ! 957: -int lineno, lastline; ! 958: -int cnt; ! 959: -int state = SBBLK; ! 960: -char *ptr, *curarg; ! 961: -char curdir[256]; ! 962: - ! 963: -main(argc, argv) ! 964: -char **argv; ! 965: -{ int i; ! 966: - if(argc <= 1) { ! 967: - fprintf(stderr, "no files given\n"); ! 968: - exit(1); ! 969: - } ! 970: - for(i = 0; insts[i].iname; i++) ! 971: - ; ! 972: - for(; i >= 0; i--) ! 973: - index[insts[i].iname[0]] = insts + i; ! 974: - fd = popen("pwd", "r"); ! 975: - for(i = 0; i < sizeof(curdir) && !feof(fd); i++) ! 976: - curdir[i] = getc(fd); ! 977: - curdir[i-2] = 0; /* thisdir\n */ ! 978: - fclose(fd); ! 979: - for(i = 1; i < argc; i++) { ! 980: - if(setfd(argv[i])) /* fix fd, outs, outl */ ! 981: - doarg(); /* do the work */ ! 982: - } ! 983: - exit(0); ! 984: -} ! 985: - ! 986: -setfd(s) ! 987: -char *s; ! 988: -{ char outnams[24], outnaml[24]; ! 989: - fname[0] = 0; ! 990: - cnt = 3; ! 991: - if(fd != NULL) ! 992: - fclose(fd); ! 993: - if(outs != NULL) ! 994: - fclose(outs); ! 995: - if(outl != NULL) ! 996: - fclose(outl); ! 997: - sprintf(outnams, "X%s", s); ! 998: - sprintf(outnaml, "%sL", s); ! 999: - lastline = lineno = 0; ! 1000: - fd = fopen(s, "r"); ! 1001: - if(fd == NULL) { ! 1002: - perror(s); ! 1003: - return(0); ! 1004: - } ! 1005: - outs = fopen(outnams, "w"); ! 1006: - if(outs == NULL) { ! 1007: - perror(outnams); ! 1008: - return(0); ! 1009: - } ! 1010: - outl = fopen(outnaml, "w"); ! 1011: - if(outl == NULL) { ! 1012: - perror(outnaml); ! 1013: - return(0); ! 1014: - } ! 1015: - curarg = s; ! 1016: - return(1); ! 1017: -} ! 1018: - ! 1019: -doarg() ! 1020: -{ struct inst *x, *firstword(); ! 1021: - state = SBBLK; ! 1022: - for(;;) { ! 1023: - (void) fgets(line, sizeof(line), fd); ! 1024: - if(feof(fd)) ! 1025: - break; ! 1026: - for(ptr = line; isspace(*ptr); *ptr++) ! 1027: - ; ! 1028: - if(*ptr == 0 || *ptr == '#') ! 1029: - continue; ! 1030: - testlabel(); ! 1031: - /* deal with symbol table info */ ! 1032: - if(*ptr == '.') { ! 1033: - stab(); ! 1034: - fprintf(outs, "%s", ptr); ! 1035: - continue; ! 1036: - } ! 1037: - if(*ptr == 0 || *ptr == '\n') ! 1038: - continue; ! 1039: - x = firstword(); ! 1040: - if(x == 0) ! 1041: - continue; ! 1042: - if(state == SPRO) ! 1043: - prolog(x); ! 1044: - if(state == SINST) ! 1045: - tally(x); ! 1046: - if(state == SBBLK && (x->type & JUMP)) ! 1047: - state = SINST; ! 1048: - outinstr(); ! 1049: - if(x->type & BYTE) ! 1050: - fixinstr(x); ! 1051: - fprintf(outs, "%s", ptr); ! 1052: - } ! 1053: - finish(); ! 1054: -} ! 1055: -/* unbelievable variability in sdb info */ ! 1056: -stab() ! 1057: -{ char buf[128]; ! 1058: - int i, j, k; ! 1059: - if(state == SMAYBE && strncmp(ptr, ".word", 5) == 0) { ! 1060: - state = SPRO; ! 1061: - return; ! 1062: - } ! 1063: - if((i = *(ptr + 1)) != 's' && i != 'f' && i != 'l') ! 1064: - return; ! 1065: - /* real compiler output */ ! 1066: - if(sscanf(ptr, ".stabs \"%[^\"]\", %o", buf, &i) == 2 && i == 0144) ! 1067: - strcat(fname, buf); ! 1068: - else if(sscanf(ptr, ".stabs \"%[^\"]\", 0x%x", buf, &i) == 2 && i == 0x64) ! 1069: - strcat(fname, buf); ! 1070: - else if(sscanf(ptr, ".stabd %o,%o,%o", &i, &j, &k) == 3 && i == 0104) ! 1071: - lineno = k; ! 1072: - else if(sscanf(ptr, ".stabd 0x%x,0,%d", &i, &k) == 2 && i == 0x44) ! 1073: - lineno = k; ! 1074: - /* pwb 3.0 */ ! 1075: - else if(sscanf(ptr, ".stab %[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%d", ! 1076: - buf, buf+2, buf+4, buf+6, buf+8, buf+10, buf+12, buf+14, &i) ! 1077: - == 9 && i == 144) { ! 1078: - for(i = k = 0; buf[i] ; i++) ! 1079: - if(buf[i] == '\'') ! 1080: - buf[k++] = buf[++i]; ! 1081: - buf[k] = 0; ! 1082: - strcat(fname, buf); ! 1083: - } ! 1084: - else if(sscanf(ptr, ".stab %[0,]%d,%d,%d", buf,&i, &j, &k) == 4 ! 1085: - && i == 104) ! 1086: - lineno = k; ! 1087: - /* pwb 5.0 */ ! 1088: - else if(sscanf(ptr," .file \"%[^\"]\"", buf) == 1) ! 1089: - strcat(fname, buf); ! 1090: - else if(sscanf(ptr, " .ln %d",&k) == 1) ! 1091: - lineno = k; ! 1092: -} ! 1093: - ! 1094: -testlabel() ! 1095: -{ char *p; ! 1096: -again: ! 1097: - for(p = ptr; *p; p++) { ! 1098: - if(*p == ':') ! 1099: - break; ! 1100: - if(isalnum(*p) || *p == '_') ! 1101: - continue; ! 1102: - if(p > ptr && *p == '.') /* f77 */ ! 1103: - continue; ! 1104: - return; ! 1105: - } ! 1106: - if(*p == 0) ! 1107: - return; ! 1108: - *p++ = 0; /* that is overwriting the : */ ! 1109: - fprintf(outs, "%s:\n", ptr); ! 1110: - if(*ptr == '_') { ! 1111: - state = SMAYBE; ! 1112: - strcpy(curfunc, ptr); ! 1113: - } ! 1114: - else ! 1115: - if(state != SPRO) ! 1116: - state = SINST; ! 1117: - for(ptr = p; isspace(*ptr); ptr++) ! 1118: - ; ! 1119: - goto again; /* L68:L70: ... */ ! 1120: -} ! 1121: - ! 1122: -struct inst * ! 1123: -firstword() ! 1124: -{ char buf[sizeof(line)], *p, *q; ! 1125: - struct inst *x; ! 1126: - for(p = buf, q = ptr; isalnum(*q); ) ! 1127: - *p++ = *q++; ! 1128: - if(p == buf) ! 1129: - return((struct inst *)0); ! 1130: - *p = 0; ! 1131: - for(x = index[buf[0]]; x && x->iname[0] == buf[0]; x++) ! 1132: - if(strcmp(buf, x->iname) == 0) ! 1133: - return(x); ! 1134: - return(0); ! 1135: -} ! 1136: - ! 1137: -tally(x) ! 1138: -struct inst *x; ! 1139: -{ ! 1140: - if(x->type & E) ! 1141: - fprintf(outs, "incl locprof+%d\n", 4*cnt++); ! 1142: - else { ! 1143: - fprintf(outs, "movpsl -(sp)\n"); ! 1144: - fprintf(outs, "incl locprof+%d\n", 4*cnt++); ! 1145: - fprintf(outs, "movw (sp)+,(sp)\n"); ! 1146: - fprintf(outs, "bicpsw $0xff\n"); ! 1147: - fprintf(outs, "bispsw (sp)+\n"); ! 1148: - /* thanks to kirk mckusick */ ! 1149: - } ! 1150: - state = SBBLK; ! 1151: -} ! 1152: - ! 1153: -outinstr() ! 1154: -{ int i; ! 1155: - for(i = lastline + 1; i <= lineno; i++) ! 1156: - fprintf(outl, "%d %s: %d\n", 4*(cnt - 1), fname, i); ! 1157: - lastline = lineno; ! 1158: - fprintf(outl, "%d %s", 4*(cnt - 1), ptr); ! 1159: -} ! 1160: - ! 1161: -prolog(x) /* no liveness test, presumes can't get here by jump */ ! 1162: -struct inst *x; ! 1163: -{ int i; ! 1164: - fprintf(outs, ".data\n"); ! 1165: - fprintf(outs, ".comm _proFptr,4\n"); /* the global chain */ ! 1166: - fprintf(outs, ".text\n"); ! 1167: - fprintf(outs, "tstl locprof+4\n"); ! 1168: - fprintf(outs, "bneq L%da\n", i = cnt); ! 1169: - fprintf(outs, "movl _proFptr,locprof+4\n"); ! 1170: - fprintf(outs, "moval locprof,_proFptr\n"); ! 1171: - fprintf(outs, "L%da: incl locprof+%d\n", i, 4*cnt++); ! 1172: - state = SBBLK; ! 1173: - fprintf(outl, "%d %s: %s\n", 4*(cnt-1), fname, curfunc); ! 1174: -} ! 1175: - ! 1176: -finish() ! 1177: -{ int i; ! 1178: - fprintf(outs, ".data\n"); ! 1179: - fprintf(outs, "locprof: .long %d\n", cnt); ! 1180: - fprintf(outs, ".long 0\n"); ! 1181: - fprintf(outs, ".long L%db\n", cnt); ! 1182: - fprintf(outs, ".space %d\n", 4 * cnt); ! 1183: - fprintf(outs, "L%db: .byte ", cnt); ! 1184: - for(i = 0; curdir[i]; i++) ! 1185: - fprintf(outs, "0x%x,", curdir[i]); ! 1186: - fprintf(outs, "0x%x\n", '/'); ! 1187: - fprintf(outs, ".byte "); ! 1188: - if(fname[0]) ! 1189: - for(i = 0; fname[i]; i++) ! 1190: - fprintf(outs, "0x%x,", fname[i]); ! 1191: - else ! 1192: - for(i = 0; curarg[i]; i++) ! 1193: - fprintf(outs, "0x%x,", curarg[i]); ! 1194: - fprintf(outs, "0\n"); ! 1195: -} ! 1196: - ! 1197: -fixinstr(x) ! 1198: -struct inst *x; ! 1199: -{ ! 1200: - if(x->iname[0] == 'b') ! 1201: - *ptr = 'j'; /* let assembler worry about branches */ ! 1202: - /* this is where the code for aob and sob goes */ ! 1203: -} ! 1204: //GO.SYSIN DD bb.c ! 1205: echo instr.c 1>&2 ! 1206: sed 's/.//' >instr.c <<'//GO.SYSIN DD instr.c' ! 1207: -#define K 1 /* kills all condition codes */ ! 1208: -#define JUMP 2 /* ends a basic block */ ! 1209: -#define BYTE 4 /* target is byte offset */ ! 1210: -#define C 8 /* kills all condition codes but for C bit*/ ! 1211: -/* if((p->type & EXPAND) && p->iname[0] == 'b') replace first char with j */ ! 1212: -/* aob and sob get replaced by two instructions */ ! 1213: - ! 1214: -struct inst { ! 1215: - char *iname; ! 1216: - short type; ! 1217: -} insts[] = { ! 1218: -"acbb", C | JUMP, ! 1219: -"acbd", C | JUMP, ! 1220: -"acbf", C | JUMP, ! 1221: -"acbg", C | JUMP, ! 1222: -"acbh", C | JUMP, ! 1223: -"acbl", C | JUMP, ! 1224: -"acbw", C | JUMP, ! 1225: -"adawi", K, ! 1226: -"addb2", K, ! 1227: -"addb3", K, ! 1228: -"addd2", K, ! 1229: -"addd3", K, ! 1230: -"addf2", K, ! 1231: -"addf3", K, ! 1232: -"addg2", K, ! 1233: -"addg3", K, ! 1234: -"addh2", K, ! 1235: -"addh3", K, ! 1236: -"addl2", K, ! 1237: -"addl3", K, ! 1238: -"addp4", K, ! 1239: -"addp6", K, ! 1240: -"addw2", K, ! 1241: -"addw3", K, ! 1242: -"adwc", K, ! 1243: -"aobleq", C | JUMP | BYTE, ! 1244: -"aoblss", C | JUMP | BYTE, ! 1245: -"ashl", C, ! 1246: -"ashp", K, ! 1247: -"ashq", C, ! 1248: -"bbc", JUMP | BYTE, ! 1249: -"bbcc", JUMP | BYTE, ! 1250: -"bbcci", JUMP | BYTE, ! 1251: -"bbcs", JUMP | BYTE, ! 1252: -"bbs", JUMP | BYTE, ! 1253: -"bbsc", JUMP | BYTE, ! 1254: -"bbss", JUMP | BYTE, ! 1255: -"bbssi", JUMP | BYTE, ! 1256: -"bcc", JUMP | BYTE, ! 1257: -"bcs", JUMP | BYTE, ! 1258: -"beql", JUMP | BYTE, ! 1259: -"beqlu", JUMP | BYTE, ! 1260: -"bgeq", JUMP | BYTE, ! 1261: -"bgequ", JUMP | BYTE, ! 1262: -"bgtr", JUMP | BYTE, ! 1263: -"bgtru", JUMP | BYTE, ! 1264: -"bicb2", C, ! 1265: -"bicb3", C, ! 1266: -"bicl2", C, ! 1267: -"bicl3", C, ! 1268: -"bicpsw", K, ! 1269: -"bicw2", C, ! 1270: -"bicw3", C, ! 1271: -"bisb2", C, ! 1272: -"bisb3", C, ! 1273: -"bisl2", C, ! 1274: -"bisl3", C, ! 1275: -"bispsw", K, ! 1276: -"bisw2", C, ! 1277: -"bisw3", C, ! 1278: -"bitb", C, ! 1279: -"bitl", C, ! 1280: -"bitw", C, ! 1281: -"blbc", JUMP | BYTE, ! 1282: -"blbs", JUMP | BYTE, ! 1283: -"bleq", JUMP | BYTE, ! 1284: -"blequ", JUMP | BYTE, ! 1285: -"blss", JUMP | BYTE, ! 1286: -"blssu", JUMP | BYTE, ! 1287: -"bneq", JUMP | BYTE, ! 1288: -"bnequ", JUMP | BYTE, ! 1289: -"bpt", K, ! 1290: -"brb", JUMP | BYTE, ! 1291: -"brw", JUMP, ! 1292: -"bsbb", JUMP | BYTE, ! 1293: -"bsbw", JUMP, ! 1294: -"bugl", 0, ! 1295: -"bugw", 0, ! 1296: -"bvc", JUMP | BYTE, ! 1297: -"bvs", JUMP | BYTE, ! 1298: -"callg", K, ! 1299: -"calls", K, ! 1300: -"caseb", K | JUMP, ! 1301: -"casel", K | JUMP, ! 1302: -"casew", K | JUMP, ! 1303: -"chme", K, ! 1304: -"chmk", K, ! 1305: -"chms", K, ! 1306: -"chmu", K, ! 1307: -"clrb", C, ! 1308: -"clrd", C, ! 1309: -"clrf", C, ! 1310: -"clrg", C, ! 1311: -"clrh", C, ! 1312: -"clrl", C, ! 1313: -"clro", C, ! 1314: -"clrq", C, ! 1315: -"clrw", C, ! 1316: -"cmpb", K, ! 1317: -"cmpc3", K, ! 1318: -"cmpc5", K, ! 1319: -"cmpd", K, ! 1320: -"cmpf", K, ! 1321: -"cmpg", K, ! 1322: -"cmph", K, ! 1323: -"cmpl", K, ! 1324: -"cmpp3", C, ! 1325: -"cmpp4", C, ! 1326: -"cmpv", K, ! 1327: -"cmpw", K, ! 1328: -"cmpzv", K, ! 1329: -"crc", C, ! 1330: -"cvtbd", K, ! 1331: -"cvtbf", K, ! 1332: -"cvtbg", K, ! 1333: -"cvtbh", K, ! 1334: -"cvtbl", K, ! 1335: -"cvtbw", K, ! 1336: -"cvtdb", K, ! 1337: -"cvtdf", K, ! 1338: -"cvtdh", K, ! 1339: -"cvtdl", K, ! 1340: -"cvtdw", K, ! 1341: -"cvtfb", K, ! 1342: -"cvtfd", K, ! 1343: -"cvtfg", K, ! 1344: -"cvtfh", K, ! 1345: -"cvtfl", K, ! 1346: -"cvtfw", K, ! 1347: -"cvtgb", K, ! 1348: -"cvtgf", K, ! 1349: -"cvtgh", K, ! 1350: -"cvtgl", K, ! 1351: -"cvtgw", K, ! 1352: -"cvthb", K, ! 1353: -"cvthd", K, ! 1354: -"cvthf", K, ! 1355: -"cvthg", K, ! 1356: -"cvthl", K, ! 1357: -"cvthw", K, ! 1358: -"cvtlb", K, ! 1359: -"cvtld", K, ! 1360: -"cvtlf", K, ! 1361: -"cvtlg", K, ! 1362: -"cvtlh", K, ! 1363: -"cvtlp", K, ! 1364: -"cvtlw", K, ! 1365: -"cvtpl", K, ! 1366: -"cvtps", K, ! 1367: -"cvtpt", K, ! 1368: -"cvtrdl", K, ! 1369: -"cvtrfl", K, ! 1370: -"cvtrgl", K, ! 1371: -"cvtrhl", K, ! 1372: -"cvtsp", K, ! 1373: -"cvttp", K, ! 1374: -"cvtwb", K, ! 1375: -"cvtwd", K, ! 1376: -"cvtwf", K, ! 1377: -"cvtwg", K, ! 1378: -"cvtwh", K, ! 1379: -"cvtwl", K, ! 1380: -"decb", K, ! 1381: -"decl", K, ! 1382: -"decw", K, ! 1383: -"divb2", K, ! 1384: -"divb3", K, ! 1385: -"divd2", K, ! 1386: -"divd3", K, ! 1387: -"divf2", K, ! 1388: -"divf3", K, ! 1389: -"divg2", K, ! 1390: -"divg3", K, ! 1391: -"divh2", K, ! 1392: -"divh3", K, ! 1393: -"divl2", K, ! 1394: -"divl3", K, ! 1395: -"divp", K, ! 1396: -"divw2", K, ! 1397: -"divw3", K, ! 1398: -"editpc", K, ! 1399: -"ediv", K, ! 1400: -"emodd", K, ! 1401: -"emodf", K, ! 1402: -"emodg", K, ! 1403: -"emodh", K, ! 1404: -"emul", K, ! 1405: -"escd", 0, ! 1406: -"esce", 0, ! 1407: -"escf", 0, ! 1408: -"extv", K, ! 1409: -"extzv", K, ! 1410: -"ffc", K, ! 1411: -"ffs", K, ! 1412: -"halt", JUMP, ! 1413: -"incb", K, ! 1414: -"incl", K, ! 1415: -"incw", K, ! 1416: -"index", K, ! 1417: -"insqhi", K, ! 1418: -"insqti", K, ! 1419: -"insque", K, ! 1420: -"insv", 0, ! 1421: -"jbc", JUMP, ! 1422: -"jbcc", JUMP, ! 1423: -"jbcs", JUMP, ! 1424: -"jbr", JUMP, ! 1425: -"jbs", JUMP, ! 1426: -"jbsc", JUMP, ! 1427: -"jbss", JUMP, ! 1428: -"jcc", JUMP, ! 1429: -"jcs", JUMP, ! 1430: -"jeql", JUMP, ! 1431: -"jeqlu", JUMP, ! 1432: -"jgeq", JUMP, ! 1433: -"jgequ", JUMP, ! 1434: -"jgtr", JUMP, ! 1435: -"jgtru", JUMP, ! 1436: -"jlbc", JUMP, ! 1437: -"jlbs", JUMP, ! 1438: -"jleq", JUMP, ! 1439: -"jlequ", JUMP, ! 1440: -"jlss", JUMP, ! 1441: -"jlssu", JUMP, ! 1442: -"jmp", JUMP, ! 1443: -"jneq", JUMP, ! 1444: -"jnequ", JUMP, ! 1445: -"jsb", JUMP, ! 1446: -"jvc", JUMP, ! 1447: -"jvs", JUMP, ! 1448: -"ldpctx", 0, ! 1449: -"locc", K, ! 1450: -"matchc", K, ! 1451: -"mcomb", C, ! 1452: -"mcoml", C, ! 1453: -"mcomw", C, ! 1454: -"mfpr", C, ! 1455: -"mnegb", K, ! 1456: -"mnegd", K, ! 1457: -"mnegf", K, ! 1458: -"mnegg", K, ! 1459: -"mnegh", K, ! 1460: -"mnegl", K, ! 1461: -"mnegw", K, ! 1462: -"movab", C, ! 1463: -"movad", C, ! 1464: -"movaf", C, ! 1465: -"movag", C, ! 1466: -"movah", C, ! 1467: -"moval", C, ! 1468: -"movao", C, ! 1469: -"movaq", C, ! 1470: -"movaw", C, ! 1471: -"movb", C, ! 1472: -"movc3", K, ! 1473: -"movc5", K, ! 1474: -"movd", C, ! 1475: -"movf", C, ! 1476: -"movg", C, ! 1477: -"movh", C, ! 1478: -"movl", C, ! 1479: -"movo", C, ! 1480: -"movp", C, ! 1481: -"movpsl", 0, ! 1482: -"movq", C, ! 1483: -"movtc", K, ! 1484: -"movtuc", K, ! 1485: -"movw", C, ! 1486: -"movzbl", C, ! 1487: -"movzbw", C, ! 1488: -"movzwl", C, ! 1489: -"mtpr", C, ! 1490: -"mulb2", K, ! 1491: -"mulb3", K, ! 1492: -"muld2", K, ! 1493: -"muld3", K, ! 1494: -"mulf2", K, ! 1495: -"mulf3", K, ! 1496: -"mulg2", K, ! 1497: -"mulg3", K, ! 1498: -"mulh2", K, ! 1499: -"mulh3", K, ! 1500: -"mull2", K, ! 1501: -"mull3", K, ! 1502: -"mulp", K, ! 1503: -"mulw2", K, ! 1504: -"mulw3", K, ! 1505: -"nop", 0, ! 1506: -"polyd", K, ! 1507: -"polyf", K, ! 1508: -"polyg", K, ! 1509: -"polyh", K, ! 1510: -"popr", 0, ! 1511: -"prober", K, ! 1512: -"probew", K, ! 1513: -"pushab", C, ! 1514: -"pushad", C, ! 1515: -"pushaf", C, ! 1516: -"pushag", C, ! 1517: -"pushah", C, ! 1518: -"pushal", C, ! 1519: -"pushao", C, ! 1520: -"pushaq", C, ! 1521: -"pushaw", C, ! 1522: -"pushl", C, ! 1523: -"pushr", 0, ! 1524: -"rei", K, ! 1525: -"remqhi", K, ! 1526: -"remqti", K, ! 1527: -"remque", K, ! 1528: -"ret", K | JUMP, ! 1529: -"rotl", C, ! 1530: -"rsb", 0, ! 1531: -"sbwc", K, ! 1532: -"scanc", K, ! 1533: -"skpc", K, ! 1534: -"sobgeq", C | JUMP | BYTE, ! 1535: -"sobgtr", C | JUMP | BYTE, ! 1536: -"spanc", K, ! 1537: -"subb2", K, ! 1538: -"subb3", K, ! 1539: -"subd2", K, ! 1540: -"subd3", K, ! 1541: -"subf2", K, ! 1542: -"subf3", K, ! 1543: -"subg2", K, ! 1544: -"subg3", K, ! 1545: -"subh2", K, ! 1546: -"subh3", K, ! 1547: -"subl2", K, ! 1548: -"subl3", K, ! 1549: -"subp4", K, ! 1550: -"subp6", K, ! 1551: -"subw2", K, ! 1552: -"subw3", K, ! 1553: -"svpctx", 0, ! 1554: -"tstb", K, ! 1555: -"tstd", K, ! 1556: -"tstf", K, ! 1557: -"tstg", K, ! 1558: -"tstl", K, ! 1559: -"tstw", K, ! 1560: -"tstw", K, ! 1561: -"xfc", K | JUMP, ! 1562: -"xorb2", C, ! 1563: -"xorb3", C, ! 1564: -"xorl2", C, ! 1565: -"xorl3", C, ! 1566: -"xorw2", C, ! 1567: -"xorw3", C, ! 1568: -0, 0 ! 1569: -}; ! 1570: //GO.SYSIN DD instr.c ! 1571: echo lcomp.1 1>&2 ! 1572: sed 's/.//' >lcomp.1 <<'//GO.SYSIN DD lcomp.1' ! 1573: -.TH LCOMP 1 ! 1574: -.SH NAME ! 1575: -lcomp, lprint \(mi line-by-line profiler ! 1576: -.SH SYNOPSIS ! 1577: -.B lcomp ! 1578: -[ option ... ] file ... ! 1579: -.PP ! 1580: -.B lprint ! 1581: -[ option ] [ file ... ] ! 1582: -.SH DESCRIPTION ! 1583: -.I Lcomp ! 1584: -is used in place of ! 1585: -.I cc (1) ! 1586: -or ! 1587: -.I f77 (1) ! 1588: -to insert instruction-counting code into programs. ! 1589: -It recognizes options whose initial letters are taken from the string ! 1590: -.LR CwpDUIRdlNnz , ! 1591: -and accepts files whose names end in ! 1592: -.LR .c , ! 1593: -.LR .f , ! 1594: -.LR .s , ! 1595: -or ! 1596: -.LR .o . ! 1597: -From each source file it derives a ! 1598: -.L .o ! 1599: -file and a ! 1600: -.L .sL ! 1601: -file which ! 1602: -.I lprint ! 1603: -uses to correlate source lines with basic blocks. ! 1604: -.PP ! 1605: -Option ! 1606: -.B -C ! 1607: -declares that ! 1608: -.L .c ! 1609: -files (and ! 1610: -.L .o ! 1611: -files, if no source files are named) ! 1612: -are C++ files. ! 1613: -If the ! 1614: -.B -c ! 1615: -option is not present ! 1616: -.I lcomp ! 1617: -creates ! 1618: -.FR a.out . ! 1619: -Each time ! 1620: -.F a.out ! 1621: -is run statistics are added ! 1622: -to a profiling file ! 1623: -.FR prof.out . ! 1624: -.PP ! 1625: -.I Lprint ! 1626: -produces on the standard output a listing (in the style of ! 1627: -.IR pr (1)) ! 1628: -of the programs compiled by ! 1629: -.I lcomp. ! 1630: -Without arguments or files, ! 1631: -each line of the listing is preceded by the number of times it was executed, ! 1632: -as determined from the data in ! 1633: -.FR prof.out . ! 1634: -.I Lprint ! 1635: -interprets the following options. ! 1636: -.TP ! 1637: -.B -a ! 1638: -Detailed listing of every machine instruction and how often it was executed. ! 1639: -.TP ! 1640: -.B -b ! 1641: -How often each basic block was executed. ! 1642: -.TP ! 1643: -.B -c ! 1644: -Compress the ! 1645: -.F prof.out ! 1646: -file, which otherwise grows with every execution of ! 1647: -.LR a.out . ! 1648: -.TP ! 1649: -.B -f ! 1650: -Print summary information by function: instruction executions, number of ! 1651: -invocations, source instructions, and number of instructions never executed. ! 1652: -.TP ! 1653: -.B -i ! 1654: -Before each line of source print the number of machine instructions executed. ! 1655: -.TP ! 1656: -.B -p ! 1657: -Before each line of source print the number of times the first basic block ! 1658: -in that line was executed. ! 1659: -.TP ! 1660: -.B -s ! 1661: -Summarize the counts by source file: instruction exectuions, source ! 1662: -instructions, instructions never executed, basic block executions, total ! 1663: -number of source basic blocks, and how many were never executed. ! 1664: -.PP ! 1665: -If any file names are given, the arguments ! 1666: -.L abip ! 1667: -apply only to them. ! 1668: -If no options are given, ! 1669: -.L -p ! 1670: -is assumed. ! 1671: -Any combination of options is allowed. ! 1672: -.SH FILES ! 1673: -.TF /usr/lib/nexit.o ! 1674: -.TP ! 1675: -.F prof.out ! 1676: -counts ! 1677: -.TP ! 1678: -.F *.sL ! 1679: -for correlating with source ! 1680: -.TP ! 1681: -.F /usr/lib/bb ! 1682: -for finding basic blocks and inserting counting code ! 1683: -.TP ! 1684: -.F /usr/lib/nexit.o ! 1685: -for printing counts when ! 1686: -.L a.out ! 1687: -exits ! 1688: -.SH "SEE ALSO" ! 1689: -cc(1), f77(1) ! 1690: -.SH BUGS ! 1691: -A line in the source file may be in zero, one, or more basic ! 1692: -blocks; ! 1693: -the count given in the listing corresponds to some particular ! 1694: -choice of the basic block to associate with the line. ! 1695: -.br ! 1696: -Processing the output of ! 1697: -.IR yacc (1) ! 1698: -without removing ! 1699: -.L #line ! 1700: -directives will produce unsatisfactory results. ! 1701: -.br ! 1702: -Option ! 1703: -.B -C ! 1704: -masks an option of ! 1705: -.IR cc (1). ! 1706: //GO.SYSIN DD lcomp.1 ! 1707: echo lprint.c 1>&2 ! 1708: sed 's/.//' >lprint.c <<'//GO.SYSIN DD lprint.c' ! 1709: -#include "stdio.h" ! 1710: -#include "ctype.h" ! 1711: -typedef unsigned long ul; ! 1712: -typedef struct { ! 1713: - char *fname; ! 1714: - int len; /* how many counts have been seen */ ! 1715: - int quot; /* how much has been allocated for cnt */ ! 1716: - int flag; ! 1717: - unsigned long *cnt; /* the basic block counts */ ! 1718: - int *instrcnt; /* instrs per basic block, from .sL */ ! 1719: - int *lastline; /* last source line containing instr from bb */ ! 1720: -} stab; ! 1721: -stab *tab; ! 1722: -int ntab, ltab; ! 1723: -unsigned long N, B, L, V; /* for summary */ ! 1724: -double A, U; ! 1725: -FILE *fd, *sfd, *cfd; ! 1726: -extern FILE *popen(); ! 1727: -char fname[512] = "/"; /* not checked for overflow */ ! 1728: -char buf[256]; ! 1729: -char curfunc[256]; ! 1730: -extern char *malloc(); ! 1731: -char flg[128]; ! 1732: -unsigned long val; ! 1733: -char prcmd[128] = "pr -h %s "; /* space for extra args */ ! 1734: - ! 1735: -main(argc, argv) ! 1736: -char **argv; ! 1737: -{ int i, j, seenpart = 0; ! 1738: - if((fd = fopen("prof.out", "r")) == 0) { ! 1739: - perror("prof.out"); ! 1740: - exit(1); ! 1741: - } ! 1742: - readall(); ! 1743: - fclose(fd); ! 1744: - for(i = 1; i < argc; i++) ! 1745: - if(argv[i][0] != '-') { ! 1746: - seenpart++; ! 1747: - okfile(argv[i]); ! 1748: - } ! 1749: - else for(j = 1; argv[i][j]; j++) ! 1750: - switch(argv[i][j]) { ! 1751: - default: /* assume whole thing is for pr */ ! 1752: - strcat(prcmd, argv[i]); ! 1753: - strcat(prcmd, " "); ! 1754: - break; ! 1755: - case 'b': /* each bb */ ! 1756: - flg['b']++; ! 1757: - break; ! 1758: - case 'a': /* intermediate everything */ ! 1759: - flg['a']++; ! 1760: - break; ! 1761: - case 'i': /* count machine instrs */ ! 1762: - flg['i']++; ! 1763: - break; ! 1764: - case 'f': /* counts by function */ ! 1765: - flg['f']++; ! 1766: - flg['s']++; ! 1767: - break; ! 1768: - case 'p': /* print, in addition */ ! 1769: - flg['p']++; ! 1770: - break; ! 1771: - case 's': /* bb summary */ ! 1772: - flg['s']++; ! 1773: - break; ! 1774: - case 'c': /* compress prof.out */ ! 1775: - flg['c']++; ! 1776: - break; ! 1777: - } ! 1778: - if(argc <= seenpart + 1) ! 1779: - flg['p']++; ! 1780: - if(!seenpart) ! 1781: - for(i = 0; i < ntab; i++) ! 1782: - tab[i].flag = 1; ! 1783: - if(flg['f']) { ! 1784: - for(i = 0; i < ntab; i++) ! 1785: - fsum(tab + i); ! 1786: - } ! 1787: - if(flg['s']) { ! 1788: - for(i = 0; i < ntab; i++) ! 1789: - summary(tab + i); ! 1790: - if(ntab > 1) ! 1791: - printf("%.0fie %ui %uin %.0fbbe %ubb %ubbne total\n", ! 1792: - A, N, B, U, L, V); ! 1793: - } ! 1794: - if(flg['c']) { ! 1795: - fd = fopen("prof.out", "w"); ! 1796: - if(fd == 0) { ! 1797: - perror("rewriting prof.out"); ! 1798: - exit(1); ! 1799: - } ! 1800: - for(i = 0; i < ntab; i++) { ! 1801: - fprintf(fd, "%s\n", tab[i].fname); ! 1802: - for(j = 0; j < tab[i].len; j++) ! 1803: - fprintf(fd, "%u\n", tab[i].cnt[j]); ! 1804: - } ! 1805: - fclose(fd); ! 1806: - } ! 1807: - if(flg['p'] || flg['i'] || flg['a'] || flg['b']) ! 1808: - giantprint(); ! 1809: - exit(0); ! 1810: -} ! 1811: - ! 1812: -okfile(s) ! 1813: -char *s; ! 1814: -{ int i, j, k; ! 1815: - j = strlen(s); ! 1816: - for(i = 0; i < ntab; i++) { ! 1817: - k = strlen(tab[i].fname); ! 1818: - if(strcmp(s, tab[i].fname + k - j) == 0) { ! 1819: - tab[i].flag = 1; ! 1820: - return; ! 1821: - } ! 1822: - } ! 1823: - fprintf(stderr, "argument %s not a source file\n", s); ! 1824: - exit(1); ! 1825: -} ! 1826: - ! 1827: -readall() ! 1828: -{ int c, i, index; ! 1829: - stab *curtab = 0; ! 1830: -sawnl: ! 1831: - if((c = getc(fd)) == EOF) ! 1832: - return; ! 1833: - if(c == '\n') ! 1834: - goto sawnl; ! 1835: - if(c == '/') { ! 1836: - fscanf(fd, "%s", fname+1); ! 1837: - for(i = 0; i < ntab; i++) ! 1838: - if(strcmp(fname, tab[i].fname) == 0) ! 1839: - break; ! 1840: - if(i >= ntab) { /* new file */ ! 1841: - if(ltab == 0) { ! 1842: - tab = (stab *)malloc(20 * sizeof(stab)); ! 1843: - ltab = 20; ! 1844: - } ! 1845: - else if(ntab >= ltab) ! 1846: - tab = (stab *)realloc((char *)tab, ! 1847: - (ltab += 20) * sizeof(stab)); ! 1848: - tab[ntab].fname = malloc(sizeof(fname) + 1); ! 1849: - strcpy(tab[ntab].fname, fname); ! 1850: - tab[ntab].flag = tab[ntab].len = tab[ntab].quot = 0; ! 1851: - ntab++; ! 1852: - } ! 1853: - curtab = tab + i; ! 1854: - index = 0; ! 1855: - } ! 1856: - else if(c < '0' || c > '9') { ! 1857: - fprintf(stderr, "prof.out has weird format\n"); ! 1858: - abort(); ! 1859: - } ! 1860: - else { ! 1861: - ungetc(c, fd); ! 1862: - fscanf(fd, "%d", &val); ! 1863: - if(curtab->len <= index) { ! 1864: - if(curtab->quot == 0) { ! 1865: - curtab->cnt = (ul *)malloc(100*sizeof(long)); ! 1866: - curtab->quot = 100; ! 1867: - for(i = 0; i < 100; i++) ! 1868: - curtab->cnt[i] = 0; ! 1869: - } ! 1870: - else if(curtab->len >= curtab->quot) { ! 1871: - curtab->cnt = (ul *)realloc((char *)curtab->cnt, ! 1872: - (curtab->quot += 200) * sizeof(long)); ! 1873: - for(i = curtab->quot-200; i < curtab->quot; i++) ! 1874: - curtab->cnt[i] = 0; ! 1875: - } ! 1876: - curtab->len++; ! 1877: - } ! 1878: - curtab->cnt[index++] += val; ! 1879: - } ! 1880: - goto sawnl; ! 1881: -} ! 1882: - ! 1883: -summary(x) ! 1884: -stab *x; ! 1885: -{ unsigned long i, v, n, b; ! 1886: - double a, u; ! 1887: - for(i = u = v = 0; i < x->len; i++) ! 1888: - if(x->cnt[i]) ! 1889: - u += x->cnt[i]; ! 1890: - else ! 1891: - v++; ! 1892: - n = strlen(x->fname); ! 1893: - strcpy(buf, x->fname); ! 1894: - strcpy(buf + n - 2, ".sL"); ! 1895: - if((fd = fopen(buf, "r")) == 0) { ! 1896: - perror(buf); ! 1897: - printf("%s %u bbs %.0f execs %u untouched\n", ! 1898: - x->fname, x->len, u, v); ! 1899: - return; ! 1900: - } ! 1901: - for(n = a = b = 0; ;) { ! 1902: - (void) fgets(buf, sizeof(buf), fd); ! 1903: - if(feof(fd)) ! 1904: - break; ! 1905: - if(hascolon(buf)) ! 1906: - continue; ! 1907: - n++; ! 1908: - i = atoi(buf)/4 - 3; ! 1909: - if(x->cnt[i]) ! 1910: - a += x->cnt[i]; ! 1911: - else ! 1912: - b++; ! 1913: - } ! 1914: - printf("%.0fie %ui %uine %.0fbbe %ubb %ubbne %s\n", a, n, b, u, x->len, ! 1915: - v, x->fname); ! 1916: - fclose(fd); ! 1917: - A += a; N += n; B += b; U += u; L += x->len; V += v; ! 1918: -} ! 1919: - ! 1920: -fsum(x) ! 1921: -stab *x; ! 1922: -{ unsigned i, v, n, b, cnt; ! 1923: - double a, u; ! 1924: - char *p; ! 1925: - strcpy(buf, x->fname); ! 1926: - n = strlen(x->fname); ! 1927: - strcpy(buf + n - 2, ".sL"); ! 1928: - if((fd = fopen(buf, "r")) == 0) { ! 1929: - perror(buf); ! 1930: - return; ! 1931: - } ! 1932: - curfunc[0] = 0; ! 1933: - for(cnt = v = n = b = a = u = 0;;) { ! 1934: - (void) fgets(buf, sizeof(buf), fd); ! 1935: - if(feof(fd)) ! 1936: - break; ! 1937: - if(hascolon(buf)) { ! 1938: - /* 24 foo.c: 456 or ! 1939: - * 24 foo.c: _funcjunk */ ! 1940: - for(p = buf; *p != ':'; p++) ! 1941: - ; ! 1942: - while(isspace(*++p)) ! 1943: - ; ! 1944: - if(isdigit(*p)) ! 1945: - continue; ! 1946: - if(curfunc[0] != 0) ! 1947: - printf("%.0fie %dcalls %ui %uine %s\n", ! 1948: - a, v, n, b, curfunc); ! 1949: - for(i = 0; *p && *p != '\n'; i++) ! 1950: - curfunc[i] = *p++; ! 1951: - curfunc[i] = 0; ! 1952: - a = n = b = 0; ! 1953: - i = atoi(buf)/4 - 3; ! 1954: - v = x->cnt[i]; ! 1955: - continue; ! 1956: - } ! 1957: - n++; ! 1958: - i = atoi(buf)/4 - 3; ! 1959: - if(x->cnt[i]) ! 1960: - a += x->cnt[i]; ! 1961: - else ! 1962: - b++; ! 1963: - } ! 1964: - if(n > 0) ! 1965: - printf("%.0fie %dcalls %ui %uine %s\n", a, v, n, b, curfunc); ! 1966: - fclose(fd); ! 1967: -} ! 1968: - ! 1969: -giantprint() ! 1970: -{ int i, n; ! 1971: - for(i = 0; i < ntab; i++) { ! 1972: - if(tab[i].flag == 0) ! 1973: - continue; ! 1974: - /* the fname file is the source, there should be a corresponding ! 1975: - * .sL file for correlation between basic blocks and source. ! 1976: - * If fname is a .s file, the .sL file is all there is */ ! 1977: - n = strlen(tab[i].fname); ! 1978: - if(strcmp(".s", tab[i].fname + n - 2) == 0) { ! 1979: - sfile(tab + i); ! 1980: - continue; ! 1981: - } ! 1982: - sfd = fopen(tab[i].fname, "r"); ! 1983: - if(sfd == 0 && !flg['a']) { ! 1984: - perror(tab[i].fname); ! 1985: - return; ! 1986: - } ! 1987: - strcpy(buf, tab[i].fname); ! 1988: - strcpy(buf + n - 1, "sL"); ! 1989: - if((cfd = fopen(buf, "r")) == 0) { ! 1990: - fprintf(stderr, "no intermediate listing file "); ! 1991: - perror(buf); ! 1992: - fclose(sfd); ! 1993: - return; ! 1994: - } ! 1995: - sprintf(buf, prcmd, tab[i].fname); ! 1996: - if(!flg['a']) ! 1997: - fd = popen(buf, "w"); ! 1998: - if(!flg['a']) ! 1999: - xlistit(tab + i); ! 2000: - else ! 2001: - listit(tab + i); ! 2002: - if(fd) ! 2003: - pclose(fd); ! 2004: - if(sfd) ! 2005: - fclose(sfd); ! 2006: - fclose(cfd); ! 2007: - } ! 2008: -} ! 2009: - ! 2010: -sfile(x) ! 2011: -stab *x; ! 2012: -{ int i; ! 2013: - char *p; ! 2014: - strcpy(buf, x->fname); ! 2015: - strcat(buf, "L"); ! 2016: - sfd = fopen(buf, "r"); ! 2017: - if(sfd == 0) { ! 2018: - perror(buf); ! 2019: - return; ! 2020: - } ! 2021: - sprintf(buf, "pr -h %s", x->fname); ! 2022: - fd = popen(buf, "w"); ! 2023: - if(fd == 0) { ! 2024: - perror(buf); ! 2025: - fclose(sfd); ! 2026: - return; ! 2027: - } ! 2028: - for(;;) { ! 2029: - (void) fgets(buf, sizeof(buf), sfd); ! 2030: - if(feof(sfd)) { ! 2031: - pclose(fd); ! 2032: - fclose(sfd); ! 2033: - return; ! 2034: - } ! 2035: - for(i = 0, p = buf; *p >= '0' && *p <= '9'; p++) ! 2036: - i = 10 * i + *p - '0'; ! 2037: - i = i/4 - 3; ! 2038: - fprintf(fd, "%u\t%s", x->cnt[i], p); ! 2039: - } ! 2040: -} ! 2041: - ! 2042: -/* function added, so name (stripnum) is now misleading */ ! 2043: -char * ! 2044: -stripnum(s) ! 2045: -char *s; ! 2046: -{ char *p; ! 2047: - while(*s && (isdigit(*s) || isspace(*s))) ! 2048: - s++; ! 2049: - for(p = s; *p && *p != '\n'; p++) ! 2050: - ; ! 2051: - if(*p == '\n') ! 2052: - *p = ' '; ! 2053: - return(s); ! 2054: -} ! 2055: - ! 2056: -listit(x) ! 2057: -stab *x; ! 2058: -{ int i; ! 2059: - char *p; ! 2060: - for(;;) { ! 2061: - (void) fgets(buf, sizeof(buf), cfd); ! 2062: - if(feof(cfd)) ! 2063: - break; ! 2064: - for(p = buf; *p && *p != ':' ; p++) ! 2065: - ; ! 2066: - if(*p++ != ':') { /* these are instructions */ ! 2067: - i = x->cnt[atoi(buf)/4 - 3]; ! 2068: - printf("%d\t%s\n", i, stripnum(buf)); ! 2069: - continue; ! 2070: - } ! 2071: - else { ! 2072: - printf("%s", stripnum(buf)); ! 2073: - if(atoi(p) == 0) { /* foo.c: _main */ ! 2074: - putchar('\n'); ! 2075: - continue; ! 2076: - } ! 2077: - (void) fgets(buf, sizeof(buf), sfd); ! 2078: - printf("%s", buf); ! 2079: - continue; ! 2080: - } ! 2081: - } ! 2082: -} ! 2083: - ! 2084: -xlistit(x) ! 2085: -stab *x; ! 2086: -{ int lnum, i, icnt, bcnt; ! 2087: - char *p; ! 2088: - x->instrcnt = (int *) malloc(x->len * sizeof(int)); ! 2089: - x->lastline = (int *) malloc(x->len * sizeof(int)); ! 2090: - if(!x->instrcnt || !x->lastline) { ! 2091: - fprintf(stderr, "out of memory\n"); ! 2092: - return; ! 2093: - } ! 2094: - for(i = 0; i < x->len; i++) ! 2095: - x->instrcnt[i] = x->lastline[i] = 0; ! 2096: - for(;;) { ! 2097: - (void) fgets(buf, sizeof(buf), cfd); ! 2098: - if(feof(cfd)) ! 2099: - break; ! 2100: - for(p = buf; *p && *p != ':'; p++) ! 2101: - ; ! 2102: - if(*p++ != ':') { /* instruction */ ! 2103: - x->instrcnt[atoi(buf)/4 - 3]++; ! 2104: - continue; ! 2105: - } ! 2106: - lnum = atoi(p); /* hmm (atoi (" x..") is zero?)*/ ! 2107: - if(lnum <= 0) ! 2108: - continue; ! 2109: - i = atoi(buf)/4 - 3; ! 2110: - x->lastline[i] = lnum; ! 2111: - } ! 2112: - /* now read all the source lines and print out appropriate stuff */ ! 2113: - for(lnum = 1, i = 0;; lnum++) { ! 2114: - (void) fgets(buf, sizeof(buf), sfd); ! 2115: - if(feof(sfd)) ! 2116: - return; ! 2117: - icnt = bcnt = 0; ! 2118: - for(; i < x->len && x->lastline[i] <= lnum; i++) { ! 2119: - if(flg['b'] && flg['i']) ! 2120: - fprintf(fd, "%u,%ui ", x->cnt[i], ! 2121: - x->cnt[i] * x->instrcnt[i]); ! 2122: - else if(flg['b']) ! 2123: - fprintf(fd, "%u ", x->cnt[i]); ! 2124: - else { ! 2125: - icnt += x->cnt[i] * x->instrcnt[i]; ! 2126: - bcnt += x->cnt[i]; ! 2127: - } ! 2128: - } ! 2129: - if(!flg['b'] && flg['p'] && bcnt) ! 2130: - fprintf(fd, "%u ", bcnt); ! 2131: - if(!flg['b'] && flg['i'] && icnt) ! 2132: - fprintf(fd, "%ui ", icnt); ! 2133: - fprintf(fd, "\t%s", buf); ! 2134: - } ! 2135: -} ! 2136: - ! 2137: -hascolon(s) ! 2138: -register char *s; ! 2139: -{ ! 2140: - for(; *s && *s != ':'; s++) ! 2141: - ; ! 2142: - if(*s == ':') ! 2143: - return(1); ! 2144: - else ! 2145: - return(0); ! 2146: -} ! 2147: //GO.SYSIN DD lprint.c ! 2148: echo lsub.c 1>&2 ! 2149: sed 's/.//' >lsub.c <<'//GO.SYSIN DD lsub.c' ! 2150: -#include "stdio.h" ! 2151: -typedef unsigned long ul; ! 2152: -typedef struct { ! 2153: - char *fname; ! 2154: - int len; /* how many counts have been seen */ ! 2155: - int quot; /* how much has been allocated for cnt */ ! 2156: - unsigned long *cnt; ! 2157: -} stab; ! 2158: -stab *tab; ! 2159: -int ntab, ltab; ! 2160: -FILE *fd, *sfd, *cfd; ! 2161: -char buf[256]; ! 2162: -char fname[512] = "/"; ! 2163: -extern char *malloc(); ! 2164: -char flg[128]; ! 2165: -unsigned long val; ! 2166: - ! 2167: -main(argc, argv) ! 2168: -char **argv; ! 2169: -{ int i, j; ! 2170: - if(argc <= 1) { ! 2171: - fprintf(stderr, "subtract from where?\n"); ! 2172: - exit(1); ! 2173: - } ! 2174: - if((fd = fopen("prof.out", "r")) == 0) { ! 2175: - perror("prof.out"); ! 2176: - exit(1); ! 2177: - } ! 2178: - readall(fd); ! 2179: - fclose(fd); ! 2180: - sfd = fopen(argv[1], "r"); ! 2181: - if(sfd == 0) { ! 2182: - perror(argv[1]); ! 2183: - exit(1); ! 2184: - } ! 2185: - suball(sfd); ! 2186: - fclose(sfd); ! 2187: - if((fd = fopen("prof.out", "w")) == 0) { ! 2188: - perror(argv[1]); ! 2189: - exit(1); ! 2190: - } ! 2191: - for(i = 0; i < ntab; i++) ! 2192: - rewrite(tab + i); ! 2193: - exit(0); ! 2194: -} ! 2195: - ! 2196: -readall(fd) ! 2197: -FILE *fd; ! 2198: -{ int c, i, index; ! 2199: - stab *curtab = 0; ! 2200: -sawnl: ! 2201: - if((c = getc(fd)) == EOF) ! 2202: - return; ! 2203: - if(c == '\n') ! 2204: - goto sawnl; ! 2205: - if(c == '/') { ! 2206: - fscanf(fd, "%s", fname+1); ! 2207: - for(i = 0; i < ntab; i++) ! 2208: - if(strcmp(fname, tab[i].fname) == 0) ! 2209: - break; ! 2210: - if(i >= ntab) { /* new file */ ! 2211: - if(ltab == 0) { ! 2212: - tab = (stab *)malloc(20 * sizeof(stab)); ! 2213: - ltab = 20; ! 2214: - } ! 2215: - else if(ntab >= ltab) ! 2216: - tab = (stab *)realloc((char *)tab, ! 2217: - (ltab += 20) * sizeof(stab)); ! 2218: - tab[ntab].fname = malloc(sizeof(fname) + 1); ! 2219: - strcpy(tab[ntab].fname, fname); ! 2220: - tab[ntab].len = tab[ntab].quot = 0; ! 2221: - ntab++; ! 2222: - } ! 2223: - curtab = tab + i; ! 2224: - index = 0; ! 2225: - } ! 2226: - else if(c < '0' || c > '9') { ! 2227: - fprintf(stderr, "prof.out has weird format\n"); ! 2228: - abort(); ! 2229: - } ! 2230: - else { ! 2231: - ungetc(c, fd); ! 2232: - fscanf(fd, "%d", &val); ! 2233: - if(curtab->len <= index) { ! 2234: - if(curtab->quot == 0) { ! 2235: - curtab->cnt = (ul *)malloc(100*sizeof(long)); ! 2236: - curtab->quot = 100; ! 2237: - for(i = 0; i < 100; i++) ! 2238: - curtab->cnt[i] = 0; ! 2239: - } ! 2240: - else if(curtab->len >= curtab->quot) { ! 2241: - curtab->cnt = (ul *)realloc(curtab->cnt, ! 2242: - (curtab->quot += 200) * sizeof(long)); ! 2243: - for(i = curtab->quot-200; i < curtab->quot; i++) ! 2244: - curtab->cnt[i] = 0; ! 2245: - } ! 2246: - curtab->len++; ! 2247: - } ! 2248: - curtab->cnt[index++] += val; ! 2249: - } ! 2250: - goto sawnl; ! 2251: -} ! 2252: - ! 2253: -rewrite(x) ! 2254: -stab *x; ! 2255: -{ int i; ! 2256: - for(i = 0; i < x->len; i++) ! 2257: - if(x->cnt[i]) ! 2258: - break; ! 2259: - if(i >= x->len) ! 2260: - return; ! 2261: - fprintf(fd, "%s\n", x->fname); ! 2262: - for(i = 0; i < x->len; i++) ! 2263: - fprintf(fd, "%u\n", x->cnt[i]); ! 2264: -} ! 2265: -suball(fd) ! 2266: -FILE *fd; ! 2267: -{ int c, i, index; ! 2268: - stab *curtab = 0; ! 2269: -sawnl: ! 2270: - if((c = getc(fd)) == EOF) ! 2271: - return; ! 2272: - if(c == '\n') ! 2273: - goto sawnl; ! 2274: - if(c == '/') { ! 2275: - fscanf(fd, "%s", fname+1); ! 2276: - for(i = 0; i < ntab; i++) ! 2277: - if(strcmp(fname, tab[i].fname) == 0) ! 2278: - break; ! 2279: - if(i >= ntab) { /* new file */ ! 2280: - fprintf(stderr, "new file %s ignored\n", fname); ! 2281: - goto sawnl; ! 2282: - } ! 2283: - curtab = tab + i; ! 2284: - index = 0; ! 2285: - } ! 2286: - else if(c < '0' || c > '9') { ! 2287: - fprintf(stderr, "prof.out has weird format\n"); ! 2288: - abort(); ! 2289: - } ! 2290: - else { ! 2291: - ungetc(c, fd); ! 2292: - fscanf(fd, "%d", &val); ! 2293: - curtab->cnt[index++] -= val; ! 2294: - } ! 2295: - goto sawnl; ! 2296: -} ! 2297: //GO.SYSIN DD lsub.c ! 2298: echo lcomp 1>&2 ! 2299: sed 's/.//' >lcomp <<'//GO.SYSIN DD lcomp' ! 2300: -# lcomp recognizes the following arguments to cc: c, w, p, D, U, I g. ! 2301: -# lcomp recognizes the following arguments to f77: c, w, p. ! 2302: -# it does not accept ratfor or efl ! 2303: -# lcomp recognizes the following argument to as: R ! 2304: -# lcomp recognizes the following arguments to ld: d, l, N, n, z ! 2305: -# the output from -c is .o plus .sL ! 2306: -DIR=/usr/lib ! 2307: -COMP=${COMP-cc} ! 2308: -PATH=/bin:/usr/bin ! 2309: -for i in $* ! 2310: -do ! 2311: - case $i in ! 2312: - -c) compflag=1 ! 2313: - ;; ! 2314: - *.c) clist="$clist $i" ! 2315: - u=`basename $i | sed 's/c$//'` ! 2316: - bblist="$bblist "$u"s" ! 2317: - rmlist="$rmlist "$u"s" ! 2318: - slist="$slist "X$u"s" ! 2319: - llist="$llist "$u"o" ! 2320: - ;; ! 2321: - -D*|-I*|-U*) ! 2322: - clist="$clist $i" ! 2323: - ;; ! 2324: - *.f) flist="$flist "$i ! 2325: - u=`basename $i | sed 's/f$//'` ! 2326: - bblist="$bblist "$u"s" ! 2327: - rmlist="$rmlist "$u"s" ! 2328: - slist="$slist "X$u"s" ! 2329: - llist="$llist "$u"o" ! 2330: - ;; ! 2331: - *.s) bblist="$bblist "$i ! 2332: - u=`basename $i | sed 's/s$//'` ! 2333: - slist="$slist "X$u"s" ! 2334: - llist="$llist "$u"o" ! 2335: - ;; ! 2336: - -w|-p|-R|-d|-l*|-N|-n|-t|-z|*.o|*.a) ! 2337: - llist="$llist "$i ! 2338: - ;; ! 2339: - *) echo incomprehensible argument $i ignored ! 2340: - ;; ! 2341: - -g) ! 2342: - ;; ! 2343: - esac ! 2344: -done ! 2345: -# get .s files ! 2346: -if test "$flist" ! 2347: -then ! 2348: - f77 -g -S $flist ! 2349: -fi ! 2350: -if test "$clist" ! 2351: -then ! 2352: - $COMP -g -S $clist ! 2353: -fi ! 2354: -# create X*.s and *.sL files ! 2355: -if test "$bblist" ! 2356: -then ! 2357: - $DIR/bb $bblist ! 2358: -fi ! 2359: -# create X*.o files ! 2360: -if test "$flist" ! 2361: -then ! 2362: - f77 -g -c $slist ! 2363: -elif test "$clist" ! 2364: -then ! 2365: - $COMP -g -c $slist ! 2366: -fi ! 2367: -# make them into real .o files ! 2368: -if test "$rmlist" ! 2369: -then ! 2370: - for i in X*.o ! 2371: - do ! 2372: - mv $i `echo $i | sed s/X//` ! 2373: - done ! 2374: -fi ! 2375: -rm -f X*.s $rmlist prof.out ! 2376: - ! 2377: -if test $compflag ! 2378: -then exit 0 ! 2379: -fi ! 2380: -if test "$flist" ! 2381: -then ! 2382: - f77 -g $DIR/nexit.o $llist ! 2383: -else ! 2384: - $COMP -g $DIR/nexit.o $llist $lC ! 2385: -fi ! 2386: //GO.SYSIN DD lcomp
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.