home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / dosdisas.zip / dccsrcoo.zip / idioms.cpp < prev    next >
C/C++ Source or Header  |  1997-04-09  |  46KB  |  1,394 lines
  1. /*****************************************************************************
  2.  *$Log:    idioms.c,v $
  3.  * Revision 2.16  94/03/14  08:42:10  cifuente
  4.  * Type propagation is now part of another file (proplong.c).
  5.  * 
  6.  * Revision 2.15  94/02/22  17:03:08  cifuente
  7.  * Idiom 16 : logical negation.
  8.  * 
  9.  * Revision 2.14  94/02/22  15:17:01  cifuente
  10.  * New idioms and propagation of long variables.
  11.  * 
  12.  * Revision 2.13  93/12/13  15:41:49  cifuente
  13.  * Fixed bug in idiom17 that incremented opcode rather than pIcode.
  14.  * 
  15.  * Revision 2.12  93/12/13  12:21:44  cifuente
  16.  * Interprocedural live analysis finished.
  17.  * 
  18.  * Revision 2.11  93/11/10  17:27:31  cifuente
  19.  * Procedure header, locals
  20.  * 
  21.  * Revision 2.10  93/11/08  12:04:09  cifuente
  22.  * du1 analysis finished.  Instantiates procedure arguments for user
  23.  * declared procedures.
  24.  * 
  25.  * Revision 2.9  93/11/01  15:04:29  cifuente
  26.  * Finds byte and integer expressions
  27.  * 
  28.  * Revision 2.8  93/10/25  10:54:30  cifuente
  29.  * New SYNTHETIC instructions for d/u analysis
  30.  * 
  31.  * Revision 2.7  93/10/11  11:38:28  cifuente
  32.  * Introduced new idioms (idioms 5..11)
  33.  * First walk of HIGH_LEVEL icodes.
  34.  * 
  35.  * Revision 2.6  93/10/01  08:59:47  cifuente
  36.  * boolT type - for compilation under unix SVR4.2
  37.  * 
  38.  * Revision 2.5  93/09/29  10:44:52  cifuente
  39.  * LOW_LEVEL and HIGH_LEVEL icode definitions.  Increases llIcode indirection
  40.  * by 2 levels.
  41.  * 
  42.  * Revision 2.3  93/08/23  12:15:34  cifuente
  43.  * Interactive mode with curses
  44.  * 
  45.  * Revision 2.1  93/03/30  14:52:06  cifuente
  46.  * Compiled with gcc.
  47.  * 
  48.  *          REVCOMP project machine idiom recognition
  49.  ****************************************************************************/
  50.  
  51. #include "dcc.h"
  52. #include <string.h>
  53. #ifdef __DOSWIN__
  54. #include <stdio.h>
  55. #endif
  56.  
  57.  
  58. /*****************************************************************************
  59.  * JmpInst - Returns TRUE if opcode is a conditional or unconditional jump
  60.  ****************************************************************************/
  61. boolT JmpInst(llIcode opcode)
  62. {
  63.     switch (opcode) {
  64.         case iJMP:  case iJMPF: case iJCXZ:
  65.         case iLOOP: case iLOOPE:case iLOOPNE:
  66.         case iJB:   case iJBE:  case iJAE:  case iJA:
  67.         case iJL:   case iJLE:  case iJGE:  case iJG: 
  68.         case iJE:   case iJNE:  case iJS:   case iJNS:
  69.         case iJO:   case iJNO:  case iJP:   case iJNP:
  70.             return TRUE;
  71.     }
  72.     return FALSE;
  73. }
  74.  
  75.  
  76. /*****************************************************************************
  77. /* checkStkVars - Checks for PUSH SI
  78.  *                          [PUSH DI]
  79.  *                or         PUSH DI
  80.  *                          [PUSH SI]
  81.  * In which case, the stack variable flags are set 
  82.  ****************************************************************************/
  83. static Int checkStkVars (PICODE pIcode, PICODE pEnd, PPROC pProc)
  84. {
  85.     /* Look for PUSH SI */
  86.     if ((pIcode < pEnd) && (pIcode->ic.ll.opcode == iPUSH) &&
  87.         (pIcode->ic.ll.dst.regi == rSI))
  88.     {
  89.         pProc->flg |= SI_REGVAR;
  90.  
  91.         /* Look for PUSH DI */
  92.         if (++pIcode < pEnd && (pIcode->ic.ll.opcode == iPUSH) &&
  93.             (pIcode->ic.ll.dst.regi == rDI))
  94.         {
  95.             pProc->flg |= DI_REGVAR;    
  96.             return 2;
  97.         }
  98.         else
  99.             return 1;
  100.     }
  101.     else if ((pIcode < pEnd) && (pIcode->ic.ll.opcode == iPUSH) &&
  102.         (pIcode->ic.ll.dst.regi == rDI))
  103.     {
  104.         pProc->flg |= DI_REGVAR;
  105.  
  106.         /* Look for PUSH SI */
  107.         if ((++pIcode < pEnd) && (pIcode->ic.ll.opcode == iPUSH) &&
  108.             (pIcode->ic.ll.dst.regi == rSI))
  109.         {
  110.             pProc->flg |= SI_REGVAR;
  111.             return 2;
  112.         }
  113.         else
  114.             return 1;
  115.     }
  116.     else
  117.         return 0;
  118. }
  119.  
  120.  
  121. /*****************************************************************************
  122.  * idiom1 - HLL procedure prologue;  Returns number of instructions matched.
  123.  *          PUSH BP     ==> ENTER immed, 0
  124.  *          MOV  BP, SP     and sets PROC_HLL flag
  125.  *          [SUB  SP, immed]
  126.  *          [PUSH SI]
  127.  *          [PUSH DI]
  128.  *        - Second version: Push stack variables and then save BP
  129.  *          PUSH BP
  130.  *          PUSH SI
  131.  *          [PUSH DI]
  132.  *          MOV BP, SP
  133.  *        - Third version: Stack variables
  134.  *          [PUSH SI]
  135.  *          [PUSH DI]
  136.  ****************************************************************************/
  137. static Int idiom1(PICODE pIcode, PICODE pEnd, PPROC pProc)
  138. { Int n;
  139.  
  140.     /* PUSH BP as first instruction of procedure */
  141.     if ( !(pIcode->ic.ll.flg & I) && pIcode->ic.ll.src.regi == rBP)
  142.     {
  143.         /* MOV BP, SP as next instruction */
  144.         if (++pIcode < pEnd && ! (pIcode->ic.ll.flg & (I | TARGET | CASE))
  145.            && pIcode->ic.ll.opcode == iMOV && pIcode->ic.ll.dst.regi == rBP
  146.            && pIcode->ic.ll.src.regi == rSP)
  147.         {
  148.             pProc->args.minOff = 2;
  149.             pProc->flg |= PROC_IS_HLL;
  150.  
  151.             /* Look for SUB SP, immed */
  152.             if ((++pIcode < pEnd) &&
  153.                 (pIcode->ic.ll.flg & (I | TARGET | CASE)) == I &&
  154.                 pIcode->ic.ll.opcode == iSUB && pIcode->ic.ll.dst.regi == rSP)
  155.             {
  156.                 return (3 + checkStkVars (++pIcode, pEnd, pProc));
  157.             }
  158.             else
  159.                 return (2 + checkStkVars (pIcode, pEnd, pProc));
  160.         }
  161.  
  162.         /* PUSH SI
  163.          * [PUSH DI]
  164.          * MOV BP, SP */
  165.         else
  166.         {
  167.             n = checkStkVars (pIcode, pEnd, pProc);
  168.             if (n > 0)
  169.             {
  170.                 /* Look for MOV BP, SP */
  171.                 pIcode += n;
  172.                 if (pIcode < pEnd && 
  173.                     ! (pIcode->ic.ll.flg & (I | TARGET | CASE)) && 
  174.                     pIcode->ic.ll.opcode == iMOV && 
  175.                     pIcode->ic.ll.dst.regi == rBP && 
  176.                     pIcode->ic.ll.src.regi == rSP)
  177.                 {
  178.                     pProc->args.minOff = 2 + (n * 2);
  179.                     return (2 + n);
  180.                 }
  181.                 else return 0;        // Cristina: check this please!
  182.             }
  183.             else return 0;            // Cristina: check this please!
  184.         }
  185.     }
  186.  
  187.     else 
  188.         return (checkStkVars (pIcode, pEnd, pProc));
  189. }
  190.  
  191.  
  192. /*****************************************************************************
  193.  * popStkVars - checks for
  194.  *          [POP DI]
  195.  *          [POP SI]
  196.  *      or  [POP SI]
  197.  *          [POP DI]
  198.  ****************************************************************************/
  199. static void popStkVars (PICODE pIcode, PICODE pEnd, PPROC pProc)
  200. {
  201.     /* Match [POP DI] */
  202.     if (pIcode->ic.ll.opcode == iPOP)
  203.         if ((pProc->flg & DI_REGVAR) && (pIcode->ic.ll.dst.regi == rDI))
  204.             invalidateIcode (pIcode);
  205.         else if ((pProc->flg & SI_REGVAR) && (pIcode->ic.ll.dst.regi == rSI))
  206.             invalidateIcode (pIcode);
  207.  
  208.     /* Match [POP SI] */
  209.     if ((pIcode+1)->ic.ll.opcode == iPOP)
  210.         if ((pProc->flg & SI_REGVAR) && ((pIcode+1)->ic.ll.dst.regi == rSI))
  211.             invalidateIcode (pIcode+1);
  212.         else if ((pProc->flg & DI_REGVAR) && ((pIcode+1)->ic.ll.dst.regi == rDI))
  213.             invalidateIcode (pIcode+1);
  214. }
  215.  
  216.  
  217. /*****************************************************************************
  218.  * idiom2 - HLL procedure epilogue;  Returns number of instructions matched.
  219.  *          [POP DI]
  220.  *          [POP SI]
  221.  *          MOV  SP, BP 
  222.  *          POP  BP
  223.  *          RET(F)
  224.  *****************************************************************************/
  225. static Int idiom2(PICODE pIcode, PICODE pEnd, Int ip, PPROC pProc)
  226. { PICODE nicode;
  227.  
  228.     /* Match MOV SP, BP */
  229.     if (ip != 0 && ((pIcode->ic.ll.flg & I) != I) && 
  230.         pIcode->ic.ll.dst.regi == rSP && pIcode->ic.ll.src.regi == rBP)
  231.     {
  232.         /* Get next icode, skip over holes in the icode array */
  233.         nicode = pIcode + 1;
  234.         while (nicode->ic.ll.flg & NO_CODE)
  235.             nicode++;
  236.  
  237.         /* Match POP BP */
  238.         if (nicode < pEnd &&
  239.             ! (nicode->ic.ll.flg & (I | TARGET | CASE)) &&
  240.             nicode->ic.ll.opcode == iPOP && 
  241.             nicode->ic.ll.dst.regi == rBP)
  242.         {
  243.             nicode++;
  244.             
  245.             /* Match RET(F) */
  246.             if (nicode < pEnd &&
  247.                 ! (nicode->ic.ll.flg & (I | TARGET | CASE)) &&
  248.                 (nicode->ic.ll.opcode == iRET || 
  249.                 nicode->ic.ll.opcode == iRETF))
  250.             {
  251.                 popStkVars (pIcode-2, pEnd, pProc);
  252.                 return 2;
  253.             }
  254.         }
  255.     }
  256.     return 0;
  257. }
  258.  
  259.  
  260.  
  261. /*****************************************************************************
  262.  * idiom3 - C calling convention.
  263.  *          CALL(F)  proc_X
  264.  *          ADD  SP, immed
  265.  *      Eg: CALL proc_X
  266.  *          ADD  SP, 6
  267.  *          =>  pProc->cbParam = immed
  268.  *        Special case: when the call is at the end of the procedure, 
  269.  *                      sometimes the stack gets restored by a MOV sp, bp.
  270.  *                      Need to flag the procedure in these cases.
  271.  *  Used by compilers to restore the stack when invoking a procedure using
  272.  *  the C calling convention.
  273.  ****************************************************************************/
  274. static Int idiom3(PICODE pIcode, PICODE pEnd)
  275. { 
  276.     /* Match ADD  SP, immed */
  277.     if ((++pIcode < pEnd) && (pIcode->ic.ll.flg & I) &&
  278.         (pIcode->ic.ll.opcode == iADD) && (pIcode->ic.ll.dst.regi == rSP))
  279.         return (pIcode->ic.ll.immed.op);
  280.     else if ((pIcode->ic.ll.opcode == iMOV) && (pIcode->ic.ll.dst.regi == rSP)
  281.              && (pIcode->ic.ll.src.regi == rBP))
  282.         (pIcode-1)->ic.ll.flg |= REST_STK;
  283.     return 0;
  284. }
  285.  
  286.  
  287. /*****************************************************************************
  288.  * idiom 17 - C calling convention.
  289.  *          CALL(F)  xxxx
  290.  *          POP reg
  291.  *          [POP reg]           reg in {AX, BX, CX, DX}
  292.  *      Eg: CALL proc_X
  293.  *          POP cx
  294.  *          POP cx      (4 bytes of arguments)
  295.  *          => pProc->cbParam = # pops * 2
  296.  *  Found in Turbo C when restoring the stack for a procedure that uses the
  297.  *  C calling convention.  Used to restore the stack of 2 or 4 bytes args.
  298.  ****************************************************************************/
  299. static Int idiom17 (PICODE pIcode, PICODE pEnd)
  300. { Int i = 0;            /* Count on # pops */
  301.   byte regi;
  302.  
  303.     /* Match POP reg */
  304.     if ((++pIcode < pEnd) && (pIcode->ic.ll.opcode == iPOP))
  305.     {
  306.         regi = pIcode->ic.ll.dst.regi;
  307.         if ((regi >= rAX) && (regi <= rBX))
  308.             i++;
  309.         while ((++pIcode)->ic.ll.opcode == iPOP)
  310.         {
  311.             if (pIcode->ic.ll.dst.regi == regi)
  312.                 i++;
  313.             else
  314.                 break;
  315.         }
  316.         return (i * 2);
  317.     }
  318.     return (0);
  319. }
  320.  
  321.  
  322. /*****************************************************************************
  323.  * idiom4 - Pascal calling convention.
  324.  *          RET(F) immed   
  325.  *          ==> pProc->cbParam = immed
  326.  *              sets CALL_PASCAL flag 
  327.  *        - Second version: check for optional pop of stack vars
  328.  *          [POP DI]
  329.  *          [POP SI]
  330.  *          POP BP
  331.  *          RET(F) [immed]
  332.  *          - Third version: pop stack vars
  333.  *            [POP DI]
  334.  *            [POP SI]
  335.  *            RET(F) [immed]
  336.  ****************************************************************************/
  337. static void idiom4 (PICODE pIcode, PICODE pEnd, PPROC pProc)
  338. {
  339.     /* Check for [POP DI]
  340.      *           [POP SI] */
  341.     popStkVars (pIcode-3, pEnd, pProc);
  342.  
  343.     /* Check for POP BP */
  344.     if (((pIcode-1)->ic.ll.opcode == iPOP) && 
  345.         (((pIcode-1)->ic.ll.flg & I) != I) &&
  346.         ((pIcode-1)->ic.ll.dst.regi == rBP))
  347.         invalidateIcode (pIcode-1);
  348.     else
  349.         popStkVars (pIcode-2, pEnd, pProc);
  350.  
  351.     /* Check for RET(F) immed */
  352.     if (pIcode->ic.ll.flg & I) 
  353.     {
  354.         pProc->cbParam = (int16)pIcode->ic.ll.immed.op;
  355.         pProc->flg |= CALL_PASCAL;
  356.     }
  357. }
  358.  
  359.  
  360. /*****************************************************************************
  361.  * idiom5 - Long addition.
  362.  *      ADD reg/stackOff, reg/stackOff
  363.  *      ADC reg/stackOff, reg/stackOff 
  364.  *      Eg:     ADD ax, [bp-4]
  365.  *              ADC dx, [bp-2]
  366.  *          =>  dx:ax = dx:ax + [bp-2]:[bp-4]
  367.  *      Found in Borland Turbo C code.
  368.  *      Commonly used idiom for long addition.
  369.  ****************************************************************************/
  370. static boolT idiom5 (PICODE pIcode, PICODE pEnd)
  371. {
  372.     if (pIcode < pEnd)
  373.         if ((pIcode+1)->ic.ll.opcode == iADC)
  374.             return (TRUE);
  375.     return (FALSE);
  376. }
  377.  
  378.  
  379. /*****************************************************************************
  380.  * idiom6 - Long substraction.
  381.  *      SUB reg/stackOff, reg/stackOff
  382.  *      SBB reg/stackOff, reg/stackOff 
  383.  *      Eg:     SUB ax, [bp-4]
  384.  *              SBB dx, [bp-2]
  385.  *          =>  dx:ax = dx:ax - [bp-2]:[bp-4]
  386.  *      Found in Borland Turbo C code.
  387.  *      Commonly used idiom for long substraction.
  388.  ****************************************************************************/
  389. static boolT idiom6 (PICODE pIcode, PICODE pEnd)
  390. {
  391.     if (pIcode < pEnd)
  392.         if ((pIcode+1)->ic.ll.opcode == iSBB)
  393.             return (TRUE);
  394.     return (FALSE);
  395. }
  396.  
  397.  
  398. /*****************************************************************************
  399.  * idiom7 - Assign zero
  400.  *      XOR reg/stackOff, reg/stackOff
  401.  *      Eg:     XOR ax, ax
  402.  *          =>  ax = 0
  403.  *      Found in Borland Turbo C and Microsoft C code.
  404.  ****************************************************************************/
  405. static boolT idiom7 (PICODE pIcode)
  406. { PMEM dst, src;
  407.  
  408.     dst = &pIcode->ic.ll.dst;
  409.     src = &pIcode->ic.ll.src;
  410.     if (dst->regi == 0)                 /* global variable */
  411.     {
  412.         if ((dst->segValue == src->segValue) && (dst->off == src->off))
  413.             return (TRUE);
  414.     }
  415.     else if (dst->regi < INDEXBASE)     /* register */
  416.     {
  417.         if (dst->regi == src->regi)
  418.             return (TRUE);
  419.     }
  420.     else if ((dst->off) && (dst->seg == rSS) && (dst->regi == INDEXBASE + 6))
  421.                                         /* offset from BP */
  422.     {
  423.         if ((dst->off == src->off) && (dst->seg == src->seg) &&
  424.             (dst->regi == src->regi))
  425.             return (TRUE);
  426.     }
  427.     return (FALSE);
  428. }
  429.  
  430.  
  431. /*****************************************************************************
  432.  * idiom21 - Assign long kte with high part zero
  433.  *        XOR regH, regH
  434.  *        MOV regL, kte
  435.  *        => regH:regL = kte
  436.  *        Eg: XOR dx, dx
  437.  *            MOV ax, 3
  438.  *            => dx:ax = 3
  439.  *        Note: only the following valid combinations are available:
  440.  *                dx:ax
  441.  *                cx:bx
  442.  *        Found in Borland Turbo C code.
  443.  ****************************************************************************/
  444. static boolT idiom21 (PICODE picode, PICODE pend)
  445. { PMEM dst, src;
  446.  
  447.     dst = &picode->ic.ll.dst;
  448.     src = &picode->ic.ll.src;
  449.     if (((picode+1) < pend) && ((picode+1)->ic.ll.flg & I))
  450.     {
  451.         if ((dst->regi == src->regi) && (dst->regi > 0) && 
  452.             (dst->regi < INDEXBASE))
  453.         {
  454.             if ((dst->regi == rDX) && ((picode+1)->ic.ll.dst.regi == rAX))
  455.                 return (TRUE);
  456.             if ((dst->regi == rCX) && ((picode+1)->ic.ll.dst.regi == rBX))
  457.                 return (TRUE);
  458.         }
  459.     }
  460.     return (FALSE);
  461. }
  462.  
  463.  
  464. /*****************************************************************************
  465.  * idiom8 - Shift right by 1 (signed long ops)
  466.  *      SAR reg, 1
  467.  *      RCR reg, 1
  468.  *      Eg:     SAR dx, 1
  469.  *              RCR ax, 1
  470.  *          =>  dx:ax = dx:ax >> 1      (dx:ax are signed long)
  471.  *      Found in Microsoft C code for long signed variable shift right.
  472.  ****************************************************************************/
  473. static boolT idiom8 (PICODE pIcode, PICODE pEnd)
  474. {
  475.     if (pIcode < pEnd)
  476.     {
  477.         if (((pIcode->ic.ll.flg & I) == I) && (pIcode->ic.ll.immed.op == 1))
  478.             if (((pIcode+1)->ic.ll.opcode == iRCR) &&   
  479.                 (((pIcode+1)->ic.ll.flg & I) == I) && 
  480.                 ((pIcode+1)->ic.ll.immed.op == 1))
  481.                 return (TRUE);
  482.     }
  483.     return (FALSE);
  484. }
  485.  
  486.  
  487. /*****************************************************************************
  488.  * idiom 15 - Shift left by n 
  489.  *      SHL reg, 1
  490.  *      SHL reg, 1
  491.  *      [...]
  492.  *      [SHL    reg, 1]
  493.  *      Eg:     SHL ax, 1
  494.  *              SHL ax, 1
  495.  *          =>  ax = ax << 2
  496.  *      Found in Borland Turbo C code to index an array (array multiplication)
  497.  ****************************************************************************/
  498. static Int idiom15 (PICODE picode, PICODE pend)
  499. { Int n = 1; 
  500.   byte regi;
  501.  
  502.     if (picode < pend)
  503.     {
  504.         /* Match SHL reg, 1 */
  505.         if ((picode->ic.ll.flg & I) && (picode->ic.ll.immed.op == 1))
  506.         {
  507.             regi = picode->ic.ll.dst.regi;
  508.             while (1)
  509.             {
  510.                 if (((picode+n) < pend) &&
  511.                     ((picode+n)->ic.ll.opcode == iSHL) &&
  512.                     ((picode+n)->ic.ll.flg & I) && 
  513.                     ((picode+n)->ic.ll.immed.op == 1) &&
  514.                     ((picode+n)->ic.ll.dst.regi == regi))
  515.                     n++;
  516.                 else
  517.                     break;
  518.             }
  519.         }
  520.     }
  521.     if (n > 1)
  522.         return (n);
  523.     else
  524.         return (0);
  525. }
  526.  
  527.  
  528. /*****************************************************************************
  529.  * idiom12 - Shift left long by 1
  530.  *      SHL reg, 1
  531.  *      RCL reg, 1
  532.  *      Eg:     SHL ax, 1
  533.  *              RCL dx, 1
  534.  *          =>  dx:ax = dx:ax << 1
  535.  *      Found in Borland Turbo C code for long variable shift left.
  536.  ****************************************************************************/
  537. static boolT idiom12 (PICODE pIcode, PICODE pEnd)
  538. {
  539.     if (pIcode < pEnd)
  540.     {
  541.         if (((pIcode->ic.ll.flg & I) == I) && (pIcode->ic.ll.immed.op == 1))
  542.             if (((pIcode+1)->ic.ll.opcode == iRCL) &&   
  543.                 (((pIcode+1)->ic.ll.flg & I) == I) && 
  544.                 ((pIcode+1)->ic.ll.immed.op == 1))
  545.                 return (TRUE);
  546.     }
  547.     return (FALSE);
  548. }
  549.  
  550.  
  551. /*****************************************************************************
  552.  * idiom9 - Shift right by 1 (unsigned long ops)
  553.  *      SHR reg, 1
  554.  *      RCR reg, 1
  555.  *      Eg:     SHR dx, 1
  556.  *              RCR ax, 1
  557.  *          =>  dx:ax = dx:ax >> 1   (dx:ax are unsigned long)
  558.  *      Found in Microsoft C code for long unsigned variable shift right.
  559.  ****************************************************************************/
  560. static boolT idiom9 (PICODE pIcode, PICODE pEnd)
  561. {
  562.     if (pIcode < pEnd)
  563.     {
  564.         if (((pIcode->ic.ll.flg & I) == I) && (pIcode->ic.ll.immed.op == 1))
  565.             if (((pIcode+1)->ic.ll.opcode == iRCR) &&   
  566.                 (((pIcode+1)->ic.ll.flg & I) == I) && 
  567.                 ((pIcode+1)->ic.ll.immed.op == 1))
  568.                 return (TRUE);
  569.     }
  570.     return (FALSE);
  571. }
  572.  
  573.  
  574. /*****************************************************************************
  575.  * idiom10 - Jump if not equal to 0
  576.  *      OR  reg, reg
  577.  *      JNE labX
  578.  *      Eg:     OR  ax, ax
  579.  *              JNE labX
  580.  *      => HLI_JCOND (ax != 0) labX
  581.  *        Note: we also check that these instructions are not followed by
  582.  *              CMP reg, kte
  583.  *              JE  lab
  584.  *              because this is most likely a long conditional equality test.
  585.  *      Found in Borland Turbo C.
  586.  ****************************************************************************/
  587. static boolT idiom10old (PICODE pIcode, PICODE pEnd)
  588. {
  589.     if (pIcode < pEnd)
  590.     {
  591.         /* Check OR reg, reg */
  592.         if (((pIcode->ic.ll.flg & I) != I) && 
  593.             (pIcode->ic.ll.src. regi > 0) && 
  594.             (pIcode->ic.ll.src.regi < INDEXBASE) && 
  595.             (pIcode->ic.ll.src.regi == pIcode->ic.ll.dst.regi))
  596.             if ((pIcode+3) < pEnd)
  597.             {
  598.                 if (((pIcode+1)->ic.ll.opcode == iJNE) &&
  599.                     ((pIcode+2)->ic.ll.opcode != iCMP) &&
  600.                     ((pIcode+3)->ic.ll.opcode != iJE))
  601.                     return (TRUE);
  602.             }
  603.             else    /* at the end of the procedure */
  604.                 if (((pIcode+1) < pEnd) && ((pIcode+1)->ic.ll.opcode == iJNE))
  605.                     return (TRUE);
  606.     }
  607.     return (FALSE);
  608. }
  609.  
  610.  
  611. /*****************************************************************************
  612.  * idiom10 - Jump if not equal to 0
  613.  *      OR  reg, reg
  614.  *      JNE labX
  615.  *      Eg:     OR  ax, ax
  616.  *              JNE labX
  617.  *      => CMP reg 0
  618.  *           JNE labX
  619.  *        This instruction is NOT converted into the equivalent high-level
  620.  *        instruction "HLI_JCOND (reg != 0) labX" because we do not know yet if
  621.  *        it forms part of a long register conditional test.  It is therefore
  622.  *        modified to simplify the analysis.
  623.  *      Found in Borland Turbo C.
  624.  ****************************************************************************/
  625. static void idiom10 (PICODE pIcode, PICODE pEnd)
  626. {
  627.     if (pIcode < pEnd)
  628.     {
  629.         /* Check OR reg, reg */
  630.         if (((pIcode->ic.ll.flg & I) != I) && 
  631.             (pIcode->ic.ll.src. regi > 0) && 
  632.             (pIcode->ic.ll.src.regi < INDEXBASE) && 
  633.             (pIcode->ic.ll.src.regi == pIcode->ic.ll.dst.regi))
  634.             if (((pIcode+1) < pEnd) && ((pIcode+1)->ic.ll.opcode == iJNE))
  635.             {
  636.                 pIcode->ic.ll.opcode = iCMP;
  637.                 pIcode->ic.ll.flg |= I;
  638.                 pIcode->ic.ll.immed.op = 0;
  639.                 pIcode->du.def = 0;
  640.                 pIcode->du1.numRegsDef = 0;
  641.             }
  642.     }
  643. }
  644.  
  645.  
  646. /*****************************************************************************
  647.  * idiom 13 - Word assign
  648.  *      MOV regL, mem
  649.  *      MOV regH, 0
  650.  *      Eg:     MOV al, [bp-2]
  651.  *              MOV ah, 0
  652.  *      => MOV ax, [bp-2]
  653.  *      Found in Borland Turbo C, used for multiplication and division of
  654.  *      byte operands (ie. they need to be extended to words).
  655.  ****************************************************************************/
  656. static byte idiom13 (PICODE picode, PICODE pend)
  657. { byte regi;
  658.  
  659.     if (picode < pend)
  660.     {
  661.         /* Check for regL */
  662.         regi = picode->ic.ll.dst.regi;
  663.         if (((picode->ic.ll.flg & I) != I) && (regi >= rAL) && (regi <= rBH))
  664.         {
  665.             /* Check for MOV regH, 0 */
  666.             if (((picode+1)->ic.ll.opcode == iMOV) &&
  667.                 ((picode+1)->ic.ll.flg & I) &&
  668.                 ((picode+1)->ic.ll.immed.op == 0))
  669.             {
  670.                 if ((picode+1)->ic.ll.dst.regi == (regi + 4))
  671.                     return (regi - rAL + rAX);
  672.             }
  673.         }
  674.     }
  675.     return (0);
  676. }
  677.  
  678.  
  679. /*****************************************************************************
  680.  * idiom 14 - Long word assign
  681.  *      MOV regL, mem/reg
  682.  *      XOR regH, regH
  683.  *      Eg:     MOV ax, di 
  684.  *              XOR dx, dx
  685.  *      => MOV dx:ax, di 
  686.  *        Note: only the following combinations are allowed: 
  687.  *                dx:ax
  688.  *                cx:bx
  689.  *        this is to remove the possibility of making errors in situations
  690.  *        like this:
  691.  *            MOV dx, offH
  692.  *            MOV ax, offL
  693.  *            XOR    cx, cx
  694.  *      Found in Borland Turbo C, used for division of unsigned integer 
  695.  *      operands.
  696.  ****************************************************************************/
  697. static boolT idiom14 (PICODE picode, PICODE pend, byte *regL, byte *regH)
  698. {
  699.     if (picode < pend)
  700.     {
  701.         /* Check for regL */
  702.         *regL = picode->ic.ll.dst.regi;
  703.         if (((picode->ic.ll.flg & I) != I) && ((*regL == rAX) || (*regL ==rBX)))
  704.         {
  705.             /* Check for XOR regH, regH */
  706.             if (((picode+1)->ic.ll.opcode == iXOR) &&
  707.                 (((picode+1)->ic.ll.flg & I) != I)) 
  708.             {
  709.                 *regH = (picode+1)->ic.ll.dst.regi;
  710.                 if (*regH == (picode+1)->ic.ll.src.regi)
  711.                 {
  712.                     if ((*regL == rAX) && (*regH == rDX))
  713.                         return (TRUE);
  714.                     if ((*regL == rBX) && (*regH == rCX))
  715.                         return (TRUE);
  716.                 }
  717.             }
  718.         }
  719.     }
  720.     return (FALSE);
  721. }
  722.  
  723. /*****************************************************************************
  724.  * idiom11 - Negate long integer
  725.  *      NEG regH
  726.  *      NEG regL
  727.  *      SBB regH, 0
  728.  *      Eg:     NEG dx
  729.  *              NEG ax
  730.  *              SBB dx, 0
  731.  *      => dx:ax = - dx:ax
  732.  *      Found in Borland Turbo C.
  733.  ****************************************************************************/
  734. static boolT idiom11 (PICODE pIcode, PICODE pEnd)
  735. { condId type;          /* type of argument */
  736.  
  737.     if ((pIcode + 2) < pEnd)
  738.     {
  739.         type = idType  (pIcode, DST);
  740.         if ((type != CONSTANT) && (type != OTHER))
  741.         {
  742.             /* Check NEG reg/mem 
  743.              *       SBB reg/mem, 0*/
  744.             if (((pIcode+1)->ic.ll.opcode == iNEG) &&
  745.                 ((pIcode+2)->ic.ll.opcode == iSBB))
  746.                 switch (type) {
  747.                   case GLOB_VAR:    if (((pIcode+2)->ic.ll.dst.segValue ==
  748.                                         pIcode->ic.ll.dst.segValue) &&
  749.                                         ((pIcode+2)->ic.ll.dst.off ==
  750.                                         pIcode->ic.ll.dst.off))
  751.                                         return (TRUE);
  752.                                     break;
  753.                   case REGISTER:    if ((pIcode+2)->ic.ll.dst.regi ==
  754.                                         pIcode->ic.ll.dst.regi)
  755.                                         return (TRUE);
  756.                                     break;
  757.                   case PARAM:
  758.                   case LOCAL_VAR:   if ((pIcode+2)->ic.ll.dst.off ==
  759.                                         pIcode->ic.ll.dst.off)
  760.                                         return (TRUE);
  761.                                     break;
  762.                 }
  763.         }
  764.     }
  765.     return (FALSE);
  766. }
  767.  
  768.  
  769. /*****************************************************************************
  770.  * idiom 16: Bitwise negation
  771.  *        NEG reg
  772.  *        SBB reg, reg
  773.  *        INC reg
  774.  *        => ASGN reg, !reg
  775.  *        Eg:        NEG ax
  776.  *                SBB ax, ax
  777.  *                INC ax
  778.  *            => ax = !ax
  779.  *        Found in Borland Turbo C when negating bitwise.
  780.  ****************************************************************************/
  781. static boolT idiom16 (PICODE picode, PICODE pend)
  782. { byte regi;
  783.  
  784.     if ((picode+2) < pend)
  785.     {
  786.         regi = picode->ic.ll.dst.regi;
  787.         if ((regi >= rAX) && (regi < INDEXBASE))
  788.         {
  789.             if (((picode+1)->ic.ll.opcode == iSBB) &&
  790.                 ((picode+2)->ic.ll.opcode == iINC))
  791.                 if (((picode+1)->ic.ll.dst.regi == 
  792.                                             ((picode+1)->ic.ll.src.regi)) &&
  793.                     ((picode+1)->ic.ll.dst.regi == regi) &&
  794.                     ((picode+2)->ic.ll.dst.regi == regi))
  795.                     return (TRUE);
  796.         }
  797.     }
  798.     return (FALSE);
  799. }
  800.  
  801.  
  802. /*****************************************************************************
  803.  * idiom 18: Post-increment or post-decrement in a conditional jump
  804.  *        MOV  reg, var (including register variables)
  805.  *        INC     var    or DEC var
  806.  *        CMP  var, Y
  807.  *        JX   label
  808.  *        => HLI_JCOND (var++ X Y)
  809.  *        Eg:        MOV  ax, si
  810.  *                INC  si
  811.  *                CMP  ax, 8
  812.  *                JL   labX
  813.  *            =>  HLI_JCOND (si++ < 8)
  814.  *         Found in Borland Turbo C.  Intrinsic to C languages.
  815.  ****************************************************************************/
  816. static boolT idiom18 (PICODE picode, PICODE pend, PPROC pproc)
  817. { boolT type = 0;    /* type of variable: 1 = reg-var, 2 = local */
  818.   byte regi;        /* register of the MOV */
  819.  
  820.     /* Get variable */
  821.     if (picode->ic.ll.dst.regi == 0)    /* global variable */
  822.         /* not supported yet */ ;
  823.     else if (picode->ic.ll.dst.regi < INDEXBASE)    /* register */
  824.     {
  825.         if ((picode->ic.ll.dst.regi == rSI) && (pproc->flg & SI_REGVAR))
  826.             type = 1;
  827.         else if ((picode->ic.ll.dst.regi == rDI) && (pproc->flg & DI_REGVAR))
  828.             type = 1;
  829.     }
  830.     else if (picode->ic.ll.dst.off)        /* local variable */
  831.         type = 2;
  832.     else        /* indexed */
  833.         /* not supported yet */ ;
  834.  
  835.     /* Check previous instruction for a MOV */
  836.     if (type == 1)            /* register variable */
  837.     {
  838.         if (((picode-1)->ic.ll.opcode == iMOV) &&
  839.             ((picode-1)->ic.ll.src.regi == picode->ic.ll.dst.regi))
  840.         {
  841.             regi = (picode-1)->ic.ll.dst.regi;
  842.             if ((regi > 0) && (regi < INDEXBASE))
  843.             {
  844.                 if ((picode < pend) && ((picode+1) < pend) &&
  845.                     ((picode+1)->ic.ll.opcode == iCMP) &&
  846.                     ((picode+1)->ic.ll.dst.regi == regi) &&
  847.                     (((picode+2)->ic.ll.opcode >= iJB) &&
  848.                      ((picode+2)->ic.ll.opcode < iJCXZ)))
  849.                     return (TRUE);
  850.             }
  851.         }
  852.     }
  853.     else if (type == 2)        /* local */
  854.     {
  855.         if (((picode-1)->ic.ll.opcode == iMOV) && 
  856.             ((picode-1)->ic.ll.src.off == picode->ic.ll.dst.off))
  857.         {
  858.             regi = (picode-1)->ic.ll.dst.regi;
  859.             if ((regi > 0) && (regi < INDEXBASE))
  860.             {
  861.                 if ((picode < pend) && ((picode+1) < pend) &&
  862.                     ((picode+1)->ic.ll.opcode == iCMP) &&
  863.                     ((picode+1)->ic.ll.dst.regi == regi) &&
  864.                     (((picode+2)->ic.ll.opcode >= iJB) && 
  865.                      ((picode+2)->ic.ll.opcode < iJCXZ)))
  866.                     return (TRUE);
  867.             }
  868.         }
  869.     }
  870.     return (FALSE);
  871. }
  872.  
  873.  
  874. /*****************************************************************************
  875.  * idiom 19: pre-increment or pre-decrement in conditional jump, comparing
  876.  *             against 0.
  877.  *        INC var            or DEC var        (including register vars)
  878.  *        JX    lab               JX  lab
  879.  *        =>  HLI_JCOND (++var X 0) or HLI_JCOND (--var X 0)
  880.  *        Eg: INC [bp+4]
  881.  *            JG  lab2
  882.  *            => HLI_JCOND (++[bp+4] > 0)
  883.  *        Found in Borland Turbo C.  Intrinsic to C language.
  884.  ****************************************************************************/
  885. static boolT idiom19 (PICODE picode, PICODE pend, PPROC pproc)
  886. {
  887.     if (picode->ic.ll.dst.regi == 0)    /* global variable */
  888.         /* not supported yet */ ;
  889.     else if (picode->ic.ll.dst.regi < INDEXBASE) /* register */
  890.     {
  891.         if (((picode->ic.ll.dst.regi == rSI) && (pproc->flg & SI_REGVAR)) ||
  892.             ((picode->ic.ll.dst.regi == rDI) && (pproc->flg & DI_REGVAR)))
  893.             if ((picode < pend) && ((picode+1)->ic.ll.opcode >= iJB) && 
  894.                 ((picode+1)->ic.ll.opcode < iJCXZ))
  895.                 return (TRUE);
  896.     }
  897.     else if (picode->ic.ll.dst.off)        /* stack variable */
  898.     {
  899.         if ((picode < pend) && ((picode+1)->ic.ll.opcode >= iJB) && 
  900.             ((picode+1)->ic.ll.opcode < iJCXZ))
  901.             return (TRUE);
  902.     }
  903.     else    /* indexed */
  904.         /* not supported yet */ ;
  905.     return (FALSE);
  906. }
  907.  
  908.  
  909. /*****************************************************************************
  910.  * idiom20: Pre increment/decrement in conditional expression (compares
  911.  *            against a register, variable or constant different than 0).
  912.  *        INC var            or DEC var (including register vars)
  913.  *        MOV reg, var       MOV reg, var
  914.  *        CMP reg, Y           CMP reg, Y
  915.  *        JX  lab               JX  lab
  916.  *        => HLI_JCOND (++var X Y) or HLI_JCOND (--var X Y)
  917.  *        Eg: INC si    (si is a register variable)
  918.  *            MOV ax, si
  919.  *            CMP ax, 2
  920.  *            JL    lab4
  921.  *            => HLI_JCOND (++si < 2)
  922.  *        Found in Turbo C.  Intrinsic to C language.
  923.  ****************************************************************************/
  924. static boolT idiom20 (PICODE picode, PICODE pend, PPROC pproc)
  925. { boolT type = 0;    /* type of variable: 1 = reg-var, 2 = local */
  926.   byte regi;        /* register of the MOV */
  927.  
  928.     /* Get variable */
  929.     if (picode->ic.ll.dst.regi == 0)    /* global variable */
  930.         /* not supported yet */ ;
  931.     else if (picode->ic.ll.dst.regi < INDEXBASE)    /* register */
  932.     {
  933.         if ((picode->ic.ll.dst.regi == rSI) && (pproc->flg & SI_REGVAR))
  934.             type = 1;
  935.         else if ((picode->ic.ll.dst.regi == rDI) && (pproc->flg & DI_REGVAR))
  936.             type = 1;
  937.     }
  938.     else if (picode->ic.ll.dst.off)        /* local variable */
  939.         type = 2;
  940.     else        /* indexed */
  941.         /* not supported yet */ ;
  942.  
  943.     /* Check previous instruction for a MOV */
  944.     if (type == 1)            /* register variable */
  945.     {
  946.         if ((picode < pend) && ((picode+1)->ic.ll.opcode == iMOV) && 
  947.             ((picode+1)->ic.ll.src.regi == picode->ic.ll.dst.regi))
  948.         {
  949.             regi = (picode+1)->ic.ll.dst.regi;
  950.             if ((regi > 0) && (regi < INDEXBASE))
  951.             {
  952.                 if (((picode+1) < pend) && ((picode+2) < pend) &&
  953.                     ((picode+2)->ic.ll.opcode == iCMP) &&
  954.                     ((picode+2)->ic.ll.dst.regi == regi) &&
  955.                     (((picode+3)->ic.ll.opcode >= iJB) && 
  956.                      ((picode+3)->ic.ll.opcode < iJCXZ)))
  957.                     return (TRUE);
  958.             }
  959.         }
  960.     }
  961.     else if (type == 2)        /* local */
  962.     {
  963.         if ((picode < pend) && ((picode+1)->ic.ll.opcode == iMOV) && 
  964.             ((picode+1)->ic.ll.src.off == picode->ic.ll.dst.off))
  965.         {
  966.             regi = (picode+1)->ic.ll.dst.regi;
  967.             if ((regi > 0) && (regi < INDEXBASE))
  968.             {
  969.                 if (((picode+1) < pend) && ((picode+2) < pend) &&
  970.                     ((picode+2)->ic.ll.opcode == iCMP) &&
  971.                     ((picode+2)->ic.ll.dst.regi == regi) &&
  972.                     (((picode+3)->ic.ll.opcode >= iJB) && 
  973.                      ((picode+3)->ic.ll.opcode < iJCXZ)))
  974.                     return (TRUE);
  975.             }
  976.         }
  977.     }
  978.     return (FALSE);
  979. }
  980.  
  981.  
  982. /*****************************************************************************
  983.  * findIdioms  - translates LOW_LEVEL icode idioms into HIGH_LEVEL icodes.
  984.  ****************************************************************************/
  985. void findIdioms (PPROC pProc)
  986. {   Int     ip;             /* Index to current icode                   */
  987.     PICODE  pEnd, pIcode;   /* Pointers to end of BB and current icodes */
  988.     int16   delta;
  989.     COND_EXPR *rhs, *lhs;   /* Pointers to left and right hand side exps */
  990.     COND_EXPR *exp;         /* Pointer to temporal expression           */
  991.     Int     idx;            /* Index into local identifier table        */
  992.     byte    regH, regL;     /* High and low registers for long word reg */
  993.  
  994.     pIcode = pProc->Icode.GetFirstIcode();
  995.     pEnd = pIcode + pProc->Icode.GetNumIcodes();
  996.     ip = 0;
  997.  
  998.     while (pIcode < pEnd)
  999.     {
  1000.         switch (pIcode->ic.ll.opcode) {
  1001.         case iDEC: case iINC:
  1002.             if (idiom18 (pIcode, pEnd, pProc))
  1003.             {
  1004.                 lhs = idCondExp (pIcode-1, SRC, pProc, ip, pIcode, E_USE);
  1005.                 if (pIcode->ic.ll.opcode == iDEC)
  1006.                     lhs = unaryCondExp (POST_DEC, lhs);
  1007.                 else
  1008.                     lhs = unaryCondExp (POST_INC, lhs);
  1009.                 rhs = idCondExp (pIcode+1, SRC, pProc, ip, pIcode+2, E_USE);
  1010.                 exp = boolCondExp (lhs, rhs,
  1011.                                    condOpJCond[(pIcode+2)->ic.ll.opcode - iJB]);
  1012.                 newJCondHlIcode (pIcode+2, exp);
  1013.                 invalidateIcode (pIcode-1);
  1014.                 invalidateIcode (pIcode);
  1015.                 invalidateIcode (pIcode+1);
  1016.                 pIcode += 3;
  1017.                 ip += 2;
  1018.             }
  1019.             else if (idiom19 (pIcode, pEnd, pProc))
  1020.             {
  1021.                 lhs = idCondExp (pIcode, DST, pProc, ip, pIcode+1, E_USE);
  1022.                 if (pIcode->ic.ll.opcode == iDEC)
  1023.                     lhs = unaryCondExp (PRE_DEC, lhs);
  1024.                 else
  1025.                     lhs = unaryCondExp (PRE_INC, lhs);
  1026.                 rhs = idCondExpKte (0, 2);
  1027.                 exp = boolCondExp (lhs, rhs,
  1028.                                    condOpJCond[(pIcode+1)->ic.ll.opcode - iJB]);
  1029.                 newJCondHlIcode (pIcode+1, exp);
  1030.                 invalidateIcode (pIcode);
  1031.                 pIcode += 2;
  1032.                 ip++;
  1033.             }
  1034.             else if (idiom20 (pIcode, pEnd, pProc))
  1035.             {
  1036.                 lhs = idCondExp (pIcode+1, SRC, pProc, ip, pIcode, E_USE);
  1037.                 if (pIcode->ic.ll.opcode == iDEC)
  1038.                     lhs = unaryCondExp (PRE_DEC, lhs);
  1039.                 else
  1040.                     lhs = unaryCondExp (PRE_INC, lhs);
  1041.                 rhs = idCondExp (pIcode+2, SRC, pProc, ip, pIcode+3, E_USE);
  1042.                 exp = boolCondExp (lhs, rhs,
  1043.                                    condOpJCond[(pIcode+3)->ic.ll.opcode - iJB]);
  1044.                 newJCondHlIcode (pIcode+3, exp);
  1045.                 invalidateIcode (pIcode);
  1046.                 invalidateIcode (pIcode+1);
  1047.                 invalidateIcode (pIcode+2);
  1048.                 pIcode += 3;
  1049.                 ip += 2;
  1050.             }
  1051.             else
  1052.                 pIcode++;
  1053.             break;
  1054.  
  1055.         case iPUSH:             /* Idiom 1 */
  1056.             if ((! (pProc->flg & PROC_HLL)) && 
  1057.                 (idx = idiom1 (pIcode, pEnd, pProc)))
  1058.             {
  1059.                 pProc->flg |= PROC_HLL;
  1060.                 for ( ; idx > 0; idx--)
  1061.                 {
  1062.                     invalidateIcode (pIcode++);
  1063.                     ip++;
  1064.                 }
  1065.                 ip--;
  1066.             }
  1067.             else
  1068.                 pIcode++;
  1069.             break;
  1070.  
  1071.         case iMOV:              /* Idiom 2 */
  1072.             if (idx = idiom2(pIcode, pEnd, ip, pProc))
  1073.             {
  1074.                 invalidateIcode (pIcode);
  1075.                 invalidateIcode (pIcode+1);
  1076.                 pIcode += 3;
  1077.                 ip += 2;
  1078.             }
  1079.             else if (idiom14 (pIcode, pEnd, ®L, ®H))  /* Idiom 14 */ 
  1080.             {
  1081.                 idx = newLongRegId (&pProc->localId, TYPE_LONG_SIGN,
  1082.                                      regH, regL, ip);
  1083.                 lhs = idCondExpLongIdx (idx);
  1084.                 setRegDU (pIcode, regH, E_DEF);
  1085.                 rhs = idCondExp (pIcode, SRC, pProc, ip, pIcode, NONE);
  1086.                 newAsgnHlIcode (pIcode, lhs, rhs);
  1087.                 invalidateIcode (pIcode+1);
  1088.                 pIcode += 2;
  1089.                 ip++;
  1090.             }
  1091.             else if (idx = idiom13 (pIcode, pEnd))      /* Idiom 13 */ 
  1092.             {
  1093.                 lhs = idCondExpReg (idx, 0, &pProc->localId);
  1094.                 setRegDU (pIcode, idx, E_DEF);
  1095.                 pIcode->du1.numRegsDef--;       /* prev byte reg def */
  1096.                 rhs = idCondExp (pIcode, SRC, pProc, ip, pIcode, NONE);
  1097.                 newAsgnHlIcode (pIcode, lhs, rhs);
  1098.                 invalidateIcode (pIcode+1);
  1099.                 pIcode += 2;
  1100.                 ip++;
  1101.             } 
  1102.             else
  1103.                 pIcode++;
  1104.             break;
  1105.  
  1106.         case iCALL:  case iCALLF:
  1107.             /* Check for library functions that return a long register.
  1108.              * Propagate this result */
  1109.     if (pIcode->ic.ll.immed.proc.proc != 0)
  1110.             if ((pIcode->ic.ll.immed.proc.proc->flg & PROC_ISLIB) &&
  1111.                 (pIcode->ic.ll.immed.proc.proc->flg & PROC_IS_FUNC))
  1112.             {
  1113.                if ((pIcode->ic.ll.immed.proc.proc->retVal.type==TYPE_LONG_SIGN)    
  1114.                   || (pIcode->ic.ll.immed.proc.proc->retVal.type ==
  1115.                                                               TYPE_LONG_UNSIGN))
  1116.                     newLongRegId(&pProc->localId, TYPE_LONG_SIGN, rDX, rAX, ip);
  1117.             }
  1118.  
  1119.             /* Check for idioms */
  1120.             if (idx = idiom3(pIcode, pEnd))         /* idiom 3 */
  1121.             {
  1122.                 if (pIcode->ic.ll.flg & I) 
  1123.                 {
  1124.                     (pIcode->ic.ll.immed.proc.proc)->cbParam = (int16)idx;
  1125.                     pIcode->ic.ll.immed.proc.cb = idx;
  1126.                     (pIcode->ic.ll.immed.proc.proc)->flg |= CALL_C;
  1127.                     pIcode++;
  1128.                     invalidateIcode (pIcode++);
  1129.                     ip++;
  1130.                 }
  1131.             }
  1132.             else if (idx = idiom17 (pIcode, pEnd))  /* idiom 17 */
  1133.             {
  1134.                 if (pIcode->ic.ll.flg & I)
  1135.                 {
  1136.                     (pIcode->ic.ll.immed.proc.proc)->cbParam = (int16)idx;
  1137.                     pIcode->ic.ll.immed.proc.cb = idx;
  1138.                     (pIcode->ic.ll.immed.proc.proc)->flg |= CALL_C;
  1139.                     ip += idx/2 - 1;
  1140.                     pIcode++;
  1141.                     for (idx /= 2; idx > 0; idx--)
  1142.                         invalidateIcode (pIcode++);
  1143.                 }
  1144.             }
  1145.             else
  1146.                 pIcode++;
  1147.             break;
  1148.  
  1149.         case iRET:          /* Idiom 4 */   
  1150.         case iRETF:
  1151.             idiom4 (pIcode, pEnd, pProc);
  1152.             pIcode++;
  1153.             break;
  1154.  
  1155.         case iADD:          /* Idiom 5 */
  1156.             if (idiom5 (pIcode, pEnd))
  1157.             {
  1158.                 lhs = idCondExpLong (&pProc->localId, DST, pIcode, LOW_FIRST, 
  1159.                                      ip, USE_DEF, 1); 
  1160.                 rhs = idCondExpLong (&pProc->localId, SRC, pIcode, LOW_FIRST, 
  1161.                                      ip, E_USE, 1);
  1162.                 exp = boolCondExp (lhs, rhs, ADD);
  1163.                 newAsgnHlIcode (pIcode, lhs, exp);
  1164.                 invalidateIcode (pIcode + 1);
  1165.                 pIcode++;
  1166.                 ip++;
  1167.             }
  1168.             pIcode++;
  1169.             break;
  1170.  
  1171.         case iSAR:          /* Idiom 8 */
  1172.             if (idiom8 (pIcode, pEnd))
  1173.             {
  1174.                 idx = newLongRegId (&pProc->localId, TYPE_LONG_SIGN,
  1175.                         pIcode->ic.ll.dst.regi, (pIcode+1)->ic.ll.dst.regi,ip);
  1176.                 lhs = idCondExpLongIdx (idx);
  1177.                 setRegDU (pIcode, (pIcode+1)->ic.ll.dst.regi, USE_DEF);
  1178.                 rhs = idCondExpKte (1, 2);
  1179.                 exp = boolCondExp (lhs, rhs, SHR);
  1180.                 newAsgnHlIcode (pIcode, lhs, exp);
  1181.                 invalidateIcode (pIcode + 1);
  1182.                 pIcode++;
  1183.                 ip++;
  1184.             }
  1185.             pIcode++;
  1186.             break;
  1187.  
  1188.         case iSHL:
  1189.             if (idx = idiom15 (pIcode, pEnd))       /* idiom 15 */
  1190.             {
  1191.                 lhs = idCondExpReg (pIcode->ic.ll.dst.regi, 
  1192.                                     pIcode->ic.ll.flg & NO_SRC_B,
  1193.                                     &pProc->localId);
  1194.                 rhs = idCondExpKte (idx, 2);
  1195.                 exp = boolCondExp (lhs, rhs, SHL);
  1196.                 newAsgnHlIcode (pIcode, lhs, exp);
  1197.                 pIcode++;
  1198.                 for (idx-- ; idx > 0; idx--)
  1199.                 {
  1200.                     invalidateIcode (pIcode++);
  1201.                     ip++;
  1202.                 }
  1203.             }
  1204.             else if (idiom12 (pIcode, pEnd))        /* idiom 12 */
  1205.             {
  1206.                 idx = newLongRegId (&pProc->localId, TYPE_LONG_UNSIGN,
  1207.                         (pIcode+1)->ic.ll.dst.regi, pIcode->ic.ll.dst.regi,ip);
  1208.                 lhs = idCondExpLongIdx (idx);
  1209.                 setRegDU (pIcode, (pIcode+1)->ic.ll.dst.regi, USE_DEF);
  1210.                 rhs = idCondExpKte (1, 2);
  1211.                 exp = boolCondExp (lhs, rhs, SHL);
  1212.                 newAsgnHlIcode (pIcode, lhs, exp);
  1213.                 invalidateIcode (pIcode + 1);
  1214.                 pIcode += 2;
  1215.                 ip++;
  1216.             }
  1217.             else
  1218.                 pIcode++;
  1219.             break;
  1220.  
  1221.         case iSHR:          /* Idiom 9 */
  1222.             if (idiom9 (pIcode, pEnd))
  1223.             {
  1224.                 idx = newLongRegId (&pProc->localId, TYPE_LONG_UNSIGN,
  1225.                         pIcode->ic.ll.dst.regi, (pIcode+1)->ic.ll.dst.regi,ip);
  1226.                 lhs = idCondExpLongIdx (idx);
  1227.                 setRegDU (pIcode, (pIcode+1)->ic.ll.dst.regi, USE_DEF);
  1228.                 rhs = idCondExpKte (1, 2);
  1229.                 exp = boolCondExp (lhs, rhs, SHR);
  1230.                 newAsgnHlIcode (pIcode, lhs, exp);
  1231.                 invalidateIcode (pIcode + 1);
  1232.                 pIcode++;
  1233.                 ip++;
  1234.             }
  1235.             pIcode++;
  1236.             break;
  1237.  
  1238.         case iSUB:          /* Idiom 6 */
  1239.             if (idiom6 (pIcode, pEnd))
  1240.             {
  1241.                 lhs = idCondExpLong (&pProc->localId, DST, pIcode, LOW_FIRST, 
  1242.                                      ip, USE_DEF, 1);
  1243.                 rhs = idCondExpLong (&pProc->localId, SRC, pIcode, LOW_FIRST, 
  1244.                                      ip, E_USE, 1);
  1245.                 exp = boolCondExp (lhs, rhs, SUB);
  1246.                 newAsgnHlIcode (pIcode, lhs, exp);
  1247.                 invalidateIcode (pIcode + 1);
  1248.                 pIcode++;
  1249.                 ip++;
  1250.             }
  1251.             pIcode++;
  1252.             break;
  1253.  
  1254.         case iOR:           /* Idiom 10 */
  1255.             idiom10 (pIcode, pEnd);
  1256.             pIcode++;
  1257.             break;
  1258.  
  1259.         case iNEG:          /* Idiom 11 */
  1260.             if (idiom11 (pIcode, pEnd))
  1261.             {
  1262.                 lhs = idCondExpLong (&pProc->localId, DST, pIcode, HIGH_FIRST, 
  1263.                                      ip, USE_DEF, 1);
  1264.                 rhs = unaryCondExp (NEGATION, lhs);
  1265.                 newAsgnHlIcode (pIcode, lhs, rhs);
  1266.                 invalidateIcode (pIcode+1);
  1267.                 invalidateIcode (pIcode+2);
  1268.                 pIcode += 3;
  1269.                 ip += 2;
  1270.             }
  1271.             else if (idiom16 (pIcode, pEnd))
  1272.             {
  1273.                 lhs = idCondExpReg (pIcode->ic.ll.dst.regi, pIcode->ic.ll.flg,
  1274.                                     &pProc->localId);
  1275.                 rhs = copyCondExp (lhs);
  1276.                 rhs = unaryCondExp (NEGATION, lhs);
  1277.                 newAsgnHlIcode (pIcode, lhs, rhs);
  1278.                 invalidateIcode (pIcode+1);
  1279.                 invalidateIcode (pIcode+2);
  1280.                 pIcode += 3;
  1281.                 ip += 2;
  1282.             }
  1283.             else
  1284.                 pIcode++;
  1285.             break;
  1286.  
  1287.         case iNOP:
  1288.             invalidateIcode (pIcode++);
  1289.             break;
  1290.  
  1291.         case iENTER:        /* ENTER is equivalent to init PUSH bp */
  1292.             if (ip == 0)
  1293.                 pProc->flg |= (PROC_HLL | PROC_IS_HLL);
  1294.             pIcode++;
  1295.             break;
  1296.  
  1297.         case iXOR:          /* Idiom 7 */
  1298.             if (idiom21 (pIcode, pEnd))
  1299.             {
  1300.                 lhs = idCondExpLong (&pProc->localId, DST, pIcode,
  1301.                                      HIGH_FIRST, ip, E_DEF, 1);
  1302.                 rhs = idCondExpKte ((pIcode+1)->ic.ll.immed.op , 4);
  1303.                 newAsgnHlIcode (pIcode, lhs, rhs);
  1304.                 pIcode->du.use = 0;        /* clear register used in iXOR */
  1305.                 invalidateIcode (pIcode+1);
  1306.                 pIcode++;
  1307.                 ip++;
  1308.             }
  1309.             else if (idiom7 (pIcode))
  1310.             {
  1311.                 lhs = idCondExp (pIcode, DST, pProc, ip, pIcode, NONE);
  1312.                 rhs = idCondExpKte (0, 2);
  1313.                 newAsgnHlIcode (pIcode, lhs, rhs);
  1314.                 pIcode->du.use = 0;    /* clear register used in iXOR */
  1315.                 pIcode->ic.ll.flg |= I;
  1316.             } 
  1317.             pIcode++;
  1318.             break;
  1319.  
  1320.         default:
  1321.             pIcode++;
  1322.         }
  1323.         ip++;
  1324.     }
  1325.  
  1326.     /* Check if number of parameter bytes match their calling convention */
  1327.     if ((pProc->flg & PROC_HLL) && (pProc->args.csym)) 
  1328.     {
  1329.         pProc->args.minOff += (pProc->flg & PROC_FAR ? 4 : 2);
  1330.         delta = pProc->args.maxOff - pProc->args.minOff;
  1331.         if (pProc->cbParam != delta) 
  1332.         {
  1333.             pProc->cbParam = delta;
  1334.             pProc->flg |= (CALL_MASK & CALL_UNKNOWN);
  1335.         }
  1336.     } 
  1337. }
  1338.  
  1339.  
  1340. void bindIcodeOff (PPROC pProc)
  1341. /* Sets up the TARGET flag for jump target addresses, and
  1342.  * binds jump target addresses to icode offsets.    */
  1343. { Int i, j;                 /* idx into icode array */
  1344.   PICODE pIcode;            /* ptr icode array      */
  1345.   dword *p;                 /* for case table       */
  1346.  
  1347.     if (! pProc->Icode.GetNumIcodes())        /* No Icode */
  1348.         return;             
  1349.     pIcode = pProc->Icode.GetFirstIcode();
  1350.  
  1351.     /* Flag all jump targets for BB construction and disassembly stage 2 */
  1352.     for (i = 0; i < pProc->Icode.GetNumIcodes(); i++)
  1353.         if ((pIcode[i].ic.ll.flg & I) && JmpInst(pIcode[i].ic.ll.opcode))
  1354.         {
  1355.             if (pProc->Icode.labelSrch(pIcode[i].ic.ll.immed.op, &j))
  1356.             {
  1357.                 pIcode[j].ic.ll.flg |= TARGET;
  1358.             }
  1359.         }
  1360.  
  1361.     /* Finally bind jump targets to Icode offsets.  Jumps for which no label
  1362.      * is found (no code at dest. of jump) are simply left unlinked and 
  1363.      * flagged as going nowhere.  */
  1364.     pIcode = pProc->Icode.GetFirstIcode();
  1365.     for (i = 0; i < pProc->Icode.GetNumIcodes(); i++)
  1366.         if (JmpInst(pIcode[i].ic.ll.opcode))
  1367.         {
  1368.             if (pIcode[i].ic.ll.flg & I)
  1369.             {
  1370.                 if (! pProc->Icode.labelSrch(pIcode[i].ic.ll.immed.op, 
  1371.                                 (Int *)&pIcode[i].ic.ll.immed.op))
  1372.                     pIcode[i].ic.ll.flg |= NO_LABEL;
  1373.             }
  1374.             else if (pIcode[i].ic.ll.flg & SWITCH)
  1375.             {
  1376.                 p = pIcode[i].ic.ll.caseTbl.entries;
  1377.                 for (j = 0; j < pIcode[i].ic.ll.caseTbl.numEntries; j++, p++)
  1378.                     pProc->Icode.labelSrch(*p, (Int *)p);
  1379.             }
  1380.         }
  1381. }
  1382.  
  1383.  
  1384. void lowLevelAnalysis (PPROC pProc)
  1385. /* Performs idioms analysis, and propagates long operands, if any */
  1386. {
  1387.     /* Idiom analysis - sets up some flags and creates some HIGH_LEVEL
  1388.      * icodes */
  1389.     findIdioms (pProc); 
  1390.  
  1391.     /* Propagate HIGH_LEVEL idiom information for long operands */
  1392.     propLong (pProc);
  1393. }
  1394.