home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / dosdisas.zip / dccsrcoo.zip / procs.cpp < prev    next >
C/C++ Source or Header  |  1997-04-09  |  11KB  |  423 lines
  1. /*
  2.  *$Log:    procs.c,v $
  3.  * Revision 1.3  94/02/22  15:18:00  cifuente
  4.  * Routines to support propagation of types across arguments.
  5.  * 
  6.  * Revision 1.2  93/12/13  12:25:39  cifuente
  7.  * Interprocedural live analysis finished.
  8.  * 
  9.  * Revision 1.1  93/11/17  16:28:11  cifuente
  10.  * Initial revision
  11.  * 
  12.  * File:    procs.c
  13.  * Purpose: Functions to support Call graphs and procedures
  14.  * Date:    November 1993
  15.  */
  16.  
  17. #include "dcc.h"
  18. #include <string.h>
  19.  
  20.  
  21. /* Static indentation buffer */
  22. #define indSize     61          /* size of indentation buffer; max 20 */
  23. static char indentBuf[indSize] = 
  24.     "                                                            ";
  25.  
  26. static char *indent (Int indLevel)
  27. /* Indentation according to the depth of the statement */
  28. { 
  29.     return (&indentBuf[indSize-(indLevel*3)-1]); 
  30. }
  31.  
  32.  
  33. static void insertArc (PCALL_GRAPH pcallGraph, PPROC newProc)
  34. /* Inserts an outEdge at the current callGraph pointer if the newProc does 
  35.  * not exist.  */
  36. { CALL_GRAPH *pcg;
  37.   Int i;
  38.  
  39.     /* Check if procedure already exists */
  40.     for (i = 0;  i < pcallGraph->numOutEdges; i++)
  41.         if (pcallGraph->outEdges[i]->proc == newProc)
  42.             return;
  43.  
  44.     /* Check if need to allocate more space */
  45.     if (pcallGraph->numOutEdges == pcallGraph->numAlloc)
  46.     {
  47.         pcallGraph->numAlloc += NUM_PROCS_DELTA;
  48.         pcallGraph->outEdges = (PCALL_GRAPH*)reallocVar(pcallGraph->outEdges,
  49.                             pcallGraph->numAlloc * sizeof(PCALL_GRAPH));
  50.         memset (&pcallGraph->outEdges[pcallGraph->numOutEdges], 0,
  51.                 NUM_PROCS_DELTA * sizeof(PCALL_GRAPH));
  52.     }
  53.  
  54.     /* Include new arc */
  55.     pcg = allocStruc(CALL_GRAPH); 
  56.     memset (pcg, 0, sizeof(CALL_GRAPH));
  57.     pcg->proc = newProc;
  58.     pcallGraph->outEdges[pcallGraph->numOutEdges] = pcg;
  59.     pcallGraph->numOutEdges++;
  60. }
  61.  
  62.  
  63. boolT insertCallGraph (PCALL_GRAPH pcallGraph, PPROC caller, PPROC callee)
  64. /* Inserts a (caller, callee) arc in the call graph tree. */
  65. { Int i;
  66.  
  67.     if (pcallGraph->proc == caller)
  68.     {
  69.         insertArc (pcallGraph, callee);
  70.         return (TRUE);
  71.     }
  72.     else
  73.     {
  74.         for (i = 0; i < pcallGraph->numOutEdges; i++)
  75.             if (insertCallGraph (pcallGraph->outEdges[i], caller, callee))
  76.                 return (TRUE);
  77.         return (FALSE);
  78.     }
  79. }
  80.  
  81.  
  82. static void writeNodeCallGraph (PCALL_GRAPH pcallGraph, Int indIdx) 
  83. /* Displays the current node of the call graph, and invokes recursively on
  84.  * the nodes the procedure invokes. */
  85. { Int i;
  86.  
  87.     printf ("%s%s\n", indent(indIdx), pcallGraph->proc->name);
  88.     for (i = 0; i < pcallGraph->numOutEdges; i++)
  89.         writeNodeCallGraph (pcallGraph->outEdges[i], indIdx + 1);
  90. }
  91.  
  92.  
  93. void writeCallGraph (PCALL_GRAPH pcallGraph)
  94. /* Writes the header and invokes recursive procedure */
  95. { 
  96.     printf ("\nCall Graph:\n");
  97.     writeNodeCallGraph (pcallGraph, 0); 
  98. }
  99.  
  100.  
  101. /**************************************************************************
  102.  *  Routines to support arguments 
  103.  *************************************************************************/
  104.  
  105. void newRegArg (PPROC pproc, PICODE picode, PICODE ticode)
  106. /* Updates the argument table by including the register(s) (ie. lhs of
  107.  * picode) and the actual expression (ie. rhs of picode).
  108.  * Note: register(s) are only included once in the table.   */
  109. { COND_EXPR *lhs;
  110.   PSTKFRAME ps, ts;
  111.   ID *id;
  112.   Int i, tidx;
  113.   boolT regExist;
  114.   condId type;
  115.   PPROC tproc;
  116.   byte regL, regH;        /* Registers involved in arguments */
  117.  
  118.     /* Flag ticode as having register arguments */
  119.     tproc = ticode->ic.hl.oper.call.proc;
  120.     tproc->flg |= REG_ARGS;
  121.  
  122.     /* Get registers and index into target procedure's local list */
  123.     ps = ticode->ic.hl.oper.call.args;
  124.     ts = &tproc->args;
  125.     lhs = picode->ic.hl.oper.asgn.lhs;
  126.     type = lhs->expr.ident.idType;
  127.     if (type == REGISTER)
  128.     {
  129.         regL = pproc->localId.id[lhs->expr.ident.idNode.regiIdx].id.regi;
  130.         if (regL < rAL)
  131.             tidx = newByteWordRegId (&tproc->localId, TYPE_WORD_SIGN, regL);
  132.         else
  133.             tidx = newByteWordRegId (&tproc->localId, TYPE_BYTE_SIGN, regL);
  134.     }
  135.     else if (type == LONG_VAR)
  136.     {
  137.         regL = pproc->localId.id[lhs->expr.ident.idNode.longIdx].id.longId.l;
  138.         regH = pproc->localId.id[lhs->expr.ident.idNode.longIdx].id.longId.h;
  139.         tidx = newLongRegId (&tproc->localId, TYPE_LONG_SIGN, regH, regL, 0);
  140.     }
  141.  
  142.     /* Check if register argument already on the formal argument list */
  143.     regExist = FALSE;
  144.     for (i = 0; i < ts->csym; i++)
  145.     {
  146.         if (type == REGISTER)
  147.         {
  148.             if ((ts->sym[i].regs != NULL) && 
  149.                 (ts->sym[i].regs->expr.ident.idNode.regiIdx == tidx))
  150.             {
  151.                 regExist = TRUE;
  152.                 i = ts->csym;
  153.             }
  154.         }
  155.         else if (type == LONG_VAR)
  156.         {
  157.             if ((ts->sym[i].regs != NULL) && 
  158.                 (ts->sym[i].regs->expr.ident.idNode.longIdx == tidx))
  159.             {
  160.                 regExist = TRUE;
  161.                 i = ts->csym;
  162.             }
  163.         }
  164.     }
  165.  
  166.     /* Do ts (formal arguments) */
  167.     if (regExist == FALSE)
  168.     {
  169.         if (ts->csym == ts->alloc) 
  170.         {
  171.             ts->alloc += 5;
  172.             ts->sym = (STKSYM*)reallocVar(ts->sym, ts->alloc * sizeof(STKSYM));
  173.             memset (&ts->sym[ts->csym], 0, 5 * sizeof(STKSYM));
  174.         }
  175.         sprintf (ts->sym[ts->csym].name, "arg%ld", ts->csym);
  176.         if (type == REGISTER)
  177.         {
  178.             if (regL < rAL)
  179.             {
  180.                 ts->sym[ts->csym].type = TYPE_WORD_SIGN;
  181.                 ts->sym[ts->csym].regs = idCondExpRegIdx (tidx, WORD_REG);
  182.             }
  183.             else
  184.             {
  185.                 ts->sym[ts->csym].type = TYPE_BYTE_SIGN;
  186.                 ts->sym[ts->csym].regs = idCondExpRegIdx (tidx, BYTE_REG);
  187.             }
  188.             sprintf (tproc->localId.id[tidx].name, "arg%ld", ts->csym);
  189.         }
  190.         else if (type == LONG_VAR)
  191.         {
  192.             ts->sym[ts->csym].regs = idCondExpLongIdx (tidx);
  193.             ts->sym[ts->csym].type = TYPE_LONG_SIGN; 
  194.             sprintf (tproc->localId.id[tidx].name, "arg%ld", ts->csym);
  195.             propLongId (&tproc->localId, regL, regH,
  196.                                         tproc->localId.id[tidx].name);
  197.         }
  198.  
  199.         ts->csym++;
  200.         ts->numArgs++;
  201.     }
  202.  
  203.     /* Do ps (actual arguments) */
  204.     if (ps->csym == ps->alloc) 
  205.     {
  206.         ps->alloc += 5;
  207.         ps->sym = (STKSYM*)reallocVar(ps->sym, ps->alloc * sizeof(STKSYM));
  208.         memset (&ps->sym[ps->csym], 0, 5 * sizeof(STKSYM));
  209.     }
  210.     sprintf (ps->sym[ps->csym].name, "arg%ld", ps->csym);
  211.     ps->sym[ps->csym].actual = picode->ic.hl.oper.asgn.rhs;
  212.     ps->sym[ps->csym].regs = lhs;
  213.  
  214.     /* Mask off high and low register(s) in picode */
  215.     switch (type) {
  216.       case REGISTER:    
  217.         id = &pproc->localId.id[lhs->expr.ident.idNode.regiIdx];
  218.         picode->du.def &= maskDuReg[id->id.regi];
  219.         if (id->id.regi < rAL)
  220.             ps->sym[ps->csym].type = TYPE_WORD_SIGN;
  221.         else
  222.             ps->sym[ps->csym].type = TYPE_BYTE_SIGN;
  223.         break;
  224.       case LONG_VAR: 
  225.         id = &pproc->localId.id[lhs->expr.ident.idNode.longIdx];
  226.         picode->du.def &= maskDuReg[id->id.longId.h];
  227.         picode->du.def &= maskDuReg[id->id.longId.l];
  228.         ps->sym[ps->csym].type = TYPE_LONG_SIGN; 
  229.         break;
  230.     }
  231.  
  232.     ps->csym++;
  233.     ps->numArgs++;
  234. }
  235.  
  236.  
  237. void allocStkArgs (PICODE picode, Int num)
  238. /* Allocates num arguments in the actual argument list of the current
  239.  * icode picode.    */
  240. /** NOTE: this function is not used ****/
  241. { PSTKFRAME ps;      
  242.  
  243.     ps = picode->ic.hl.oper.call.args;
  244.     ps->alloc = num;
  245.     ps->csym = num;
  246.     ps->numArgs = num;
  247.     ps->sym = (STKSYM*)reallocVar(ps->sym, ps->alloc * sizeof(STKSYM));
  248.     /**** memset here??? *****/
  249. }
  250.  
  251.  
  252. boolT newStkArg (PICODE picode, COND_EXPR *exp, llIcode opcode, PPROC pproc)
  253. /* Inserts the new expression (ie. the actual parameter) on the argument
  254.  * list.
  255.  * Returns: TRUE if it was a near call that made use of a segment register.
  256.  *            FALSE elsewhere    */
  257. { PSTKFRAME ps;
  258.   byte regi;
  259.  
  260.     /* Check for far procedure call, in which case, references to segment
  261.      * registers are not be considered another parameter (i.e. they are
  262.      * long references to another segment) */
  263.     if (exp)
  264.     {
  265.         if ((exp->type == IDENTIFIER) && (exp->expr.ident.idType == REGISTER))
  266.         {
  267.             regi =  pproc->localId.id[exp->expr.ident.idNode.regiIdx].id.regi;
  268.             if ((regi >= rES) && (regi <= rDS))
  269.                 if (opcode == iCALLF)
  270.                     return (FALSE);
  271.                 else
  272.                     return (TRUE);
  273.         }
  274.     }
  275.  
  276.     /* Place register argument on the argument list */
  277.     ps = picode->ic.hl.oper.call.args;
  278.     if (ps->csym == ps->alloc) 
  279.     {
  280.         ps->alloc += 5;
  281.         ps->sym = (STKSYM*)reallocVar(ps->sym, ps->alloc * sizeof(STKSYM));
  282.         memset (&ps->sym[ps->csym], 0, 5 * sizeof(STKSYM));
  283.     }
  284.     ps->sym[ps->csym].actual = exp;
  285.     ps->csym++;
  286.     ps->numArgs++;
  287.     return (FALSE);
  288. }
  289.  
  290.  
  291. void placeStkArg (PICODE picode, COND_EXPR *exp, Int pos)
  292. /* Places the actual argument exp in the position given by pos in the
  293.  * argument list of picode.    */
  294. { PSTKFRAME ps;
  295.  
  296.     ps = picode->ic.hl.oper.call.args;
  297.     ps->sym[pos].actual = exp;
  298.     sprintf (ps->sym[pos].name, "arg%ld", pos);
  299. }
  300.  
  301.  
  302. void adjustActArgType (COND_EXPR *exp, hlType forType, PPROC pproc)
  303. /* Checks to determine whether the expression (actual argument) has the
  304.  * same type as the given type (from the procedure's formal list).  If not,
  305.  * the actual argument gets modified */
  306. { hlType actType;
  307.   Int offset, offL;
  308.  
  309.     if (exp == NULL)
  310.         return;
  311.  
  312.     actType = expType (exp, pproc);
  313.     if ((actType != forType) && (exp->type == IDENTIFIER))
  314.     {
  315.         switch (forType) {
  316.           case TYPE_UNKNOWN: case TYPE_BYTE_SIGN:
  317.           case TYPE_BYTE_UNSIGN: case TYPE_WORD_SIGN:
  318.           case TYPE_WORD_UNSIGN: case TYPE_LONG_SIGN:
  319.           case TYPE_LONG_UNSIGN: case TYPE_RECORD:
  320.                 break;
  321.  
  322.           case TYPE_PTR:
  323.           case TYPE_CONST:
  324.                 break;
  325.  
  326.           case TYPE_STR:
  327.                 switch (actType) {
  328.                   case TYPE_CONST:
  329.                     /* It's an offset into image where a string is
  330.                      * found.  Point to the string.    */
  331.                     offL = exp->expr.ident.idNode.kte.kte;
  332.                     if (prog.fCOM)
  333.                         offset = (pproc->state.r[rDS]<<4) + offL + 0x100;
  334.                     else
  335.                         offset = (pproc->state.r[rDS]<<4) + offL;
  336.                     exp->expr.ident.idNode.strIdx = offset;
  337.                     exp->expr.ident.idType = STRING;
  338.                     break;
  339.  
  340.                   case TYPE_PTR:
  341.                     /* It's a pointer to a char rather than a pointer to 
  342.                      * an integer */
  343.                     /***HERE - modify the type ****/
  344.                     break;
  345.  
  346.                   case TYPE_WORD_SIGN:
  347.  
  348.                     break;
  349.                 } /* eos */
  350.                 break;
  351.         }
  352.     }
  353. }
  354.  
  355.  
  356. void adjustForArgType (PSTKFRAME pstkFrame, Int numArg, hlType actType)
  357. /* Determines whether the formal argument has the same type as the given
  358.  * type (type of the actual argument).  If not, the formal argument is 
  359.  * changed its type */
  360. { hlType forType;
  361.   PSTKSYM psym, nsym;
  362.   Int off, i;
  363.  
  364.     /* Find stack offset for this argument */
  365.     off = pstkFrame->minOff;
  366.     for (i = 0; i < numArg; i++)
  367.         off += pstkFrame->sym[i].size;
  368.  
  369.     /* Find formal argument */
  370.     if (numArg < pstkFrame->csym)
  371.     {
  372.         psym = &pstkFrame->sym[numArg];
  373.         i = numArg;
  374.         while ((i < pstkFrame->csym) && (psym->off != off))
  375.         {
  376.             psym++;
  377.             i++;
  378.         }
  379.         if (numArg == pstkFrame->csym)
  380.             return;
  381.     }
  382.     /* If formal argument does not exist, do not create new ones, just
  383.      * ignore actual argument */
  384.     else
  385.         return;
  386.  
  387.     forType = psym->type;
  388.     if (forType != actType)
  389.     {
  390.         switch (actType) {
  391.           case TYPE_UNKNOWN: case TYPE_BYTE_SIGN:
  392.           case TYPE_BYTE_UNSIGN: case TYPE_WORD_SIGN:
  393.           case TYPE_WORD_UNSIGN: case TYPE_RECORD:
  394.                 break;
  395.  
  396.           case TYPE_LONG_UNSIGN: case TYPE_LONG_SIGN:
  397.                 if ((forType == TYPE_WORD_UNSIGN) || 
  398.                     (forType == TYPE_WORD_SIGN) ||
  399.                     (forType == TYPE_UNKNOWN))
  400.                 {
  401.                     /* Merge low and high */
  402.                     psym->type = actType;
  403.                     psym->size = 4;
  404.                     nsym = psym + 1;
  405.                     sprintf (nsym->macro, "HI");
  406.                     sprintf (psym->macro, "LO");
  407.                     nsym->hasMacro = TRUE;
  408.                     psym->hasMacro = TRUE;
  409.                     sprintf (nsym->name, "%s", psym->name);
  410.                     nsym->invalid = TRUE;
  411.                     pstkFrame->numArgs--;
  412.                 }
  413.                 break;
  414.  
  415.           case TYPE_PTR:
  416.           case TYPE_CONST:
  417.           case TYPE_STR:
  418.                 break;
  419.         } /* eos */
  420.     }
  421. }
  422.  
  423.