![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to i8086b.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / db_400|
Return to i8086b.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / db_400 |
1.1 ! root 1: /* $Header: /src386/bin/db/RCS/i8086b.c,v 1.3 93/03/11 07:45:40 bin Exp Locker: bin $ ! 2: * ! 3: * The information contained herein is a trade secret of Mark Williams ! 4: * Company, and is confidential information. It is provided under a ! 5: * license agreement, and may be copied or disclosed only under the ! 6: * terms of that agreement. Any reproduction or disclosure of this ! 7: * material without the express written authorization of Mark Williams ! 8: * Company or persuant to the license agreement is unlawful. ! 9: * ! 10: * COHERENT Version 2.3.35 ! 11: * Copyright (c) 1982, 1983, 1984. ! 12: * An unpublished work by Mark Williams Company, Chicago. ! 13: * All rights reserved. ! 14: */ ! 15: /* ! 16: * A debugger. ! 17: * Intel 8086. ! 18: * ! 19: * $Log: i8086b.c,v $ ! 20: * Revision 1.3 93/03/11 07:45:40 bin ! 21: * Hal: post NDP update that at least ! 22: * can st breakpoints. ! 23: * ! 24: * Revision 1.1 92/06/10 14:36:31 bin ! 25: * Initial revision ! 26: * ! 27: * Revision 1.2 89/06/19 16:46:29 src ! 28: * Bug: 80286 virtual mode instructions not supported [ie: lgdt]. ! 29: * Fix: Metakey 'V' added to support 3 byte virtual mode instructions. (ABC) ! 30: * ! 31: * Revision 1.1 88/10/17 04:03:49 src ! 32: * Initial revision ! 33: * ! 34: * Revision: 386 version 92/05/01 ! 35: * Bernard Wald, Wald Software Consulting, Germany ! 36: */ ! 37: ! 38: #include <stdio.h> ! 39: #include <sys/param.h> ! 40: #include <l.out.h> ! 41: #include "trace.h" ! 42: #include "i8086.h" ! 43: ! 44: /* ! 45: * Disassemble an Intel 80386 instruction. ! 46: */ ! 47: ! 48: #define MAXINSTLEN 50 /* max. expanded opcode string length */ ! 49: #define MAXDISPLCTSIZE 6 /* max. displacement size in bytes */ ! 50: #define ESC_2_OPMAP2 0x0F /* escape to second byte of the opcode */ ! 51: ! 52: /* define instruction prefix codes */ ! 53: #define REP 0xF3 ! 54: #define REPNE 0xF2 ! 55: #define LOCK 0xF0 ! 56: ! 57: /* define address size prefix codes */ ! 58: #define ADDRPRE 0x67 ! 59: ! 60: /* define operand size prefix codes */ ! 61: #define OPDPRE 0x66 ! 62: ! 63: /* define segment override prefix codes */ ! 64: #define CS_PFX 0x2E ! 65: #define DS_PFX 0x3E ! 66: #define ES_PFX 0x26 ! 67: #define FS_PFX 0x64 ! 68: #define GS_PFX 0x65 ! 69: #define SS_PFX 0x36 ! 70: ! 71: #define EBP_SIB 5 ! 72: ! 73: #define UNSIGNED 0 ! 74: #define SIGNED 1 ! 75: ! 76: #define ADDZERO 0 ! 77: #define ADDADDR 1 ! 78: ! 79: #define mod(x) (((x)>>6)&3) ! 80: #define modR(x) (((x)>>3)&7) ! 81: #define modRM(x) ((x)&7) ! 82: #define sibss(x) (((x)>>6)&3) ! 83: #define sibx(x) (((x)>>3)&7) ! 84: #define sibb(x) ((x)&7) ! 85: ! 86: #define ADDRINDEX(x) (x == RM32 ? 1 : 0) ! 87: ! 88: #define TOLSYM 0x100 /* print symbol if greater */ ! 89: #define TOLHEX 0x10 /* print hexidecimal if greater */ ! 90: /* print decimal if less */ ! 91: static int addrflag=0; /* address size prefix flag */ ! 92: static int opdflag=0; /* operand size prefix flag */ ! 93: static int segflag=0; /* segment override prefix flag */ ! 94: static char *segPreStrp; /* segment prefix str., e.g. "cs:" */ ! 95: static unsigned char m; /* "Mod" field of ModR/M byte */ ! 96: static unsigned char mRM; /* "R/M" field of ModR/M byte */ ! 97: static unsigned char mReg; /* "REG" field of ModR/M byte */ ! 98: static unsigned char modRMloaded; /* ModR/M byte part of instruction ! 99: has already been loaded, if set */ ! 100: static unsigned char sb; /* "base" field of SIB byte */ ! 101: static unsigned char sss; /* "ss" field of SIB byte */ ! 102: static unsigned char sx; /* "index" field of SIB byte */ ! 103: static unsigned char sibLoaded; /* SIB byte part of instruction ! 104: has already been loaded, if set */ ! 105: ! 106: /* Function declatations */ ! 107: char *getmodREGstr(); ! 108: char *getmodRM16str(); ! 109: char *getmodRM32str(); ! 110: char *getsibstr(); ! 111: char *getmodRMstr(); ! 112: unsigned long getVal(); ! 113: unsigned short getValData(); ! 114: unsigned char check4prefix(); ! 115: unsigned long evalValData(); ! 116: char *getSegValStr(); ! 117: char *getASCIIimmediateStr(); ! 118: char *getASCIIdisplcmtStr(); ! 119: char *getSegPreStr(); ! 120: unsigned char c2opdsizeAdj(); ! 121: unsigned char getnbytes(); ! 122: unsigned char getgenRegIndex(); ! 123: ! 124: char * ! 125: newconinst(sp, s) ! 126: char *sp; /* pointer to assembler nmeumonic string, which will ! 127: contain the expanded string to be output (to screen). */ ! 128: int s; /* segment number */ ! 129: { ! 130: unsigned char ibp[MAXDISPLCTSIZE]; /* buffer to store read-in instruction/ ! 131: displacement machine code */ ! 132: char is[MAXINSTLEN], *isp; /* buffer to store formatted ! 133: instructon string. */ ! 134: char *tsp; /* temporary string pointer */ ! 135: int loop, useMap2; ! 136: ! 137: /* ! 138: * Initialize ! 139: */ ! 140: addrflag = 0; ! 141: opdflag = 0; ! 142: segflag = 0; ! 143: modRMloaded = 0; ! 144: sibLoaded = 0; ! 145: ! 146: isp = is; ! 147: ! 148: /* ! 149: * Check whether any prefixes are present ! 150: */ ! 151: for (loop=1, useMap2=0; loop; ) { ! 152: if (getb(s, ibp, sizeof(char)) == 0) ! 153: return (NULL); ! 154: switch (ibp[0]) { ! 155: case REP: /* rep instruction prefix */ ! 156: case REPNE: /* repne instruction prefix */ ! 157: case LOCK: /* lock instruction prefix */ ! 158: loop = 0; /* treat instruction prefixe like a */ ! 159: break; /* separate instruction */ ! 160: case ADDRPRE: /* address size prefix */ ! 161: addrflag = 1; ! 162: continue; ! 163: case OPDPRE: /* operand size prefix */ ! 164: opdflag = 1; ! 165: continue; ! 166: case CS_PFX: /* "cs:" segment override prefix */ ! 167: case DS_PFX: /* "ds:" segment override prefix */ ! 168: case ES_PFX: /* "es:" segment override prefix */ ! 169: case FS_PFX: /* "fs:" segment override prefix */ ! 170: case GS_PFX: /* "gs:" segment override prefix */ ! 171: case SS_PFX: /* "ss:" segment override prefix */ ! 172: segPreStrp = opStrMap1[ ibp[0] ]; /* store segment override */ ! 173: segflag = 1; ! 174: break; ! 175: case ESC_2_OPMAP2: /* opcode info is in the next byte */ ! 176: useMap2 = 1; ! 177: if (getb(s, ibp, sizeof(char)) == 0) ! 178: return (NULL); ! 179: loop = 0; ! 180: break; ! 181: default: ! 182: loop = 0; ! 183: } ! 184: } ! 185: ! 186: /* ! 187: * get and evaluate the formated opcode string obtained from the ! 188: * opStrMap1&2[] ! 189: */ ! 190: ! 191: /* get formatted opcode string and store in is[] */ ! 192: if ( (tsp = useMap2 ? opStrMap2[ibp[0]] : opStrMap1[ibp[0]]) == NULL ) { ! 193: sprintf(sp, "Invalid instruction byte = %02x (opStrMap%d)\n" ! 194: , ibp[0], useMap2 ? 2 : 1); ! 195: return( sp = (char *)strchr(sp, '\0') ); ! 196: } ! 197: strcpy(isp, tsp); ! 198: ! 199: /* Expand the formatted opcode string pointed at by isp to produce an ! 200: assembler nmeumonic string. Make sure sp is pointing to the current ! 201: end-of-string after each loop. */ ! 202: for ( ; isp[0]; isp++) { ! 203: switch (isp[0]) { ! 204: case '%': ! 205: if ( (isp = fmatPercent(isp, sp, s, ibp)) == NULL) { ! 206: printf("Invalid opcode string.\n"); ! 207: return(NULL); ! 208: } ! 209: /* point to end of string */ ! 210: sp = (char *)strchr(sp, '\0'); ! 211: break; ! 212: case ' ': ! 213: *sp++ = '\t'; ! 214: *sp = '\0'; ! 215: break; ! 216: default: ! 217: *sp++ = isp[0]; ! 218: *sp = '\0'; ! 219: ! 220: } ! 221: } ! 222: return(sp); ! 223: } ! 224: ! 225: ! 226: /* ! 227: * Evalute "%c1c2" and store the expanded results in wb[]. Then, copy wb[] into ! 228: * sp[] and return isp pointing to the next character of the formatted ! 229: * instruction string. ! 230: * ! 231: * CAREFULL! - when doing string manipulations, make sure that wbp ! 232: * is pointing at '\0' before breaking from switch statement. ! 233: */ ! 234: char * ! 235: fmatPercent(isp, sp, s, ibp) ! 236: char *isp, *sp; ! 237: int s; ! 238: unsigned char *ibp; ! 239: { ! 240: char wb[MAXINSTLEN], *wbp; /* work buffer (pointer) */ ! 241: unsigned char c1, c2; /* 1st & 2nd char after '%' */ ! 242: long deltaVal; ! 243: unsigned long val; ! 244: char *tsp1, *tsp2; /* temporary string pointer */ ! 245: ! 246: c1 = *++isp; ! 247: c2 = *++isp; ! 248: wbp = wb; ! 249: wbp[0] = '\0'; ! 250: ! 251: switch (c1) { ! 252: case 'A': ! 253: c2 = c2opdsizeAdj(c2); ! 254: val = getVal(s, ibp, c2, UNSIGNED, ADDZERO, &deltaVal); ! 255: wbp = getSegValStr(ibp, wbp, c2); ! 256: wbp = getASCIIdisplcmtStr(wbp, 'a', UNSIGNED, s, deltaVal, val); ! 257: break; ! 258: case 'C': ! 259: getmodRM(s, ibp, sizeof(char)); ! 260: wbp = (char *)strcpy(wbp, ctrlReg[mReg]); ! 261: wbp = (char *)strchr(wbp, '\0'); ! 262: break; ! 263: case 'D': ! 264: getmodRM(s, ibp, sizeof(char)); ! 265: wbp = (char *)strcpy(wbp, dbgReg[mReg]); ! 266: wbp = (char *)strchr(wbp, '\0'); ! 267: break; ! 268: case 'E': ! 269: case 'M': ! 270: case 'R': ! 271: if (getaddrsize() == RM16) ! 272: wbp = getmodRM16str(s, ibp, c2, wbp); ! 273: else ! 274: wbp = getmodRM32str(s, ibp, c2, wbp); ! 275: break; ! 276: case 'G': ! 277: wbp = getmodREGstr(s, ibp, c2, wbp); ! 278: break; ! 279: case 'I': ! 280: *wbp++ = '$'; ! 281: c2 = c2opdsizeAdj(c2); ! 282: val = getVal(s, ibp, c2, SIGNED, ADDZERO, &deltaVal); ! 283: wbp = getSegValStr(ibp, wbp, c2); ! 284: wbp = getASCIIimmediateStr(wbp, 'x', ! 285: SIGNED, s, deltaVal, val, c2); ! 286: break; ! 287: case 'J': ! 288: wbp = getSegPreStr(wbp); ! 289: c2 = c2opdsizeAdj(c2); ! 290: val = getVal(s, ibp, c2, SIGNED, ADDADDR, &deltaVal); ! 291: wbp = getSegValStr(ibp, wbp, c2); ! 292: wbp = getASCIIdisplcmtStr(wbp, 'a', SIGNED, s, deltaVal, val); ! 293: break; ! 294: case 'K': ! 295: wbp = getSegPreStr(wbp); ! 296: c2 = c2opdsizeAdj(c2); ! 297: val = getVal(s, ibp, c2, SIGNED, ADDADDR, &deltaVal); ! 298: wbp = getSegValStr(ibp, wbp, c2); ! 299: wbp = getASCIIdisplcmtStr(wbp, 's', SIGNED, s, deltaVal, val); ! 300: break; ! 301: /* case 'M': see case 'E' ! 302: break; */ ! 303: case 'O': ! 304: wbp = getSegPreStr(wbp); ! 305: c2 = getaddrsize() == RM16 ? 'w' : 'd'; ! 306: val = getVal(s, ibp, c2, SIGNED, ADDZERO, &deltaVal); ! 307: wbp = getSegValStr(ibp, wbp, c2); ! 308: wbp = getASCIIdisplcmtStr(wbp, 's', SIGNED, ! 309: (hdrinfo.defsegatt == RM16 ? 2 : 1), deltaVal, val); ! 310: break; ! 311: /* case 'R': see case 'E' ! 312: break; */ ! 313: case 'S': ! 314: getmodRM(s, ibp, sizeof(char)); ! 315: wbp = (char *)strcpy(wbp, segReg[mReg]); ! 316: wbp = (char *)strchr(wbp, '\0'); ! 317: break; ! 318: case 'T': ! 319: getmodRM(s, ibp, sizeof(char)); ! 320: wbp = (char *)strcpy(wbp, tstReg[mReg]); ! 321: wbp = (char *)strchr(wbp, '\0'); ! 322: break; ! 323: case 'X': ! 324: /* if (getaddrsize()==RM16) { ! 325: sprintf(wbp, "ds:(%%si)"); ! 326: } ! 327: else { ! 328: sprintf(wbp, "ds:(%%esi)"); ! 329: } ! 330: wbp = (char *)strchr(wbp, '\0'); ! 331: break; ! 332: */ case 'Y': ! 333: /* if (getaddrsize()==RM16) { ! 334: sprintf(wbp, "es:(%%di)"); ! 335: } ! 336: else { ! 337: sprintf(wbp, "es:(%%edi)"); ! 338: } ! 339: wbp = (char *)strchr(wbp, '\0'); ! 340: */ break; ! 341: case 'Z': ! 342: c2 = c2opdsizeAdj(c2); ! 343: switch(c2) { ! 344: case 'b': ! 345: *wbp++ = 'b'; ! 346: break; ! 347: case 'd': ! 348: *wbp++ = 'l'; ! 349: break; ! 350: case 'w': ! 351: *wbp++ = 'w'; ! 352: break; ! 353: case 'z': ! 354: *wbp++ = (getopdsize()==RM16 ? 'w': 'l'); ! 355: break; ! 356: } ! 357: wbp[0] = '\0'; ! 358: break; ! 359: case 'e': ! 360: if (getopdsize()==OPD16) { ! 361: *wbp++ = '%'; ! 362: *wbp++ = c2; ! 363: *wbp = '\0'; ! 364: } ! 365: else { ! 366: *wbp++ = '%'; ! 367: *wbp++ = 'e'; ! 368: *wbp++ = c2; ! 369: *wbp = '\0'; ! 370: } ! 371: break; ! 372: case 'g': /* just inserting the group string into isp */ ! 373: getmodRM(s, ibp, sizeof(char)); ! 374: if (grpStrMap[c2-'0'][mReg] == NULL) { ! 375: sprintf(wbp, "\nInvalid instruction byte = %02x (grpStrMap[%d][%d])\n" ! 376: , ibp[0], c2-'0', mReg); ! 377: return( wbp = (char *)strchr(wbp, '\0') ); ! 378: } ! 379: tsp1 = malloc(MAXINSTLEN); ! 380: tsp2 = isp; ! 381: strcpy(tsp1, isp+1); ! 382: strcpy(isp+1, grpStrMap[c2-'0'][mReg]); ! 383: isp = (char *)strchr(isp+1, '\0'); ! 384: strcpy(isp, tsp1); ! 385: isp = tsp2; ! 386: free(tsp1); ! 387: *wbp = '\0'; ! 388: break; ! 389: case 'r': ! 390: if (getb(s, ibp, sizeof(char)) == 0) ! 391: return (NULL); ! 392: break; ! 393: default: ! 394: *wbp++ = c1; ! 395: *wbp++ = c2; ! 396: *wbp = '\0'; ! 397: } ! 398: ! 399: sp = (char *)strcpy(sp, wb); ! 400: ! 401: return(isp); ! 402: } ! 403: ! 404: char * ! 405: getmodREGstr(s, ibp, c2, wbp) ! 406: int s; ! 407: unsigned char *ibp; ! 408: char c2, *wbp; ! 409: { ! 410: getmodRM(s, ibp, sizeof(char)); ! 411: strcpy(wbp, genReg[getgenRegIndex(c2)][mReg]); ! 412: wbp = (char *)strchr(wbp, '\0'); ! 413: return(wbp); ! 414: } ! 415: ! 416: char * ! 417: getmodRM16str(s, ibp, c2, wbp) ! 418: int s; ! 419: unsigned char *ibp; ! 420: char c2, *wbp; ! 421: { ! 422: unsigned char genRegIndex; ! 423: long deltaVal; ! 424: unsigned long val; ! 425: ! 426: getmodRM(s, ibp, sizeof(char)); ! 427: c2 = c2opdsizeAdj(c2); ! 428: ! 429: switch(m) { ! 430: case 0: ! 431: if (mRM==6) { ! 432: wbp = getSegPreStr(wbp); ! 433: val = getVal(s, ibp, 'w', SIGNED, ADDZERO, &deltaVal); ! 434: wbp = getSegValStr(ibp, wbp, 'w'); ! 435: wbp = getASCIIdisplcmtStr(wbp, 's', SIGNED, ! 436: (hdrinfo.defsegatt == RM16 ? 2 : 1), deltaVal, val); ! 437: break; ! 438: } ! 439: wbp = getSegPreStr(wbp); ! 440: wbp = (char *)strcpy(wbp, modRMtab16[mRM] ); ! 441: wbp = (char *)strchr(wbp, '\0'); ! 442: break; ! 443: case 1: ! 444: wbp = getmodRMstr(s, ibp, wbp, 'b', 'd', RM16, 1); ! 445: break; ! 446: case 2: ! 447: wbp = getmodRMstr(s, ibp, wbp, 'w', 'd', RM16, 1); ! 448: break; ! 449: case 3: ! 450: genRegIndex = getgenRegIndex(c2); ! 451: ! 452: wbp = (char *)strcpy(wbp, genReg[genRegIndex][mRM]); ! 453: wbp = (char *)strchr(wbp, '\0'); ! 454: break; ! 455: } ! 456: return(wbp); ! 457: } ! 458: ! 459: char * ! 460: getmodRM32str(s, ibp, c2, wbp) ! 461: int s; ! 462: unsigned char *ibp; ! 463: char c2, *wbp; ! 464: { ! 465: unsigned char genRegIndex; ! 466: long deltaVal; ! 467: unsigned long val; ! 468: ! 469: getmodRM(s, ibp, sizeof(char)); ! 470: c2 = c2opdsizeAdj(c2); ! 471: ! 472: switch(m) { ! 473: case 0: ! 474: if (mRM==4) { ! 475: wbp = getsibstr(s, ibp, wbp, '\0', m); ! 476: break; ! 477: } ! 478: if (mRM==5) { ! 479: wbp = getSegPreStr(wbp); ! 480: val = getVal(s, ibp, 'd', SIGNED, ADDZERO, &deltaVal); ! 481: wbp = getSegValStr(ibp, wbp, 'd'); ! 482: wbp = getASCIIdisplcmtStr(wbp, 's', SIGNED, ! 483: (hdrinfo.defsegatt == RM16 ? 2 : 1), deltaVal, val); ! 484: break; ! 485: } ! 486: wbp = getSegPreStr(wbp); ! 487: wbp = (char *)strcpy(wbp, modRMtab32[mRM] ); ! 488: wbp = (char *)strchr(wbp, '\0'); ! 489: break; ! 490: case 1: ! 491: if (mRM==4) { ! 492: wbp = getsibstr(s, ibp, wbp, 'b', m); ! 493: break; ! 494: } ! 495: wbp = getmodRMstr(s, ibp, wbp, 'b', 'd', RM32, 1); ! 496: break; ! 497: case 2: ! 498: if (mRM==4) { ! 499: wbp = getsibstr(s, ibp, wbp, 'd', m); ! 500: break; ! 501: } ! 502: wbp = getmodRMstr(s, ibp, wbp, 'd', 'd', RM32, 1); ! 503: break; ! 504: case 3: ! 505: genRegIndex = getgenRegIndex(c2); ! 506: ! 507: wbp = (char *)strcpy(wbp, genReg[genRegIndex][mRM]); ! 508: wbp = (char *)strchr(wbp, '\0'); ! 509: break; ! 510: } ! 511: return(wbp); ! 512: } ! 513: ! 514: char * ! 515: getmodRMstr(s, ibp, wbp, displctsize, form, addrsize, signedVal) ! 516: int s; ! 517: unsigned char *ibp; ! 518: char *wbp; ! 519: unsigned char displctsize, form, addrsize, signedVal; ! 520: { ! 521: long deltaVal; ! 522: unsigned long val; ! 523: ! 524: wbp = getSegPreStr(wbp); ! 525: ! 526: val = getVal(s, ibp, displctsize, signedVal, ADDZERO, &deltaVal); ! 527: wbp = getSegValStr(ibp, wbp, displctsize); ! 528: wbp = getASCIIdisplcmtStr(wbp, form, signedVal, s, deltaVal, val); ! 529: ! 530: wbp = (char *)strcpy(wbp, modRMtab[ADDRINDEX(addrsize)][mRM] ); ! 531: wbp = (char *)strchr(wbp, '\0'); ! 532: ! 533: return(wbp); ! 534: } ! 535: ! 536: char * ! 537: getsibstr(s, ibp, wbp, displctsize, m) ! 538: int s; ! 539: unsigned char *ibp; ! 540: char *wbp; ! 541: unsigned char displctsize, m; ! 542: { ! 543: long deltaVal; ! 544: unsigned long val; ! 545: ! 546: getsib(s, ibp, sizeof(char)); ! 547: ! 548: switch(m) { ! 549: case 0: ! 550: wbp = getSegPreStr(wbp); ! 551: if (sb == EBP_SIB) { ! 552: val = getVal(s, ibp, 'd', SIGNED, ADDZERO, &deltaVal); ! 553: wbp = getSegValStr(ibp, wbp, 'd'); ! 554: wbp = getASCIIdisplcmtStr(wbp, 'd', SIGNED, s, deltaVal, val); ! 555: } ! 556: else { ! 557: wbp = (char *)strcpy(wbp, modRMtab[ADDRINDEX(RM32)][sb]); ! 558: wbp = (char *)strchr(wbp, '\0'); ! 559: } ! 560: break; ! 561: case 1: ! 562: wbp = getSegPreStr(wbp); ! 563: ! 564: val = getVal(s, ibp, displctsize, SIGNED, ADDZERO, &deltaVal); ! 565: wbp = getSegValStr(ibp, wbp, displctsize); ! 566: wbp = getASCIIdisplcmtStr(wbp, 'd', SIGNED, s, deltaVal, val); ! 567: ! 568: wbp = (char *)strcpy(wbp, modRMtab[ADDRINDEX(RM32)][sb]); ! 569: wbp = (char *)strchr(wbp, '\0'); ! 570: break; ! 571: case 2: ! 572: wbp = getSegPreStr(wbp); ! 573: ! 574: val = getVal(s, ibp, displctsize, SIGNED, ADDZERO, &deltaVal); ! 575: wbp = getSegValStr(ibp, wbp, displctsize); ! 576: wbp = getASCIIdisplcmtStr(wbp, 'd', SIGNED, s, deltaVal, val); ! 577: ! 578: wbp = (char *)strcpy(wbp, modRMtab[ADDRINDEX(RM32)][sb]); ! 579: wbp = (char *)strchr(wbp, '\0'); ! 580: break; ! 581: } ! 582: if (sibtab[sss][sx] != NULL) { ! 583: wbp = (char *)strcpy(wbp, sibtab[sss][sx]); ! 584: wbp = (char *)strchr(wbp, '\0'); ! 585: } ! 586: return(wbp); ! 587: } ! 588: ! 589: unsigned long ! 590: getVal(s, ibp, mysizeof, signedVal, addVal, deltaValp) ! 591: int s; ! 592: unsigned char *ibp; ! 593: unsigned char mysizeof, signedVal; ! 594: unsigned char addVal; ! 595: long *deltaValp; ! 596: { ! 597: unsigned char nbytes; ! 598: unsigned long val; ! 599: ! 600: if ( (nbytes = getValData(s, ibp, signedVal, mysizeof)) == 0) ! 601: return(ADDZERO); ! 602: nbytes = check4prefix(mysizeof, nbytes); ! 603: val = evalValData(ibp, signedVal, nbytes, addVal, deltaValp); ! 604: return(val); ! 605: } ! 606: ! 607: unsigned short ! 608: getValData(s, ibp, signedVal, mysizeof) ! 609: int s; ! 610: unsigned char *ibp, signedVal; ! 611: unsigned char mysizeof; ! 612: { ! 613: unsigned char nbytes, i; ! 614: ! 615: if ( (nbytes = getnbytes(mysizeof)) == 0 ) ! 616: return(0); ! 617: ! 618: if ( (getb(s, ibp, nbytes)) == 0 ) { ! 619: printf("Unable to read opcode displacement or immediate data\n"); ! 620: return (0); ! 621: } ! 622: ! 623: for (i=nbytes; i<MAXDISPLCTSIZE; i++) { ! 624: if (signedVal) ! 625: ibp[i] = (ibp[i-1] & 0x80) ? 0xFF : 0; ! 626: else ! 627: ibp[i] = 0; ! 628: } ! 629: return(nbytes); ! 630: } ! 631: ! 632: unsigned char ! 633: check4prefix(mysizeof, nbytes) ! 634: { ! 635: switch(mysizeof) { ! 636: case 'f': /* 32 bit pointer */ ! 637: case 'l': /* 48 bit pointer */ ! 638: nbytes -= 2; ! 639: break; ! 640: } ! 641: return(nbytes); ! 642: } ! 643: ! 644: unsigned long ! 645: evalValData(ibp, signedVal, nbytes, addVal, deltaValp) ! 646: unsigned char *ibp; ! 647: unsigned char signedVal, nbytes; ! 648: unsigned char addVal; ! 649: long *deltaValp; ! 650: { ! 651: unsigned long baseVal, val; ! 652: ! 653: if (addVal) ! 654: baseVal = add; ! 655: else baseVal = 0L; ! 656: ! 657: switch (nbytes) { ! 658: case DBBYTE: ! 659: if (signedVal) { ! 660: *deltaValp = *(signed char *)ibp; ! 661: if ((signed long)*deltaValp >= 0) ! 662: val = baseVal + *deltaValp; ! 663: else ! 664: val = baseVal ! 665: - (unsigned long) ! 666: (-(signed long)*deltaValp); ! 667: } ! 668: else { ! 669: *deltaValp = *(unsigned char *)ibp; ! 670: val = baseVal + *deltaValp; ! 671: } ! 672: break; ! 673: case DBWORD: ! 674: if (signedVal) { ! 675: *deltaValp = *(signed short *)ibp; ! 676: if ((signed long)*deltaValp >= 0) ! 677: val = baseVal + *deltaValp; ! 678: else ! 679: val = baseVal ! 680: - (unsigned long) ! 681: (-(signed long)*deltaValp); ! 682: } ! 683: else { ! 684: *deltaValp = *(unsigned short *)ibp; ! 685: val = baseVal + *deltaValp; ! 686: } ! 687: break; ! 688: case DBLONG: ! 689: *deltaValp = *(long *)ibp; ! 690: if (signedVal) { ! 691: if ((signed long)*deltaValp >= 0) ! 692: val = baseVal + *deltaValp; ! 693: else ! 694: val = baseVal ! 695: - (unsigned long) ! 696: (-(signed long)*deltaValp); ! 697: } ! 698: else { ! 699: val = baseVal + *deltaValp; ! 700: } ! 701: break; ! 702: } ! 703: return(val); ! 704: } ! 705: ! 706: char * ! 707: getSegValStr(ibp, wbp, mysizeof) ! 708: unsigned char *ibp; ! 709: char *wbp; ! 710: unsigned char mysizeof; ! 711: { ! 712: unsigned char nbytes; ! 713: ! 714: nbytes = getnbytes(mysizeof); ! 715: ! 716: switch(mysizeof) { ! 717: case 'f': /* 32 bit pointer */ ! 718: case 'l': /* 48 bit pointer */ ! 719: sprintf(wbp, "0x%02x%02x:", ibp[nbytes-1], ibp[nbytes-2]); ! 720: wbp = (char *)strchr(wbp, '\0'); ! 721: break; ! 722: } ! 723: return(wbp); ! 724: } ! 725: ! 726: char * ! 727: getASCIIimmediateStr(wbp, form, signedVal, segn, deltaVal, val, mysizeof) ! 728: char *wbp; ! 729: unsigned char form, signedVal; ! 730: int segn; ! 731: signed long deltaVal; ! 732: unsigned long val; ! 733: unsigned char mysizeof; ! 734: { ! 735: switch (getnbytes(mysizeof)) { ! 736: case DBBYTE: ! 737: val &= 0xFF; ! 738: break; ! 739: case DBWORD: ! 740: val &= 0xFFFF; ! 741: break; ! 742: } ! 743: getASCIIdisplcmtStr(wbp, form, signedVal, segn, deltaVal, val); ! 744: } ! 745: ! 746: char * ! 747: getASCIIdisplcmtStr(wbp, form, signedVal, segn, deltaVal, val) ! 748: char *wbp; ! 749: unsigned char form, signedVal; ! 750: int segn; ! 751: signed long deltaVal; ! 752: unsigned long val; ! 753: { ! 754: if (signedVal && deltaVal<0) ! 755: deltaVal = -deltaVal; ! 756: switch(form) { ! 757: case 'a': /* print address */ ! 758: if ( deltaVal > TOLSYM) /* print out symbol, if possible */ ! 759: conaddr(wbp, segn, val, I); ! 760: else { /* Print out address in hex format */ ! 761: *wbp = '('; ! 762: printaddr(wbp, val); ! 763: wbp = (char *)strchr(wbp, '\0'); ! 764: *wbp = ')'; ! 765: *wbp = '\0'; ! 766: } ! 767: break; ! 768: case 'd': /* print decimal */ ! 769: if (!val) ! 770: break; ! 771: /* if (deltaVal > TOLSYM) { ! 772: conaddr(wbp, segn, val, I); ! 773: } ! 774: else { ! 775: */ if (getopdsize()==OPD16) { ! 776: sprintf(wbp, "%d", val); ! 777: } ! 778: else { ! 779: sprintf(wbp, "%ld", val); ! 780: } ! 781: /* } ! 782: */ break; ! 783: case 's': /* if available, print symbol; otherwise print address */ ! 784: conaddr(wbp, segn, val, I); ! 785: break; ! 786: case 'x': /* print hex */ ! 787: /* if (deltaVal > TOLSYM) { ! 788: conaddr(wbp, segn, val, I); ! 789: } ! 790: else { ! 791: */ if (getopdsize()==OPD16) { ! 792: if (deltaVal > TOLHEX) { ! 793: sprintf(wbp, "0x%x", val); ! 794: } ! 795: else { ! 796: sprintf(wbp, "%d", val); ! 797: } ! 798: } ! 799: else { ! 800: if (deltaVal > TOLHEX) { ! 801: sprintf(wbp, "0x%lx", val); ! 802: } ! 803: else { ! 804: sprintf(wbp, "%ld", val); ! 805: } ! 806: } ! 807: /* } ! 808: */ break; ! 809: default: ! 810: if(1) printf("invalid form = %c; ", form); ! 811: } ! 812: ! 813: wbp = (char *)strchr(wbp, '\0'); ! 814: return(wbp); ! 815: } ! 816: ! 817: printaddr(wbp, v) ! 818: char *wbp; ! 819: unsigned long v; ! 820: { ! 821: if (getopdsize()==OPD16) { ! 822: sprintf(wbp, "%04x", v); ! 823: } ! 824: else { ! 825: sprintf(wbp, "%04X", v); ! 826: } ! 827: } ! 828: ! 829: char * ! 830: getSegPreStr(wbp) ! 831: char *wbp; ! 832: { ! 833: if (segflag) { ! 834: strcpy(wbp, segPreStrp); ! 835: wbp = (char *)strchr(wbp, '\0'); ! 836: } ! 837: return(wbp); ! 838: } ! 839: ! 840: unsigned char c2opdsizeAdj(c2) ! 841: unsigned char c2; ! 842: { ! 843: if (getopdsize()==RM16) { ! 844: switch(c2) { /* set to addr16 lengths */ ! 845: case 'a': ! 846: c2 = 'w'; ! 847: break; ! 848: case 'p': ! 849: c2 = 'f'; ! 850: break; ! 851: case 'v': ! 852: c2 = 'w'; ! 853: break; ! 854: } ! 855: } ! 856: else { ! 857: switch(c2) { /* set to addr32 lengths */ ! 858: case 'a': ! 859: c2 = 'd'; ! 860: break; ! 861: case 'p': ! 862: c2 = 'l'; ! 863: break; ! 864: case 'v': ! 865: c2 = 'd'; ! 866: break; ! 867: } ! 868: } ! 869: return(c2); ! 870: } ! 871: ! 872: unsigned char ! 873: getnbytes(mysizeof) ! 874: unsigned char mysizeof; ! 875: { ! 876: unsigned char nbytes; ! 877: ! 878: switch(mysizeof) { ! 879: case 'b': ! 880: nbytes = DBBYTE; ! 881: break; ! 882: case 'd': ! 883: nbytes = DBLONG; ! 884: break; ! 885: case 'f': ! 886: nbytes = DBPTR32; ! 887: break; ! 888: case 'l': ! 889: nbytes = DBPTR48; ! 890: break; ! 891: case 'w': ! 892: nbytes = DBWORD; ! 893: break; ! 894: case '\0': ! 895: nbytes = 0; ! 896: break; ! 897: default: ! 898: if(1) printf("invalid nbytes = %c; " ! 899: "a 1 byte size is chosen by default\n" ! 900: , mysizeof); ! 901: nbytes = DBBYTE; ! 902: } ! 903: return(nbytes); ! 904: } ! 905: ! 906: unsigned char ! 907: getgenRegIndex(c2) ! 908: unsigned char c2; ! 909: { ! 910: unsigned char genRegIndex; ! 911: ! 912: switch(c2) { ! 913: case 'a': ! 914: if (getopdsize() == OPD16) ! 915: genRegIndex = 1; ! 916: else ! 917: genRegIndex = 2; ! 918: break; ! 919: case 'b': ! 920: genRegIndex = 0; ! 921: break; ! 922: case 'd': ! 923: genRegIndex = 2; ! 924: break; ! 925: case 'v': ! 926: if (getopdsize() == OPD16) ! 927: genRegIndex = 1; ! 928: else ! 929: genRegIndex = 2; ! 930: break; ! 931: case 'w': ! 932: genRegIndex = 1; ! 933: break; ! 934: default: ! 935: if(1) printf("invalid c2 = %c; " ! 936: "a 1 byte reg is shown by default\n" ! 937: , c2); ! 938: genRegIndex = 0; ! 939: } ! 940: return(genRegIndex); ! 941: } ! 942: ! 943: getaddrsize() ! 944: { ! 945: return( addrflag ? 48 - hdrinfo.defsegatt : hdrinfo.defsegatt ); ! 946: } ! 947: ! 948: getopdsize() ! 949: { ! 950: return( opdflag ? 48 - hdrinfo.defsegatt : hdrinfo.defsegatt ); ! 951: } ! 952: ! 953: getmodRM(s, ibp, c) ! 954: unsigned char *ibp; ! 955: unsigned c; ! 956: { ! 957: if (!modRMloaded) { ! 958: if (getb(s, ibp, c) == 0) ! 959: return (NULL); ! 960: m = mod(ibp[0]); ! 961: mRM = modRM(ibp[0]); ! 962: mReg = modR(ibp[0]); ! 963: modRMloaded = 1; ! 964: } ! 965: } ! 966: ! 967: getsib(s, ibp, c) ! 968: unsigned char *ibp; ! 969: unsigned c; ! 970: { ! 971: if (!sibLoaded) { ! 972: if ((getb(s, ibp, c)) == 0) ! 973: return (NULL); ! 974: sss = sibss(ibp[0]); ! 975: sx = sibx(ibp[0]); ! 976: sb = sibb(ibp[0]); ! 977: sibLoaded = 1; ! 978: } ! 979: } ! 980: ! 981: /* ! 982: * Given a size character, `t1', and a type, `t2', return the appropriate ! 983: * format string. ! 984: */ ! 985: char * ! 986: getform(t1, t2) ! 987: register int t1; ! 988: register int t2; ! 989: { ! 990: register char *cp; ! 991: register char *sp; ! 992: ! 993: if (t1=='f' || t1=='F') ! 994: return ("%g"); ! 995: if (t1 == 'h') ! 996: t1 = 'w'; ! 997: if ((cp=strchr(sp="bwlv", t1)) == NULL) ! 998: return ("?"); ! 999: t1 = cp-sp; ! 1000: if ((cp=strchr(sp="duox", t2)) == NULL) ! 1001: return ("?"); ! 1002: t2 = cp-sp; ! 1003: return (formtab[t1][t2]); ! 1004: } ! 1005: ! 1006: /* End of i8086b1.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.