Open64: osprey/be/opt/opt_whirlview.cxx Source File

00001 //-*-c++-*-
00002 
00003 /*
00004  * Copyright 2004, 2005, 2006 PathScale, Inc.  All Rights Reserved.
00005  */
00006 
00007 // ====================================================================
00008 // ====================================================================
00009 //
00010 // Module: opt_whirlview.cxx
00011 // $Revision: 1.1.1.1 $
00012 // $Date: 2005/10/21 19:00:00 $
00013 // $Author: marcel $
00014 // $Source: /proj/osprey/CVS/open64/osprey1.0/be/opt/opt_whirlview.cxx,v $
00015 //
00016 // ====================================================================
00017 //
00018 // Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00019 //
00020 // This program is free software; you can redistribute it and/or modify
00021 // it under the terms of version 2 of the GNU General Public License as
00022 // published by the Free Software Foundation.
00023 //
00024 // This program is distributed in the hope that it would be useful, but
00025 // WITHOUT ANY WARRANTY; without even the implied warranty of
00026 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00027 //
00028 // Further, this software is distributed without any warranty that it
00029 // is free of the rightful claim of any third person regarding
00030 // infringement  or the like.  Any license provided herein, whether
00031 // implied or otherwise, applies only to this software file.  Patent
00032 // licenses, if any, provided herein do not apply to combinations of
00033 // this program with other software, or any other product whatsoever.
00034 //
00035 // You should have received a copy of the GNU General Public License
00036 // along with this program; if not, write the Free Software Foundation,
00037 // Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
00038 //
00039 // Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00040 // Mountain View, CA 94043, or:
00041 //
00042 // http://www.sgi.com
00043 //
00044 // For further information regarding this notice, see:
00045 //
00046 // http://oss.sgi.com/projects/GenInfo/NoticeExplan
00047 //
00048 // ====================================================================
00049 // ====================================================================
00050 
00051 
00052 #ifdef USE_PCH
00053 #include "opt_pch.h"
00054 #endif // USE_PCH
00055 #pragma hdrstop
00056 
00057 
00058 #include <stdio.h>
00059 #include <string.h>
00060 
00061 #include "defs.h"
00062 #include "errors.h"
00063 #include "srcpos.h"
00064 #include "opcode.h"
00065 #include "wn.h"   /* Whirl Node descriptor */
00066 #include "wn_simp.h"    /* Whirl simplifier (can be stubs) */
00067 
00068 #ifdef TODO_IGNORE_SOURCE
00069 #include "dwarf_DST.h"
00070 #include "dwarf_DST_mem.h"
00071 #endif
00072 
00073 #include "stab.h"
00074 #include "const.h"
00075 #include "targ_const.h"
00076 #include "strtab.h"
00077 #include "wio.h"
00078 #include "wintrinsic.h"
00079 #include "wutil.h"
00080 #include "intrn_info.h"
00081 #include "wn_pragmas.h"
00082 
00083 #include "opt_base.h"
00084 #include "opt_du.h"   /* for DU_MANAGER */
00085 #include "targ_sim.h"
00086 
00087 extern FILE *Init_daVinci(void);
00088 
00089 /*========================================================================
00090 
00091   IR Ascii Writer using SPRINTF_ADV
00092     sir_put_wn
00093     sir_put_st
00094 
00095   Code for these three functions more or less stolen from
00096   common/com/ir_reader.c, with modifications to use sprintf in place
00097   of fprintf, and other very minor changes. Because some of this code
00098   owes its origins to functions written in C, the C++ compiler
00099   produces a few warnings about anachronisms.
00100  ========================================================================*/
00101 
00102 /* A general-purpose output buffer for the IR ASCII writer, and an
00103  * index into the buffer to keep track of where we're appending.
00104  */
00105 
00106 static char  ir_obuf[2048];
00107 static char *ir_oidx = ir_obuf;
00108 
00109 /* Macro to do sprintf and advance a buffer pointer (usually a pointer
00110  * to sprintf's output buffer. This isn't particularly efficient, so
00111  * don't use it if performance matters.
00112  */
00113 #define SPRINTF_ADV(buf, args) { \
00114            (void) sprintf args; \
00115            buf += strlen(buf); \
00116         }
00117 
00118 
00119 static void
00120 sir_put_st (ST *st)
00121 {
00122   char *name;
00123   char *p;
00124   
00125   if (st == NULL) {
00126     /* labels may have empty st */
00127     SPRINTF_ADV(ir_oidx, (ir_oidx, " <null-st>"));
00128   }
00129   else {
00130     name = ST_name(st);
00131     if (ST_class(st) == CLASS_CONST) {
00132       name = Targ_Print(NULL, STC_val(st));
00133       /* new lines and spaces in constant strings 
00134        * will mess up the ascii reader,
00135        * so replace with underlines */
00136       for (p = name; *p != '\0'; p++)
00137   switch (*p) {
00138   case ' ':
00139   case '\t':
00140   case '\n':
00141     *p = '_';
00142     break;
00143   case '"':      // embeded double quotes break DaVinci.
00144     *p = '\'';
00145     break;
00146   }
00147     }
00148     SPRINTF_ADV(ir_oidx, (ir_oidx, " <%d,%d,%s>", ST_level(st),
00149         ST_index(st), ST_name(st)));
00150   }
00151 }
00152 
00153 /* Write a WN in ascii form on an individual line.
00154  */ 
00155 static void sir_put_wn(WN *wn)
00156 {
00157     OPCODE opcode = WN_opcode(wn);
00158 
00159     if (wn == NULL) {
00160       /* null statement */
00161       SPRINTF_ADV(ir_oidx, (ir_oidx, "### error: null WN pointer"));
00162      return;
00163     }
00164 
00165     SPRINTF_ADV(ir_oidx,
00166     (ir_oidx, "%s", OPCODE_name(WN_opcode(wn)) + strlen("OPC_")));
00167     if (OPCODE_has_offset(opcode)) {
00168       SPRINTF_ADV(ir_oidx, (ir_oidx, " %d", WN_offset(wn)));
00169     }
00170 
00171     if (OPCODE_operator(opcode) == OPR_INTRINSIC_OP
00172 #ifdef KEY
00173   || OPCODE_operator(opcode) == OPR_PURE_CALL_OP
00174 #endif
00175        ) {
00176       SPRINTF_ADV(ir_oidx, (ir_oidx, " %d", WN_kid_count(wn)));
00177     }
00178 
00179     if (OPCODE_has_inumber(opcode)) {
00180   switch (opcode) {
00181   case OPC_IO:
00182     SPRINTF_ADV(ir_oidx,
00183           (ir_oidx, " <%d,%s>",
00184            WN_intrinsic(wn),
00185            IOSTATEMENT_name((IOSTATEMENT) WN_intrinsic(wn))));
00186     break;
00187   case OPC_IO_ITEM:
00188     SPRINTF_ADV(ir_oidx,
00189           (ir_oidx, " <%d,%s>",
00190            WN_intrinsic(wn),
00191            IOITEM_name((IOITEM) WN_intrinsic(wn))));
00192     break;
00193   default:
00194     /* intrinsic */
00195     SPRINTF_ADV(ir_oidx,
00196           (ir_oidx, " <%d,%s>",
00197            WN_intrinsic(wn),
00198            INTRINSIC_name((INTRINSIC) WN_intrinsic(wn))));
00199     break;
00200   }
00201     }
00202 
00203     if (OPCODE_has_bits(opcode))
00204       SPRINTF_ADV(ir_oidx,
00205       (ir_oidx, " %d", WN_cvtl_bits(wn)));
00206     if (OPCODE_has_label(opcode))
00207       SPRINTF_ADV(ir_oidx,
00208       (ir_oidx, " L%d", WN_label_number(wn)));
00209     if (OPCODE_has_flags(opcode)) 
00210       SPRINTF_ADV(ir_oidx,
00211       (ir_oidx, " 0x%x", WN_flag(wn)));
00212     if (OPCODE_has_sym(opcode)) {
00213       sir_put_st (WN_st(wn));
00214     }
00215 
00216     if (OPCODE_has_1ty(opcode)) {
00217       if (WN_ty(wn) != 0) {
00218   SPRINTF_ADV(ir_oidx,
00219         (ir_oidx, " T<%d,%s>",
00220          TY_id(WN_ty(wn)), 
00221          TY_name(WN_ty(wn))));
00222       }
00223       else {
00224   SPRINTF_ADV(ir_oidx,
00225         (ir_oidx, " T<### ERROR: null ptr>"));
00226       }
00227     } else if (OPCODE_has_2ty(opcode)) {
00228       if (WN_ty(wn) != 0) { 
00229   SPRINTF_ADV(ir_oidx,
00230         (ir_oidx, " T<%d,%s>", 
00231          TY_id(WN_ty(wn)), 
00232          TY_name(WN_ty(wn))));
00233       }
00234       else {
00235   SPRINTF_ADV(ir_oidx,
00236         (ir_oidx, " T<### ERROR: null ptr>"));
00237       }
00238       if (WN_load_addr_ty(wn) != 0) {
00239   SPRINTF_ADV(ir_oidx,
00240         (ir_oidx, " T<%d,%s>", 
00241          TY_id(WN_load_addr_ty(wn)), 
00242          TY_name(WN_load_addr_ty(wn))));
00243       }
00244       else {
00245   SPRINTF_ADV(ir_oidx,
00246         (ir_oidx, " T<### ERROR: null ptr>"));
00247       }
00248     }
00249 
00250     if (OPCODE_has_ndim(opcode))
00251       SPRINTF_ADV(ir_oidx,
00252       (ir_oidx, " %d", WN_num_dim(wn)));
00253     if (OPCODE_has_esize(opcode))
00254       SPRINTF_ADV(ir_oidx,
00255       (ir_oidx, " %lld", WN_element_size(wn)));
00256 
00257     if (OPCODE_has_num_entries(opcode))
00258       SPRINTF_ADV(ir_oidx,
00259       (ir_oidx, " %d", WN_num_entries(wn)));
00260 
00261     if (OPCODE_has_value(opcode))
00262       SPRINTF_ADV(ir_oidx,
00263       (ir_oidx, " %lld", WN_const_val(wn)));
00264     
00265     if (opcode == OPC_COMMENT) {
00266   SPRINTF_ADV(ir_oidx,
00267         (ir_oidx, " # %s",
00268          Index_To_Str(WN_offset(wn))));
00269     }
00270 
00271     if (OPCODE_has_sym(opcode) && OPCODE_has_offset(opcode)
00272   && WN_st(wn) != NULL && (ST_class(WN_st(wn)) == CLASS_PREG)
00273   && !Preg_Is_Dedicated(WN_offset(wn)) ) {
00274   /* reference to a non-dedicated preg */
00275       SPRINTF_ADV(ir_oidx,
00276       (ir_oidx, " # %s", Preg_Name(WN_offset(wn))));
00277     }
00278 
00279     if (opcode == OPC_PRAGMA) {
00280   SPRINTF_ADV(ir_oidx,
00281         (ir_oidx, " # %s", WN_pragmas[WN_offset(wn)].name));
00282     }
00283 
00284     SPRINTF_ADV(ir_oidx,
00285     (ir_oidx, " # <id %d:%d>",
00286      OPCODE_mapcat(WN_opcode(wn)), WN_map_id(wn)));
00287 }
00288 
00289 /* Now the stuff to work with daVinci. Most of the code complexity
00290  * here arises from the need to get daVinci's input syntax right. For
00291  * a nearly comprehensible (though quite incomplete and somewhat
00292  * buggy) description of the syntax, see the appendices to the daVinci
00293  * document.
00294  *
00295  * The most annoying aspect of the syntax is that all the
00296  * arcs outgoing from a particular node v in the graph have to be
00297  * named along with node v. After we've "finished" with node v, we
00298  * can't come along later and add arcs going out of v. Not only that,
00299  * but while we're listing arcs incident to v, we can't define any
00300  * nodes. These facts conspire to defeat any sort of naive recursive
00301  * control flow to handle the output of the WHIRL tree. Finally, if
00302  * our output graph were guaranteed to be strictly a tree structure,
00303  * we could nest the definitions of a node v's kids inside the
00304  * definition for node v. But when we begin to output arbitrary arcs
00305  * incident to v (including "back," "forward," and "cross" arcs, if
00306  * you will -- D-U arcs, for example), the heirarchical output format
00307  * very quickly gets hard to understand and debug.
00308  *
00309  * Motivated by the desire to have easy-to-debug output, and
00310  * frustrated by the fact that the control flow couldn't be simple no
00311  * matter what, I decided to keep all the node definitions at the top
00312  * level of the heirarchy. Uncharitable translation: "Motivated by the
00313  * desire to have easy-to-debug output, I decided to write
00314  * hard-to-debug, obfuscated code." Does this decision make sense? You
00315  * be the judge. :-)
00316  */
00317 
00318 /* daVinci gets the graph description from us through a pipe that
00319  * Init_daVinci() connects to this file pointer.
00320  */
00321 
00322 static FILE *dV_fp;
00323 
00324 /* To be able to traverse the WHIRL tree in the conventional node
00325  * order, we keep an explicit stack of nodes that we've seen but not
00326  * processed. The initial space allocated for the stack is
00327  * DV_INIT_STK_SZ, and it gets increased from there in steps of "times
00328  * two."
00329  */
00330 
00331 #define DV_INIT_STK_SZ 2048
00332 
00333 /* For each node w saved on the stack, we need to know whether to
00334  * treat w as an expression node, a statement node, or something
00335  * special. Generally the expr vs. stmt issue could be resolved by
00336  * looking at the node's opcode, but marking the stacked nodes makes
00337  * things substantially easier.
00338  */
00339 
00340 typedef enum {
00341   DV_NODE_EXPR,
00342   DV_NODE_STMT,
00343   DV_NODE_NONEXP,
00344   DV_NODE_NULEXP,
00345   DV_NODE_UNKNOWN
00346 } DV_NODE_TYPE;
00347 
00348 /* For each arc we are to place, we say what type it is. The arc type
00349  * controls the color we request that the arc be displayed in.
00350  */
00351 
00352 typedef enum {
00353   DV_ARC_KID,
00354   DV_ARC_DU,
00355   DV_ARC_NEXTPREV,
00356   DV_ARC_UNKNOWN
00357 } DV_ARC_TYPE;
00358 
00359 typedef struct wn_stk_ele {
00360   WN           *wn;
00361   DV_NODE_TYPE node_type;
00362 } WN_STK_ELE;
00363 
00364 static WN_STK_ELE  *dV_WN_stack;
00365 static INT          dV_WN_sp;
00366 static INT          dV_WN_stk_sz;
00367 
00368 /* Each node in the output graph must have a unique identification
00369  * string. For nodes that have map id's a string containing the node's
00370  * opcode category and map id is enough, but those nodes that don't
00371  * have map id's need something else. So we maintain a set of nodes
00372  * that have supplementary id numbers. When a node with no map id
00373  * comes along for the first time, we assign it a supplementary id
00374  * number that will always get included in the string that identifies
00375  * the node to daVinci.
00376  */
00377 
00378 #define SUP_INIT_SZ 2048
00379 
00380 static WN         **id_supplement;
00381 static INT          id_sup_sz;
00382 static INT          next_sup_id;
00383 
00384 /* Forward declarations for recursive calls.
00385  */
00386 
00387 static void dV_tree_expr(WN *, DU_MANAGER *);
00388 static void dV_tree_stmt(WN *, DU_MANAGER *);
00389 
00390 /* Allocate space for internal structures, call Init_daVinci() to
00391  * start the daVinci process and open the pipe to it, and output the
00392  * introduction for the graph to come.
00393  */
00394 
00395 static void
00396 dV_WN_init()
00397 
00398 {
00399 dV_WN_stack = (WN_STK_ELE *) malloc(DV_INIT_STK_SZ *
00400             sizeof(WN_STK_ELE));
00401 dV_WN_stk_sz = DV_INIT_STK_SZ;
00402 dV_WN_sp = 0;
00403 
00404 id_supplement = (WN **) malloc(SUP_INIT_SZ * sizeof(WN *));
00405 id_sup_sz = SUP_INIT_SZ;
00406 next_sup_id = 0;
00407 
00408 FmtAssert((dV_WN_stack != NULL) && (id_supplement != NULL),
00409     ("Unable to allocate memory in dV_WN_init()"));
00410 
00411 dV_fp = Init_daVinci();
00412 
00413 (void) fprintf(dV_fp, "graph(new([");
00414 }
00415 
00416 /* Write the characters that signify the end of the graph description
00417  * to daVinci, and free resources used.
00418  */
00419 
00420 static void
00421 dV_WN_end()
00422 
00423 {
00424 (void) fprintf(dV_fp, "]))\n");
00425 free((void *) id_supplement);
00426 free((void *) dV_WN_stack);
00427 
00428 #ifdef TODO_DONT_CLOSE_PIPE
00429 fclose(dV_fp);
00430 #endif
00431 }
00432 
00433 /* Place a dummy node corresponding to a spot in the tree where the
00434  * expected WHIRL node is missing. The dummy node is made a child of
00435  * wn, and the arc from wn to the dummy node is labeled according to
00436  * the argument label.
00437  */
00438 
00439 static char *
00440 dV_place_stub(char *label)
00441 
00442 {
00443   static INT next_id = 1;
00444 
00445   /* Prepare the node label to pass back to the caller. The caller must
00446    * copy it if she wants to keep it around for a long time.
00447    */
00448   ir_oidx = ir_obuf;
00449   (void) sprintf(ir_obuf, "Stub%d", next_id++);
00450 
00451 #ifdef VERTICAL_LABELS
00452   char       localbuf[4096], *p, *q;
00453 
00454   for (p = label, q = localbuf; *p; p++, q++) {
00455     *q++ = *p;
00456     *q++ = '\\';
00457     *q   = 'n';
00458   }
00459   if (p != label) {
00460     *(q-2) = '\0';
00461   }
00462 #else
00463   char *localbuf = label;
00464 #endif
00465 
00466   /* Output the dummy node */
00467   (void) fprintf(dV_fp, "l(\"%s\", n(\"\", [a(\"%s\",\"%s\")], [] ) ),",
00468      ir_obuf, "OBJECT", localbuf);
00469   return ir_obuf;
00470 }
00471 
00472 /* Find or generate the supplementary id for a WHIRL node with no map
00473  * id.
00474  */
00475 
00476 INT
00477 id_sup_search(WN *wn)
00478 {
00479   INT i = 0;
00480 
00481   while (i < next_sup_id) {
00482     if (wn == id_supplement[i]) {
00483       return i;
00484     }
00485     i++;
00486   }
00487 
00488   if (next_sup_id >= id_sup_sz) {
00489     id_sup_sz *= 2;
00490     id_supplement = (WN **) realloc((void *) id_supplement,
00491             id_sup_sz * sizeof(WN *));
00492   }
00493   id_supplement[next_sup_id] = wn;
00494   return next_sup_id++;
00495 }
00496 
00497 /* Generate a string that uniquely identifies the given WHIRL node.
00498  */
00499 
00500 static const char *
00501 id_str(WN *wn)
00502 
00503 {
00504   static char dv_id[64];
00505 
00506   if (wn) {
00507     if (WN_map_id(wn) == -1) {
00508       /* ID string need not be unique for this node; supplement it
00509        * with a unique integer.
00510        */
00511       INT sup = id_sup_search(wn);
00512       (void) sprintf(dv_id, "<id %d:%d>-%d",
00513          OPCODE_mapcat(WN_opcode(wn)), WN_map_id(wn),
00514          sup);
00515     }
00516     else {
00517       (void) sprintf(dv_id, "<id %d:%d>",
00518          OPCODE_mapcat(WN_opcode(wn)), WN_map_id(wn));
00519     }
00520     return dv_id;
00521   }
00522   else {
00523     return "!!! NULL WN";
00524   }
00525 }
00526 
00527 /* Save a neighbor on the explicit stack; the neighbor will be dealt
00528  * with when all the edges incident to the current node have been
00529  * output.
00530  */
00531 
00532 static void
00533 dV_save_nbor(WN *wn, DV_NODE_TYPE node_type)
00534 
00535 {
00536   /* If we're about to go over the top, realloc the stack. */
00537   if (dV_WN_sp == dV_WN_stk_sz) {
00538     dV_WN_stk_sz *= 2;
00539     dV_WN_stack = (WN_STK_ELE *) realloc((void *) dV_WN_stack,
00540            dV_WN_stk_sz *
00541            sizeof(WN_STK_ELE));
00542   }
00543   FmtAssert(dV_WN_sp < dV_WN_stk_sz, ("Stack pointer messed up"));
00544 
00545   dV_WN_stack[dV_WN_sp].wn = wn;
00546   dV_WN_stack[dV_WN_sp].node_type = node_type;
00547   dV_WN_sp++;
00548 }
00549 
00550 /* Pop an element off the stack and return a pointer to it.
00551  */
00552 
00553 static WN_STK_ELE *
00554 dV_get_nbor(void)
00555 
00556 {
00557   FmtAssert(dV_WN_sp > 0, ("Pop when dV_WN_sp == 0"));
00558   dV_WN_sp--;
00559   return dV_WN_stack + dV_WN_sp;
00560 }
00561 
00562 /* Place a graph node corresponding to a WHIRL node. The visible text
00563  * on the node is more or less what would be printed by fdump_wn(wn).
00564  */
00565 
00566 static void
00567 dV_open_WN(WN *wn)
00568 
00569 {
00570   ir_oidx = ir_obuf;
00571   sir_put_wn(wn);
00572 
00573 #ifdef VERTICAL_LABELS
00574   char localbuf[4096], *p, *q;
00575 
00576   for (p = ir_obuf, q = localbuf; *p; p++, q++) {
00577     *q++ = *p;
00578     *q++ = '\\';
00579     *q   = 'n';
00580   }
00581   if (p != ir_obuf) {
00582     *(q-2) = '\0';
00583   }
00584 #else
00585   char *localbuf = ir_obuf;
00586 #endif
00587 
00588   (void) fprintf(dV_fp, "l(\"%s\", n(\"\", [a(\"%s\",\"%s\")], [",
00589       id_str(wn), "OBJECT", localbuf);
00590 
00591   /* Save a marker on the WN stack so we know when the recursion has
00592    * finished with the kids of this node.
00593    */
00594   dV_save_nbor(NULL, DV_NODE_UNKNOWN);
00595 
00596   /* Now we're ready to output labeled edges into the daVinci pipe.
00597    */
00598 }
00599 
00600 /* Do the processing that comes after all the arcs outgoing from the
00601  * given node have been output. Mainly, we grab nodes one-by-one off
00602  * the explicit stack and them recursively. The type DV_NODE_UNKNOWN
00603  * serves as a barrier between "frames" on the stack, where a frame is
00604  * a collection of kids of one particular node.
00605  */
00606 
00607 static void
00608 dV_close_WN(WN *wn, DU_MANAGER *du_mgr)
00609 
00610 {
00611   WN_STK_ELE *nbor;
00612   char buf[64];
00613 
00614   /* First close up the syntactic construct for the WHIRL node...
00615    */
00616   (void) fprintf(dV_fp, "] ) ),");
00617 
00618   /* Now spit out the saved neighbors of the node.
00619    */
00620   while ((nbor = dV_get_nbor())->node_type != DV_NODE_UNKNOWN) {
00621     switch (nbor->node_type) {
00622     case DV_NODE_EXPR:
00623       dV_tree_expr(nbor->wn, du_mgr);
00624       break;
00625     case DV_NODE_STMT:
00626       dV_tree_stmt(nbor->wn, du_mgr);
00627       break;
00628     case DV_NODE_NONEXP:
00629       (void) sprintf(buf, "!!! NONEXP(%d)", WN_opcode(nbor->wn));
00630       dV_place_stub(buf);
00631       break;
00632     case DV_NODE_NULEXP:
00633       dV_open_WN(nbor->wn);
00634       dV_close_WN(nbor->wn, du_mgr);
00635       break;
00636     default:
00637       FmtAssert(FALSE, ("Incorrect node type in daVinci WN stack"));
00638     }
00639   }
00640 }
00641 
00642 /* Place an arc from the current WHIRL node to the WHIRL node with
00643  * daVinci id *node_id.
00644  */
00645 
00646 static void
00647 dV_place_arc(const char *node_id, DV_ARC_TYPE arc_type, const char *label)
00648 {
00649   const char *color;
00650 
00651   switch (arc_type) {
00652   case DV_ARC_KID:
00653     color = "red";
00654     break;
00655   case DV_ARC_NEXTPREV:
00656     color = "green";
00657     break;
00658   case DV_ARC_DU:
00659     color = "blue";
00660     break;
00661   default:
00662     color = "black";
00663   }
00664    
00665   (void) fprintf(dV_fp, "e(\"\", [a(\"%s\", \"%s\")], r(\"%s\")),",
00666      "EDGECOLOR", color, node_id);
00667 }
00668 
00669 /*  Write an expression and its children to the daVinci pipe.
00670  */
00671 static void
00672 dV_tree_expr(WN *wn, DU_MANAGER *du_mgr)
00673 
00674 {
00675   INT i;
00676   WN *wn2;
00677   char buf[64];
00678 
00679   dV_open_WN(wn);
00680 
00681   for (i = 0; i < WN_kid_count(wn); i++) {
00682     wn2 = WN_kid(wn,i);
00683     if (wn2) {
00684       OPCODE op = WN_opcode(wn2);
00685       if ((OPCODE_FIRST <= op && op <= OPCODE_LAST) &&
00686     (OPCODE_is_expression(op) || OPCODE_is_call(op))) {
00687   dV_save_nbor(WN_kid(wn,i), DV_NODE_EXPR);
00688   (void) sprintf(buf, "kid%d", i);
00689   dV_place_arc(id_str(WN_kid(wn,i)), DV_ARC_KID, buf);
00690       }
00691       else {
00692   dV_save_nbor(wn2, DV_NODE_NONEXP);
00693   dV_place_arc(id_str(wn2), DV_ARC_KID, "NONEXP");
00694       }
00695     }
00696     else {
00697       dV_save_nbor(wn2, DV_NODE_NULEXP);
00698       dV_place_arc(id_str(wn2), DV_ARC_KID, "NULEXP");
00699     }
00700   }
00701 
00702   /* The WHIRL tree structure is now output for this node. Time to
00703    * output the DU-chain information (and any other information we
00704    * want to include).
00705    */
00706   if (du_mgr) {
00707     USE_LIST            *use_list = du_mgr->Du_Get_Use(wn);
00708     USE_LIST_CONST_ITER  use_lst_iter;
00709     const DU_NODE       *tmp;
00710 
00711     FOR_ALL_NODE(tmp, use_lst_iter, Init(use_list))
00712       dV_place_arc(id_str(tmp->Wn()), DV_ARC_DU, "USES");
00713   }
00714 
00715   dV_close_WN(wn, du_mgr);
00716 }
00717 
00718 /* Write a statement WN * and its children to the daVinci pipe.
00719  */
00720 static void
00721 dV_tree_stmt(WN *wn, DU_MANAGER *du_mgr)
00722 {
00723   INT i;
00724   WN *wn2;
00725   char buf[64];
00726 
00727 #ifdef TODO_IGNORE_SOURCE
00728   USRCPOS srcpos;
00729   OPCODE opc = WN_opcode(wn);
00730   
00731   USRCPOS_srcpos(srcpos) = WN_Get_Linenum(wn);
00732   if (USRCPOS_srcpos(srcpos) != 0 && 
00733       USRCPOS_srcpos(srcpos) != USRCPOS_srcpos(last_srcpos)) {
00734     last_srcpos = srcpos;
00735 #ifdef FRONT_END
00736     fprintf(ir_ofile, "%*sLOC %d %d\n", indent, "",
00737       USRCPOS_filenum(srcpos), USRCPOS_linenum(srcpos));
00738 #else
00739     print_source(USRCPOS_srcpos(srcpos));
00740 #endif
00741   }
00742 #endif
00743 
00744   dV_open_WN(wn);
00745 
00746   switch (WN_opcode(wn)) {
00747   case OPC_BLOCK: {
00748     INT kid_num = 1;
00749 
00750     wn2 = WN_first(wn);
00751     while (wn2) {
00752       dV_save_nbor(wn2, DV_NODE_STMT);
00753       (void) sprintf(buf, "blkkid%d", kid_num);
00754       kid_num++;
00755       dV_place_arc(id_str(wn2), DV_ARC_KID, buf);
00756 
00757 #ifdef TODO_DV_SYNTAX_SNAG
00758       wn3 = WN_next(wn2);
00759       if (wn3) {
00760 **--> dV_place_arc(wn2, wn3, DV_ARC_NEXTPREV, "<-- PV/NX -->");
00761       }
00762       wn2 = wn3;
00763 #else
00764       wn2 = WN_next(wn2);
00765 #endif
00766     }
00767     break;
00768   }
00769   case OPC_IF:
00770     dV_save_nbor(WN_if_test(wn), DV_NODE_EXPR);
00771     dV_place_arc(id_str(WN_if_test(wn)), DV_ARC_KID, "COND");
00772     if (WN_then(wn)) {
00773       dV_save_nbor(WN_then(wn), DV_NODE_STMT);
00774       dV_place_arc(id_str(WN_then(wn)), DV_ARC_KID, "THEN");
00775     }
00776     if (WN_else(wn)) {
00777       dV_save_nbor(WN_else(wn), DV_NODE_STMT);
00778       dV_place_arc(id_str(WN_else(wn)), DV_ARC_KID, "ELSE");
00779     }
00780     break;
00781 
00782   case OPC_DO_LOOP:
00783     dV_save_nbor(WN_index(wn), DV_NODE_EXPR);
00784     dV_place_arc(id_str(WN_index(wn)), DV_ARC_KID, "INDX");
00785     dV_save_nbor(WN_start(wn), DV_NODE_STMT);
00786     dV_place_arc(id_str(WN_start(wn)), DV_ARC_KID, "INIT");
00787     dV_save_nbor(WN_end(wn), DV_NODE_EXPR);
00788     dV_place_arc(id_str(WN_end(wn)), DV_ARC_KID, "COMP");
00789     dV_save_nbor(WN_step(wn), DV_NODE_STMT);
00790     dV_place_arc(id_str(WN_step(wn)), DV_ARC_KID, "INCR");
00791     dV_save_nbor(WN_do_body(wn), DV_NODE_STMT);
00792     dV_place_arc(id_str(WN_do_body(wn)), DV_ARC_KID, "BODY");
00793     break;
00794 
00795   case OPC_COMPGOTO:
00796     dV_save_nbor(WN_kid(wn,0), DV_NODE_EXPR);
00797     dV_place_arc(id_str(WN_kid(wn,0)), DV_ARC_KID, "SWCH");
00798     dV_save_nbor(WN_kid(wn,1), DV_NODE_STMT);
00799     dV_place_arc(id_str(WN_kid(wn,1)), DV_ARC_KID, "JMPS");
00800     if (WN_kid_count(wn) > 2) {
00801       dV_save_nbor(WN_kid(wn,2), DV_NODE_STMT);
00802       dV_place_arc(id_str(WN_kid(wn,2)), DV_ARC_KID, "DFLT");
00803     }
00804     break;
00805 
00806   case OPC_XGOTO:
00807     dV_save_nbor(WN_kid(wn,0), DV_NODE_EXPR);
00808     dV_place_arc(id_str(WN_kid(wn,0)), DV_ARC_KID, "SWCH");
00809     dV_save_nbor(WN_kid(wn,1), DV_NODE_STMT);
00810     dV_place_arc(id_str(WN_kid(wn,1)), DV_ARC_KID, "JMPS");
00811     break;
00812 
00813   default: 
00814     {
00815       OPCODE opc2;
00816       for (i = 0; i < WN_kid_count(wn); i++) {
00817   wn2 = WN_kid(wn,i);
00818   FmtAssert(wn2, ("Null kid in dV_tree_stmt"));
00819   opc2 = WN_opcode(wn2);
00820   if (OPCODE_is_expression(opc2)) {
00821     dV_save_nbor(wn2, DV_NODE_EXPR);
00822     (void) sprintf(buf, "kid%d", i);
00823     dV_place_arc(id_str(wn2), DV_ARC_KID, buf);
00824   }
00825   else if (OPCODE_is_stmt(opc2) || OPCODE_is_scf(opc2)) {
00826     dV_save_nbor(wn2, DV_NODE_STMT);
00827     (void) sprintf(buf, "kid%d", i);
00828     dV_place_arc(id_str(wn2), DV_ARC_KID, buf);
00829   }
00830   else {
00831     FmtAssert(FALSE, ("operator of unknown type"));
00832   }
00833       }
00834     }
00835   }
00836 
00837   /* The WHIRL tree structure is now output for this node. Time to
00838    * output the DU-chain information (and any other information we
00839    * want to include).
00840    */
00841   if (du_mgr) {
00842     USE_LIST            *use_list = du_mgr->Du_Get_Use(wn);
00843     USE_LIST_CONST_ITER  use_lst_iter;
00844     const DU_NODE       *tmp;
00845 
00846     FOR_ALL_NODE(tmp, use_lst_iter, Init(use_list))
00847       dV_place_arc(id_str(tmp->Wn()), DV_ARC_DU, "USES");
00848   }
00849 
00850   dV_close_WN(wn, du_mgr);
00851 }
00852 
00853 /* The external interface to the world. If du_mgr is NULL on entry,
00854  * only the WHIRL tree is displayed.
00855  */
00856 
00857 extern "C" void
00858 dV_show_whirl(WN *wn, DU_MANAGER *du_mgr)
00859 
00860 {
00861   dV_WN_init();
00862 
00863   if (OPCODE_is_expression(WN_opcode(wn))) {
00864     dV_tree_expr(wn, du_mgr);
00865   }
00866   else if (OPCODE_is_stmt(WN_opcode(wn)) ||
00867      OPCODE_is_scf(WN_opcode(wn))) {
00868     dV_tree_stmt(wn, du_mgr);
00869   }
00870   else {
00871     FmtAssert(FALSE, ("opcode of unknown type"));
00872   }
00873 
00874   dV_WN_end();
00875 }