home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / dosdisas.zip / dccsrcoo.zip / proplong.cpp < prev    next >
C/C++ Source or Header  |  1997-04-09  |  18KB  |  572 lines
  1. /**************************************************************************
  2.  *$Log:    proplong.c,v $
  3.  * Revision 1.1  94/03/14  08:42:56  cifuente
  4.  * Initial revision
  5.  * 
  6.  * File : propLong.c
  7.  * Purpose: propagate the value of long variables (local variables and
  8.  *          registers) along the graph.  Structure the graph in this way.
  9.  *
  10.  **************************************************************************/
  11.  
  12. #include "dcc.h"
  13. #include "string.h"
  14. #ifdef __BORLAND__
  15. #include <mem.h>
  16. #else
  17. #include <memory.h>
  18. #endif
  19.  
  20.  
  21. static boolT isJCond (llIcode opcode)
  22. /* Returns whether the given icode opcode is within the range of valid
  23.  * high-level conditional jump icodes (iJB..iJG) */
  24. {
  25.     if ((opcode >= iJB) && (opcode <= iJG))
  26.         return (TRUE);
  27.     return (FALSE);
  28. }
  29.  
  30.  
  31. static boolT isLong23 (Int i, PBB pbb, PICODE icode, Int *off, Int *arc)
  32. /* Returns whether the conditions for a 2-3 long variable are satisfied */
  33. { PBB t, e, obb2;
  34.  
  35.     if (pbb->nodeType != TWO_BRANCH)
  36.         return (FALSE);
  37.     t = pbb->edges[THEN].BBptr;
  38.     e = pbb->edges[ELSE].BBptr;
  39.  
  40.     /* Check along the THEN path */
  41.     if ((t->length == 1) && (t->nodeType == TWO_BRANCH) && (t->numInEdges == 1))
  42.     {
  43.         obb2 = t->edges[THEN].BBptr;
  44.         if ((obb2->length == 2) && (obb2->nodeType == TWO_BRANCH) &&
  45.             (icode[obb2->start].ic.ll.opcode == iCMP))
  46.         {
  47.             *off = obb2->start - i;
  48.             *arc = THEN;
  49.             return (TRUE);
  50.         }
  51.     }
  52.  
  53.     /* Check along the ELSE path  */
  54.     else if ((e->length == 1) && (e->nodeType == TWO_BRANCH) && 
  55.              (e->numInEdges == 1))
  56.     {
  57.         obb2 = e->edges[THEN].BBptr;
  58.         if ((obb2->length == 2) && (obb2->nodeType == TWO_BRANCH) &&
  59.             (icode[obb2->start].ic.ll.opcode == iCMP))
  60.         {
  61.             *off = obb2->start - i;
  62.             *arc = ELSE;
  63.             return (TRUE);
  64.         }
  65.     }
  66.     return (FALSE);
  67. }
  68.  
  69.  
  70. static boolT isLong22 (PICODE pIcode, PICODE pEnd, Int *off)
  71. /* Returns whether the conditions for a 2-2 long variable are satisfied */
  72. {
  73.     if (((pIcode+2) < pEnd) && ((pIcode+2)->ic.ll.opcode == iCMP) &&
  74.         (isJCond ((pIcode+1)->ic.ll.opcode)) &&
  75.         (isJCond ((pIcode+3)->ic.ll.opcode)))
  76.     {
  77.         *off = 2;
  78.         return (TRUE);
  79.     }
  80.     return (FALSE);
  81. }
  82.  
  83.  
  84. static void longJCond23 (COND_EXPR *rhs, COND_EXPR *lhs, PICODE pIcode, 
  85.                          Int *idx, PPROC pProc, Int arc, Int off)
  86. /* Creates a long conditional <=, >=, <, or > at (pIcode+1).
  87.  * Removes excess nodes from the graph by flagging them, and updates
  88.  * the new edges for the remaining nodes.    */
  89. { Int j;
  90.   PBB pbb, obb1, obb2, tbb;
  91.  
  92.     if (arc == THEN)
  93.       {
  94.         /* Find intermediate basic blocks and target block */
  95.         pbb = pIcode->inBB;
  96.         obb1 = pbb->edges[THEN].BBptr;
  97.         obb2 = obb1->edges[THEN].BBptr;
  98.         tbb = obb2->edges[THEN].BBptr;
  99.  
  100.         /* Modify out edge of header basic block */
  101.         pbb->edges[THEN].BBptr = tbb;
  102.  
  103.         /* Modify in edges of target basic block */
  104.         for (j = 0; j < (tbb->numInEdges-1); j++)
  105.         {
  106.             if ((tbb->inEdges[j] == obb1) || (tbb->inEdges[j] == obb2))
  107.             {
  108.                 memmove (&tbb->inEdges[j], &tbb->inEdges[j+1],
  109.                          (tbb->numInEdges - j-1) * sizeof(PBB));
  110.                 memset (&tbb->inEdges[tbb->numInEdges-1], ' ',sizeof (PBB));
  111.                 j--;
  112.             }
  113.         }
  114.         tbb->numInEdges--;    /* looses 2 arcs, gains 1 arc */
  115.         tbb->inEdges[tbb->numInEdges-1] = pbb;
  116.  
  117.         /* Modify in edges of the ELSE basic block */
  118.         tbb = pbb->edges[ELSE].BBptr;
  119.         for (j = 0; j < (tbb->numInEdges-1); j++)
  120.         {
  121.             if (tbb->inEdges[j] == obb2)
  122.             {
  123.                 memmove (&tbb->inEdges[j], &tbb->inEdges[j+1],
  124.                          (tbb->numInEdges - j-1) * sizeof(PBB));
  125.                 break;
  126.             }
  127.         }
  128.         tbb->numInEdges--;    /* looses 1 arc */
  129.  
  130.         /* Update icode index */
  131.         (*idx) += 5; 
  132.       }
  133.  
  134.       else  /* ELSE arc */
  135.       {
  136.         /* Find intermediate basic blocks and target block */
  137.         pbb = pIcode->inBB;
  138.         obb1 = pbb->edges[ELSE].BBptr;
  139.         obb2 = obb1->edges[THEN].BBptr;
  140.         tbb = obb2->edges[THEN].BBptr;
  141.  
  142.         /* Modify in edges of target basic block */
  143.         for (j = 0; j < (tbb->numInEdges-1); j++)
  144.         {
  145.             if (tbb->inEdges[j] == obb2)
  146.             {
  147.                 memmove (&tbb->inEdges[j], &tbb->inEdges[j+1],
  148.                          (tbb->numInEdges - j-1) * sizeof(PBB));
  149.                 break;    
  150.             }
  151.         }
  152.         tbb->numInEdges--;    /* looses 1 arc */
  153.  
  154.         /* Modify in edges of the ELSE basic block */
  155.         tbb = obb2->edges[ELSE].BBptr;
  156.         for (j = 0; j < (tbb->numInEdges-1); j++)
  157.         {
  158.             if ((tbb->inEdges[j] == obb2) || (tbb->inEdges[j] == obb1))
  159.             {
  160.                 memmove (&tbb->inEdges[j], &tbb->inEdges[j+1],
  161.                          (tbb->numInEdges - j-1) * sizeof(PBB));
  162.                 memset (&tbb->inEdges[tbb->numInEdges-1], ' ',sizeof (PBB));
  163.                 j--;
  164.             }
  165.         }
  166.         tbb->numInEdges--;    /* looses 2 arcs, gains 1 arc */
  167.         tbb->inEdges[tbb->numInEdges - 1] = pbb;
  168.  
  169.         /* Modify out edge of header basic block */
  170.         pbb->edges[ELSE].BBptr = tbb;
  171.  
  172.         /* Update icode index */
  173.         (*idx) += 2; 
  174.       }
  175.  
  176.     /* Create new HLI_JCOND and condition */
  177.     lhs = boolCondExp (lhs, rhs, condOpJCond[(pIcode+off+1)->ic.ll.opcode-iJB]);
  178.     newJCondHlIcode (pIcode+1, lhs);
  179.     copyDU (pIcode+1, pIcode, E_USE, E_USE);
  180.     (pIcode+1)->du.use |= (pIcode+off)->du.use;
  181.  
  182.     /* Update statistics */
  183.     obb1->flg |= INVALID_BB;
  184.     obb2->flg |= INVALID_BB;
  185.     stats.numBBaft -= 2;
  186.  
  187.     invalidateIcode (pIcode);
  188.     invalidateIcode (pProc->Icode.GetIcode(obb1->start));
  189.     invalidateIcode (pProc->Icode.GetIcode(obb2->start));
  190.     invalidateIcode (pProc->Icode.GetIcode(obb2->start+1));
  191. }
  192.  
  193.  
  194. static void longJCond22 (COND_EXPR *rhs, COND_EXPR *lhs, PICODE pIcode,
  195.                          Int *idx)
  196. /* Creates a long conditional equality or inequality at (pIcode+1).
  197.  * Removes excess nodes from the graph by flagging them, and updates
  198.  * the new edges for the remaining nodes.    */
  199. { Int j;
  200.   PBB pbb, obb1, tbb;
  201.  
  202.     /* Form conditional expression */
  203.     lhs = boolCondExp (lhs, rhs, condOpJCond[(pIcode+3)->ic.ll.opcode - iJB]);
  204.     newJCondHlIcode (pIcode+1, lhs);
  205.     copyDU (pIcode+1, pIcode, E_USE, E_USE);
  206.     (pIcode+1)->du.use |= (pIcode+2)->du.use;
  207.  
  208.     /* Adjust outEdges[0] to the new target basic block */ 
  209.     pbb = pIcode->inBB;
  210.     if ((pbb->start + pbb->length - 1) == (*idx + 1))
  211.     {
  212.         /* Find intermediate and target basic blocks */
  213.         obb1 = pbb->edges[THEN].BBptr;
  214.         tbb = obb1->edges[THEN].BBptr;
  215.  
  216.         /* Modify THEN out edge of header basic block */
  217.         pbb->edges[THEN].BBptr = tbb;
  218.  
  219.         /* Modify in edges of target basic block */
  220.         for (j = 0; j < (tbb->numInEdges-1); j++)
  221.         {
  222.             if (tbb->inEdges[j] == obb1)
  223.             {
  224.                 memmove (&tbb->inEdges[j], &tbb->inEdges[j+1],
  225.                         (tbb->numInEdges - j-1) * sizeof(PBB));
  226.                 break;
  227.             }
  228.         }
  229.         if ((pIcode+3)->ic.ll.opcode == iJE)
  230.             tbb->numInEdges--;    /* looses 1 arc */
  231.         else                    /* iJNE => replace arc */
  232.             tbb->inEdges[tbb->numInEdges-1] = pbb;
  233.  
  234.         /* Modify ELSE out edge of header basic block */
  235.         tbb = obb1->edges[ELSE].BBptr;
  236.         pbb->edges[ELSE].BBptr = tbb;
  237.  
  238.         /* Modify in edges of the ELSE basic block */
  239.         for (j = 0; j < (tbb->numInEdges-1); j++)
  240.         {
  241.             if (tbb->inEdges[j] == obb1)
  242.             {
  243.                 memmove (&tbb->inEdges[j], &tbb->inEdges[j+1],
  244.                         (tbb->numInEdges - j-1) * sizeof(PBB));
  245.                 break;
  246.             }
  247.         }
  248.         if ((pIcode+3)->ic.ll.opcode == iJE)    /* replace */
  249.             tbb->inEdges[tbb->numInEdges-1] = pbb;    
  250.         else
  251.             tbb->numInEdges--;        /* iJNE => looses 1 arc */
  252.  
  253.  
  254.         /* Update statistics */
  255.         obb1->flg |= INVALID_BB;
  256.         stats.numBBaft--;
  257.     }
  258.  
  259.     invalidateIcode (pIcode);
  260.     invalidateIcode (pIcode+2);
  261.     invalidateIcode (pIcode+3);
  262.     (*idx) += 4;
  263. }
  264.  
  265.  
  266. static void propLongStk (Int i, ID *pLocId, PPROC pProc)
  267. /* Propagates TYPE_LONG_(UN)SIGN icode information to the current pIcode
  268.  * Pointer.
  269.  * Arguments: i     : index into the local identifier table
  270.  *            pLocId: ptr to the long local identifier 
  271.  *            pProc : ptr to current procedure's record.        */
  272. { Int idx, off, arc;
  273.   COND_EXPR *lhs, *rhs;     /* Pointers to left and right hand expression */
  274.   PICODE pIcode, pEnd;
  275.  
  276.     /* Check all icodes for offHi:offLo */
  277.     pEnd = pProc->Icode.GetIcode(pProc->Icode.GetNumIcodes() -1);
  278.     for (idx = 0; idx < (pProc->Icode.GetNumIcodes() - 1); idx++)
  279.     {
  280.         pIcode = pProc->Icode.GetIcode(idx);
  281.         if ((pIcode->type == HIGH_LEVEL) || (pIcode->invalid == TRUE))
  282.             continue;
  283.  
  284.         if (pIcode->ic.ll.opcode == (pIcode+1)->ic.ll.opcode)
  285.         {
  286.             switch (pIcode->ic.ll.opcode) {
  287.               case iMOV:
  288.                 if (checkLongEq (pLocId->id.longStkId, pIcode, i, idx, pProc, 
  289.                              &rhs, &lhs, 1) == TRUE)
  290.                 {
  291.                     newAsgnHlIcode (pIcode, lhs, rhs);
  292.                     invalidateIcode (pIcode + 1);
  293.                     idx++;
  294.                 }
  295.                 break;
  296.  
  297.               case iAND: case iOR: case iXOR:
  298.                 if (checkLongEq (pLocId->id.longStkId, pIcode, i, idx, pProc, 
  299.                              &rhs, &lhs, 1) == TRUE)
  300.                 {
  301.                     switch (pIcode->ic.ll.opcode) {
  302.                       case iAND:     rhs = boolCondExp (lhs, rhs, AND);
  303.                                 break;
  304.                       case iOR:     rhs = boolCondExp (lhs, rhs, OR);
  305.                                 break;
  306.                       case iXOR:     rhs = boolCondExp (lhs, rhs, XOR);
  307.                                 break;
  308.                     }
  309.                     newAsgnHlIcode (pIcode, lhs, rhs);
  310.                     invalidateIcode (pIcode + 1);
  311.                     idx++;
  312.                 }
  313.                 break;
  314.  
  315.               case iPUSH:
  316.                 if (checkLongEq (pLocId->id.longStkId, pIcode, i, idx, pProc,
  317.                              &rhs, &lhs, 1) == TRUE)
  318.                 {
  319.                     newUnaryHlIcode (pIcode, HLI_PUSH, lhs);
  320.                     invalidateIcode (pIcode + 1);
  321.                     idx++;
  322.                 }
  323.                 break;
  324.             } /*eos*/
  325.         }
  326.  
  327.         /* Check long conditional (i.e. 2 CMPs and 3 branches */ 
  328.         else if ((pIcode->ic.ll.opcode == iCMP) && 
  329.                  (isLong23 (idx, pIcode->inBB, pProc->Icode.GetFirstIcode(),
  330.                  &off, &arc)))
  331.         {
  332.             if (checkLongEq (pLocId->id.longStkId, pIcode, i, idx, pProc,
  333.                              &rhs, &lhs, off) == TRUE)
  334.                 longJCond23 (rhs, lhs, pIcode, &idx, pProc, arc, off);
  335.         }
  336.  
  337.         /* Check for long conditional equality or inequality.  This requires
  338.          * 2 CMPs and 2 branches */ 
  339.         else if ((pIcode->ic.ll.opcode == iCMP) && 
  340.                                         isLong22 (pIcode, pEnd, &off))
  341.         {
  342.             if (checkLongEq (pLocId->id.longStkId, pIcode, i, idx, pProc,
  343.                              &rhs, &lhs, off) == TRUE)
  344.                 longJCond22 (rhs, lhs, pIcode, &idx);
  345.         }
  346.     }
  347. }
  348.  
  349.  
  350. static void propLongReg (Int i, ID *pLocId, PPROC pProc)
  351. /* Finds the definition of the long register pointed to by pLocId, and 
  352.  * transforms that instruction into a HIGH_LEVEL icode instruction.
  353.  * Arguments: i     : index into the local identifier table
  354.  *            pLocId: ptr to the long local identifier 
  355.  *            pProc : ptr to current procedure's record.        */
  356. { COND_EXPR *lhs, *rhs; 
  357.   Int idx, j, off, arc;
  358.   PICODE pIcode, pEnd;
  359.   PMEM pmH, pmL;            /* Pointers to dst LOW_LEVEL icodes */
  360.  
  361.   /* Process all definitions/uses of long registers at an icode position */
  362.   pEnd = pProc->Icode.GetIcode(pProc->Icode.GetNumIcodes() -1);
  363.   for (j = 0; j < pLocId->idx.csym; j++)
  364.   {
  365.     /* Check backwards for a definition of this long register */
  366.     for (idx = pLocId->idx.idx[j] - 1; idx > 0 ; idx--)
  367.     {
  368.       pIcode = pProc->Icode.GetIcode(idx-1);
  369.       if ((pIcode->type == HIGH_LEVEL) || (pIcode->invalid == TRUE))
  370.             continue;
  371.  
  372.       if (pIcode->ic.ll.opcode == (pIcode+1)->ic.ll.opcode)
  373.         switch (pIcode->ic.ll.opcode) {
  374.           case iMOV:
  375.             pmH = &pIcode->ic.ll.dst;
  376.             pmL = &(pIcode+1)->ic.ll.dst;
  377.             if ((pLocId->id.longId.h == pmH->regi) && 
  378.                 (pLocId->id.longId.l == pmL->regi))
  379.             {
  380.                 lhs = idCondExpLongIdx (i);
  381.                 insertIdx (&pProc->localId.id[i].idx, idx-1);
  382.                 setRegDU (pIcode, pmL->regi, E_DEF);
  383.                 rhs = idCondExpLong (&pProc->localId, SRC, pIcode, HIGH_FIRST, 
  384.                                      idx, E_USE, 1);
  385.                 newAsgnHlIcode (pIcode, lhs, rhs);
  386.                 invalidateIcode (pIcode + 1);
  387.                 idx = 0;    /* to exit the loop */
  388.             }
  389.             break;
  390.  
  391.           case iPOP:
  392.             pmH = &(pIcode+1)->ic.ll.dst;
  393.             pmL = &pIcode->ic.ll.dst;
  394.             if ((pLocId->id.longId.h == pmH->regi) &&
  395.                 (pLocId->id.longId.l == pmL->regi))
  396.             {
  397.                 lhs = idCondExpLongIdx (i);
  398.                 setRegDU (pIcode, pmH->regi, E_DEF);
  399.                 newUnaryHlIcode (pIcode, HLI_POP, lhs);
  400.                 invalidateIcode (pIcode + 1);
  401.                 idx = 0;        /* to exit the loop */
  402.             }
  403.             break;
  404.     
  405.           /**** others missing ***/
  406.  
  407.           case iAND: case iOR: case iXOR:
  408.             pmL = &pIcode->ic.ll.dst;
  409.             pmH = &(pIcode+1)->ic.ll.dst;
  410.             if ((pLocId->id.longId.h == pmH->regi) &&
  411.                 (pLocId->id.longId.l == pmL->regi))
  412.             {
  413.                 lhs = idCondExpLongIdx (i);
  414.                 setRegDU (pIcode, pmH->regi, USE_DEF);
  415.                 rhs = idCondExpLong (&pProc->localId, SRC, pIcode, LOW_FIRST, 
  416.                                      idx, E_USE, 1);
  417.                 switch (pIcode->ic.ll.opcode) {
  418.                   case iAND: rhs = boolCondExp (lhs, rhs, AND);
  419.                              break;
  420.                   case iOR:     rhs = boolCondExp (lhs, rhs, OR);
  421.                              break;
  422.                   case iXOR: rhs = boolCondExp (lhs, rhs, XOR);
  423.                              break;
  424.                 } /* eos */
  425.                 newAsgnHlIcode (pIcode, lhs, rhs);
  426.                 invalidateIcode (pIcode + 1);
  427.                 idx = 0;
  428.             }
  429.             break;
  430.         } /* eos */
  431.     }
  432.  
  433.     /* If no definition backwards, check forward for a use of this long reg */
  434.     if (idx <= 0)
  435.       for (idx = pLocId->idx.idx[j] + 1; idx < pProc->Icode.GetNumIcodes() - 1; idx++)
  436.       {
  437.         pIcode = pProc->Icode.GetIcode(idx);
  438.         if ((pIcode->type == HIGH_LEVEL) || (pIcode->invalid == TRUE))
  439.             continue;
  440.  
  441.         if (pIcode->ic.ll.opcode == (pIcode+1)->ic.ll.opcode)
  442.             switch (pIcode->ic.ll.opcode) {
  443.               case iMOV:
  444.                 if ((pLocId->id.longId.h == pIcode->ic.ll.src.regi) &&
  445.                     (pLocId->id.longId.l == (pIcode+1)->ic.ll.src.regi))
  446.                 {
  447.                     rhs = idCondExpLongIdx (i);
  448.                     setRegDU (pIcode, (pIcode+1)->ic.ll.src.regi, E_USE); 
  449.                     lhs = idCondExpLong (&pProc->localId, DST, pIcode, 
  450.                                          HIGH_FIRST, idx, E_DEF, 1);
  451.                     newAsgnHlIcode (pIcode, lhs, rhs);
  452.                     invalidateIcode (pIcode + 1);
  453.                     idx = pProc->Icode.GetNumIcodes();    /* to exit the loop */ 
  454.                 }
  455.                 break;
  456.  
  457.               case iPUSH:
  458.                 if ((pLocId->id.longId.h == pIcode->ic.ll.src.regi) &&
  459.                     (pLocId->id.longId.l == (pIcode+1)->ic.ll.src.regi))
  460.                 {
  461.                     rhs = idCondExpLongIdx (i);
  462.                     setRegDU (pIcode, (pIcode+1)->ic.ll.src.regi, E_USE); 
  463.                     newUnaryHlIcode (pIcode, HLI_PUSH, lhs);
  464.                     invalidateIcode (pIcode + 1);
  465.                 }
  466.                 idx = pProc->Icode.GetNumIcodes();    /* to exit the loop  */
  467.                 break;
  468.  
  469.               /*** others missing ****/
  470.  
  471.                 case iAND: case iOR: case iXOR:
  472.                 pmL = &pIcode->ic.ll.dst;
  473.                 pmH = &(pIcode+1)->ic.ll.dst;
  474.                 if ((pLocId->id.longId.h == pmH->regi) &&
  475.                     (pLocId->id.longId.l == pmL->regi))
  476.                 {
  477.                     lhs = idCondExpLongIdx (i);
  478.                     setRegDU (pIcode, pmH->regi, USE_DEF);
  479.                     rhs = idCondExpLong (&pProc->localId, SRC, pIcode, 
  480.                                          LOW_FIRST, idx, E_USE, 1);
  481.                     switch (pIcode->ic.ll.opcode) {
  482.                       case iAND: rhs = boolCondExp (lhs, rhs, AND);
  483.                                  break;
  484.                       case iOR:  rhs = boolCondExp (lhs, rhs, OR);
  485.                                  break;
  486.                       case iXOR: rhs = boolCondExp (lhs, rhs, XOR);
  487.                                  break;
  488.                     }
  489.                     newAsgnHlIcode (pIcode, lhs, rhs);
  490.                     invalidateIcode (pIcode + 1);
  491.                     idx = 0;
  492.                 }
  493.                 break;
  494.             } /* eos */
  495.  
  496.         /* Check long conditional (i.e. 2 CMPs and 3 branches */ 
  497.         else if ((pIcode->ic.ll.opcode == iCMP) && 
  498.                  (isLong23 (idx, pIcode->inBB, pProc->Icode.GetFirstIcode(),
  499.                   &off, &arc)))
  500.         {
  501.             if (checkLongRegEq (pLocId->id.longId, pIcode, i, idx, pProc,
  502.                                 &rhs, &lhs, off) == TRUE)
  503.                 longJCond23 (rhs, lhs, pIcode, &idx, pProc, arc, off);
  504.         }
  505.  
  506.         /* Check for long conditional equality or inequality.  This requires
  507.          * 2 CMPs and 2 branches */ 
  508.         else if ((pIcode->ic.ll.opcode == iCMP) && 
  509.                                             (isLong22 (pIcode, pEnd, &off)))
  510.         {
  511.             if (checkLongRegEq (pLocId->id.longId, pIcode, i, idx, pProc,
  512.                                 &rhs, &lhs, off) == TRUE)
  513.                 longJCond22 (rhs, lhs, pIcode, &idx);
  514.         }
  515.         
  516.         /* Check for OR regH, regL
  517.          *             JX lab    
  518.          *        => HLI_JCOND (regH:regL X 0) lab
  519.          * This is better code than HLI_JCOND (HI(regH:regL) | LO(regH:regL)) */
  520.         else if ((pIcode->ic.ll.opcode == iOR) && ((pIcode+1) < pEnd) &&
  521.                  (isJCond ((pIcode+1)->ic.ll.opcode)))
  522.         {
  523.             if ((pIcode->ic.ll.dst.regi == pLocId->id.longId.h) &&
  524.                 (pIcode->ic.ll.src.regi == pLocId->id.longId.l))
  525.             {
  526.                 lhs = idCondExpLongIdx (i);
  527.                 rhs = idCondExpKte (0, 4);    /* long 0 */
  528.                 lhs = boolCondExp (lhs, rhs, 
  529.                                    condOpJCond[(pIcode+1)->ic.ll.opcode - iJB]);
  530.                 newJCondHlIcode (pIcode+1, lhs);
  531.                 copyDU (pIcode+1, pIcode, E_USE, E_USE);
  532.                 invalidateIcode (pIcode);
  533.             }
  534.         }
  535.  
  536.       } /* end for */
  537.   } /* end for */
  538. }
  539.  
  540.  
  541. static void propLongGlb (Int i, ID *pLocId, PPROC pProc)
  542. /* Propagates the long global address across all LOW_LEVEL icodes. 
  543.  * Transforms some LOW_LEVEL icodes into HIGH_LEVEL     */
  544. {
  545.  
  546. }
  547.  
  548.  
  549. void propLong (PPROC pProc)
  550. /* Propagated identifier information, thus converting some LOW_LEVEL icodes
  551.  * into HIGH_LEVEL icodes.  */
  552. { Int i;
  553.   ID *pLocId;           /* Pointer to current local identifier */
  554.  
  555.     for (i = 0; i < pProc->localId.csym; i++)
  556.     {
  557.         pLocId = &pProc->localId.id[i];
  558.         if ((pLocId->type==TYPE_LONG_SIGN) || (pLocId->type==TYPE_LONG_UNSIGN))
  559.         {
  560.             switch (pLocId->loc) {
  561.             case STK_FRAME:    propLongStk (i, pLocId, pProc);
  562.                             break;
  563.             case REG_FRAME: propLongReg (i, pLocId, pProc);
  564.                             break;
  565.             case GLB_FRAME: propLongGlb (i, pLocId, pProc);
  566.                             break; 
  567.             }
  568.         }
  569.     }
  570. }
  571.  
  572.