home *** CD-ROM | disk | FTP | other *** search
/ Programming Win32 Under the API / ProgrammingWin32UnderTheApiPatVillani.iso / dsasmsrc.zip / disasm.h < prev    next >
C/C++ Source or Header  |  1998-10-09  |  14KB  |  489 lines
  1. //
  2. //
  3. // This program was written by Sang Cho, associate professor at 
  4. //                                       the department of 
  5. //                                       computer science and engineering
  6. //                                       chongju university
  7. // language used: gcc 
  8. //
  9. // date of second release: August 30, 1998 (alpha version)
  10. //
  11. //
  12. //      you can contact me: e-mail address: sangcho@alpha94.chongju.ac.kr
  13. //                            hitel id: chokhas
  14. //                        phone number: (0431) 229-8491    +82-431-229-8491
  15. //
  16. //            real address: Sang Cho
  17. //                      Computer and Information Engineering
  18. //                      ChongJu University
  19. //                      NaeDok-Dong 36 
  20. //                      ChongJu 360-764
  21. //                      South Korea
  22. //
  23. //   Copyright (C) 1997,1998                                 by Sang Cho.
  24. //
  25. // Permission is granted to make and distribute verbatim copies of this
  26. // program provided the copyright notice and this permission notice are
  27. // preserved on all copies.
  28. //
  29. // File: disasm.h 
  30.  
  31. /* standard clib */                     
  32. # include <stdio.h> 
  33. # include <stdarg.h>
  34. # include <string.h>
  35. # include <malloc.h>
  36. # include <ctype.h>
  37.  
  38. # define pr1ntf(x)         if(printMode==1)printf(x);else
  39. # define pr2ntf(x,y)       if(printMode==1)printf(x,y);else
  40. # define pr3ntf(x,y,z)     if(printMode==1)printf(x,y,z);else
  41. # define pushTrace(z)      if(debugx>254) printTrace();else debugTab[debugx++]=z
  42. # define popTrace()        debugx--
  43. # define TOINT(u)          (int)(u)
  44.  
  45. typedef void               *LPVOID;
  46. typedef char                CHAR;
  47. typedef short               WCHAR;
  48. typedef short               SHORT;
  49. typedef long                LONG;
  50. typedef unsigned short      USHORT;
  51. typedef unsigned long       DWORD;
  52. typedef unsigned long long  LONGLONG;
  53. typedef LONGLONG           *PLONGLONG;
  54. typedef int                 BOOL;
  55. typedef unsigned char       BYTE;
  56. typedef unsigned short      WORD;
  57. typedef BYTE               *PBYTE;
  58. typedef WORD               *PWORD;
  59. typedef DWORD              *PDWORD;
  60. typedef int boolean;    /* BOOLEAN is returned by a PREDICATE */
  61.  
  62. /* pedump hooks */
  63. #define IMAGE_SIZEOF_SHORT_NAME              8
  64.  
  65. typedef struct _IMAGE_SECTION_HEADER {
  66.     BYTE    Name[IMAGE_SIZEOF_SHORT_NAME];
  67.     union {
  68.         DWORD   PhysicalAddress;
  69.         DWORD   VirtualSize;
  70.     } Misc;
  71.     DWORD   VirtualAddress;
  72.     DWORD   SizeOfRawData;
  73.     DWORD   PointerToRawData;
  74.     DWORD   PointerToRelocations;
  75.     DWORD   PointerToLinenumbers;
  76.     WORD    NumberOfRelocations;
  77.     WORD    NumberOfLinenumbers;
  78.     DWORD   Characteristics;
  79. } IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
  80.  
  81. extern     IMAGE_SECTION_HEADER    shdr[];
  82.  
  83. /* yylex hooks */
  84. extern  int        fsize;
  85. extern  int        yyfirsttime;
  86. extern  int        GotEof;
  87. extern  PBYTE      yyfp, yypmax;
  88.  
  89. typedef struct __key_ {
  90. int     class;
  91. DWORD   c_pos;
  92. DWORD   c_ref;
  93. } _key_, *PKEY;
  94.  
  95. typedef struct _history{
  96. short   m;     //nextMode
  97. short   f;     //fatalError
  98. short   l;     //number of labels deleted
  99. DWORD   r;     //lastReset
  100. DWORD   c;     //cur_position;
  101. DWORD   s;     //eraseUncertain start
  102. DWORD   e;     //eraseUncertain end
  103. } history, *PHISTORY;
  104.  
  105. typedef struct __labels {
  106. int     priority;
  107. DWORD   ref;
  108. } _labels;
  109.  
  110. typedef struct _node {
  111. DWORD        pos1;
  112. DWORD        pos2;
  113. short        red;
  114. short        rclass;
  115. short        rcount;
  116. struct _node *left;
  117. struct _node *right;
  118. } node, *PNODE;
  119.  
  120. typedef struct _node1 {
  121. DWORD        pos2;
  122. short        red;
  123. short        rclass;
  124. struct _node1 *left;
  125. struct _node1 *right;
  126. } node1, *PNODE1;
  127.  
  128. /* hooks to link pedump and decoder and printing */
  129.  
  130. extern LPVOID     lpFile;
  131. extern LPVOID     lpMap;
  132. extern LPVOID     lpMap1;
  133. extern int        nSections;         // number of sections
  134. extern DWORD      imagebaseRVA; /* image base of the file + code RVA */
  135. extern int        CodeOffset;    /* starting point of code   */
  136. extern int        CodeSize;      /* size of code             */
  137. extern int        vCodeOffset;   /* starting point of code   */
  138. extern int        vCodeSize;     /* size of code             */
  139. extern int        MapSize;       /* size of code map         */
  140. extern DWORD      maxRVA;        /* the largest RVA of sections */
  141. extern int        maxRVAsize;    /* size of that section */
  142.  
  143. extern int        jLc;
  144. extern int        addLabelsNum;
  145. extern int        ErrorRecoverNum;
  146. extern int        eraseUncertainNum;
  147. extern int        resetNum;
  148. extern int        totZero;
  149. extern int        needJump;              // well it is return or jmp instruction
  150. extern DWORD      needJumpNext;          // possible instruction after return or jmp
  151. extern int        needCall;              // it is call 
  152. extern DWORD      needCallRef;          // the target of call
  153. extern DWORD      needCallNext;          // position following call instruction
  154. extern int        printCol;
  155. extern int        moreprint;            // need to print more
  156.  
  157. extern char      *piNameBuff;   // import module name buffer
  158. extern char      *pfNameBuff;   // import functions in the module name buffer
  159. extern char      *peNameBuff;   // export function name buffer
  160. extern char      *pmNameBuff;   // menu name buffer
  161. extern char      *pdNameBuff;   // dialog name buffer
  162. extern int        piNameBuffSize;       // import module name buffer
  163. extern int        pfNameBuffSize;       // import functions in the module name buffer
  164. extern int        peNameBuffSize;       // export function name buffer
  165. extern int        pmNameBuffSize;   // menu name buffer
  166. extern int        pdNameBuffSize;       // dialog name buffer
  167.  
  168. /* hooks to link disassembler and decoder and printing */
  169. extern int        nextMode;
  170. extern int        printMode;
  171. extern DWORD      lastReset;
  172. extern int        fatalError;
  173. extern int        errorcount;          /* number of errors */
  174. extern int        NumberOfBytesProcessed;
  175. extern int        addressOveride;       /* address size overide  */
  176. extern int        operandOveride;   /* operand size overide..*/
  177. extern DWORD      label_start_pos;  /* label start position of case jump block */
  178. extern DWORD      min_label; 
  179. extern DWORD      cur_position;
  180. extern int        dmc;
  181. extern DWORD      dmLabels[];
  182. extern int        labelClass;
  183. extern int        finished;
  184. extern int        a_loc;
  185. extern int        a_loc_save;
  186. extern int        i_col;
  187. extern int        i_col_save;
  188. extern int        i_psp;
  189. extern int        prefixStack[];
  190. extern int        opclass;
  191. extern int        modclass;
  192. extern int        i_opclass;
  193. extern int        i_opcode;
  194. extern int        i_mod;
  195. extern int        opclassSave;
  196. extern int        opsave;
  197. extern int        modsave;
  198. extern int        i_sib;
  199. extern int        i_byte;
  200. extern int        i_word;
  201. extern int        i_dword;
  202. extern int        m_byte;
  203. extern int        needspacing;
  204. extern int        byteaddress;
  205. extern int        imb;
  206. extern int        mbytes[];
  207. extern int        stringBuf[];
  208. extern int        m_dword;
  209. extern DWORD      lastAnchor;
  210. extern int        leaveFlag;
  211. extern int        delta;
  212.  
  213.  
  214. extern DWORD      imageBase;
  215. extern DWORD      entryPoint; 
  216. extern int        opcodeTable[]; 
  217. extern int        opcode2Table[];
  218. extern int        repeatgroupTable[];
  219. extern int        modTable[];
  220. extern int        mod16Table[];
  221. extern int        sibTable[];
  222. extern int        regTable[];
  223. extern int        rmTable[];
  224.  
  225. extern int        debugx;
  226. extern int        debugTab[];
  227.  
  228. /* for label processing */
  229. extern int        hsize;
  230. extern int        width;
  231. extern LPVOID     headerS;
  232. extern LPVOID     headerD;
  233.  
  234. // functions in pedump.c
  235. int    pedump (int,char **);
  236. LPVOID GetActualAddress (LPVOID,DWORD);
  237.  
  238. // functions in main.c
  239. void  initDisassembler();
  240. void  resetDisassembler(DWORD);
  241. void  pushEnvironment();
  242. void  popEnvironment();
  243. void  showDots();
  244. void  Disassembler();
  245. void  Disassembler1();
  246. void  markCodes();
  247. void  ErrorRecover();
  248. void  clearSomeBadGuy(PHISTORY);
  249. void  checkZeros();
  250. void  checkZeros1();
  251. void  checkCrossing();
  252. DWORD GetNextOne();
  253. int   isThisGoodRef(DWORD,DWORD,DWORD);
  254. int   tryToSaveIt(DWORD);
  255. void  saveIt(DWORD);
  256. int   isItStartAnyWay(DWORD);
  257. void  trySomeAddress(DWORD);
  258. void  tryAnyAddress();
  259. int   tryMoreAddress    (DWORD,DWORD,PDWORD);
  260. int   trySomeMoreAddress(DWORD,DWORD,PDWORD);
  261. int   looksLikeMenus(DWORD);
  262. void  showPascalString(DWORD);
  263. void  showNullString(DWORD);
  264. void  markStrings(DWORD,DWORD);
  265. int   maybePartof(DWORD);
  266. void  markAddress(DWORD,DWORD);
  267. void  markAddress1(DWORD,DWORD);
  268. void  tryPascalStrings();
  269. void  checkOneInstructionFiller(DWORD);
  270. void  changeToAddress(DWORD,DWORD);
  271. void  changeToBytes(DWORD,DWORD);
  272. void  changeToCode(DWORD,DWORD);
  273. void  changeToDword(DWORD,DWORD);
  274. void  changeToFloat(DWORD,DWORD);
  275. void  changeToDouble(DWORD,DWORD);
  276. void  changeToQuad(DWORD,DWORD);
  277. void  changeTo80Real(DWORD,DWORD);
  278. void  changeToWord(DWORD,DWORD);
  279. void  changeToNullString(DWORD);
  280. void  changeToPascalString(DWORD);
  281. void  PostProcessing2(DWORD,DWORD);
  282. int   checkWellDone(DWORD,DWORD);
  283. void  PostProcessing1();
  284. void  printTrace();
  285. void  peekTrace();
  286. void  MapSummary();
  287. void  ReportMap();
  288. void  reportHistory();
  289. void  readHint();
  290. int   stringCheck(int,DWORD,DWORD);
  291. void  labelBody1(int,DWORD,DWORD);
  292. void  labelPP(PNODE1,DWORD);
  293. void  labelBody(PNODE);
  294. void  labelP(PNODE);
  295. void  LabelProcess();
  296. void  xrefBody1(int,DWORD,DWORD);
  297. void  xrefPP(PNODE1,DWORD);
  298. void  xrefBody(PNODE);
  299. void  xrefP(PNODE);
  300. void  Xreference();
  301. void  eraseUncertain(DWORD,PHISTORY);
  302. void  eraseUncertain1(DWORD,PHISTORY);
  303. void  eraseCarefully(DWORD,PHISTORY);
  304. int   isLabelCheckable(DWORD);
  305. void  setAddress(DWORD);
  306. void  setAnyAddress(DWORD);
  307. int   isItAnyAddress(DWORD);
  308. int   touchAnyAddress(DWORD);
  309. int   isAddressBlock(DWORD);
  310. void  setFirstTime(DWORD);
  311. int   isItFirstTime(DWORD);
  312. void  MyBtreeInsertDual(int,DWORD,DWORD);
  313. void  MyBtreeDeleteDual(int,DWORD,DWORD);
  314. int   BadEnter(DWORD,DWORD);
  315. void  EnterLabel(int,DWORD,DWORD);
  316. void  markData(int,DWORD,DWORD);
  317. void  DeleteLabels(DWORD);
  318. int   isGoodAddress(DWORD);
  319. DWORD AddressCheck(DWORD);
  320. int   getNumExeSec ();
  321. DWORD getOffset (DWORD);
  322. DWORD getRVA (DWORD);
  323. DWORD Get32Address(DWORD);
  324. int   isThisSecure(DWORD);
  325. int   isNotGoodJump(DWORD);
  326. PBYTE toFile(DWORD);
  327. BYTE  getByteFile(DWORD);
  328. int   getIntFile(DWORD);
  329. BYTE  getMap(DWORD);
  330. void  setMap(DWORD,BYTE);
  331. void  orMap(DWORD,BYTE);
  332. void  exMap(DWORD,BYTE);
  333. BYTE  getMap1(DWORD);
  334. void  setMap1(DWORD,BYTE);
  335. void  orMap1(DWORD,BYTE);
  336. void  exMap1(DWORD,BYTE);
  337. DWORD Get16_32Address(DWORD);
  338. void  Myfinish();
  339. void  initHeaders();
  340. void  deleteTrees1(PNODE1);
  341. void  deleteTrees(PNODE);
  342. void  deleteHeaders();
  343. PNODE1 searchTT1(PNODE1,DWORD);
  344. PNODE1 searchTT(PNODE1,DWORD,DWORD);
  345. PNODE searchT(PNODE,DWORD,DWORD);
  346. PNODE searchTree(LPVOID,DWORD,DWORD);
  347. PKEY searchBtree1(PKEY);
  348. PKEY searchBtree3(PKEY);
  349. PKEY searchBtreeX(PKEY);
  350. int   referCount(DWORD);
  351. int   referCount1(DWORD);
  352. int   insertTree(LPVOID,int,DWORD,DWORD);
  353. int   MyBtreeInsert(PKEY);
  354. int   MyBtreeInsertX(PKEY);
  355. int   MyBtreeInsertEx(PKEY);
  356. int   deleteTree(LPVOID,DWORD,DWORD);
  357. int   MyBtreeDelete(PKEY);
  358. int   sortT(PNODE1,DWORD);
  359. int   sortTree(PNODE);
  360. int   sortTrees();
  361. int   sortTrees1();
  362. PNODE1 rotate1(PNODE1*,PNODE1,DWORD,DWORD);
  363. PNODE  rotate (PNODE* ,PNODE, DWORD,DWORD);
  364. int   insertTT(PNODE1*,int,DWORD,DWORD);
  365. int   insertSecond(PNODE,int,DWORD,DWORD);
  366. int   insertT (PNODE* ,int,DWORD,DWORD);
  367. PNODE1 findSeed1(PNODE1*,DWORD,DWORD);
  368. PNODE  findSeed (PNODE*, DWORD,DWORD);
  369. void  make_leaf_red1(PNODE1*,DWORD,DWORD);
  370. void  make_leaf_red (PNODE*, DWORD,DWORD);
  371. int   deleteTT(PNODE1*,DWORD,DWORD);
  372. int   deleteT (PNODE*, DWORD,DWORD);
  373. int   heapLTE(_labels,_labels);
  374. int   heapLT (_labels,_labels);
  375. void  initHeap();
  376. int   upHeap  (_labels a[], int);
  377. void  downHeap(_labels a[], int,int);
  378. _labels  getHeap(int*);
  379. int   putHeap(int*,int,DWORD);
  380. int   getLabels();
  381. void  addRef(int,DWORD,DWORD);
  382. int   countRef(DWORD);
  383. void  addLabels(DWORD,int);
  384.  
  385. // functions in decoder.c
  386. int instruction(int c);
  387. int databody(int c);
  388. int labeldata();
  389. int worddata();
  390. int instructionbody();
  391. int byte();
  392. int bytex();
  393. int op();
  394. int pascalstring();
  395. int nullstring();
  396. int word();
  397. int dword();
  398. int adword();
  399. int wdword();
  400. int pword();
  401. int prefixes();
  402. int onebyteinstr();
  403. int twobyteinstr();
  404. int modrm();
  405. int modrm1();
  406. int modrm2();
  407. int sib();
  408. int labelstartposition();
  409. int label1();
  410. int opext();
  411. int opextg();
  412. int ReadOneByte();
  413. int PeekOneByte();
  414. int PeekSecondByte();
  415.  
  416. // functions in print.c
  417. int  print_m_byte();
  418. int  print_m_dword();
  419. int  print_i_byte();
  420. int  print_i_byte32();
  421. int  print_i_dword();
  422. int  print_i_word();
  423. int  print_rel8();
  424. int  print_rel32();
  425. int  print_moff();
  426. int  r___(int);
  427. int  mm____();
  428. int  rm_m32 (int);
  429. int  rm_m16 (int);
  430. int  reg_s ();
  431. int  base();
  432. int  scaledindex();
  433. void specifier (int);
  434. int  prefix();
  435. int  r_m_  (int);
  436. int  r_m_32  (int);
  437. int  r_m_16  (int);
  438. int  Sreg__();
  439. int  m16_32();
  440. int  m32_32();
  441. int  m_____();
  442. void nmonicprint();
  443. int addressfix();
  444. int addressprint1(int);
  445. int addressprint();
  446. int bodyprint(int);
  447. int bodyprint0();
  448. int bodyprint1();
  449. int bodyprint2();
  450. int bodyprint21();
  451. int bodyprint3();
  452. int bodyprint4();
  453. int bodyprint5();
  454. int bodyprint6();
  455. int isEntry(DWORD);
  456. int GotName(int,DWORD,DWORD);
  457. int printName(DWORD);
  458. int printExportName1(DWORD);
  459. int printExportName();
  460. int printEntryMark();
  461. int printLabelMark();
  462. int printDataMark();
  463. int printString();
  464. int print0case(); 
  465. int print1case();
  466. int print2case();
  467. int print3case();
  468. int print4case();
  469. int print5case();
  470. int print6case(); 
  471. int print7case();
  472. int print8case();
  473. int print9case();
  474. int print10case();
  475. int print11case();
  476. int print12case();
  477. int print13case();
  478. int print14case();
  479. int print15case();
  480. int print16case();
  481. int print20case();
  482. int print21case();
  483. int print22case();
  484. int print23case();
  485. int print24case();
  486. int print25case();
  487.  
  488. // functions in ieee.c
  489. double ConvertFromIeeeExtended(PBYTE);