85   class Property {

    85   elapsedTimer _walk_time;

    86 

    86   elapsedTimer _output_time;

    87   private:

    87   elapsedTimer _build_blocks_time;

    88 

    89     const char *_name;

    90     const char *_value;

    91 

    92   public:

    93 

    94     Property();

    95     Property(const Property* p);

    96     ~Property();

    97     Property(const char *name, const char *value);

    98     Property(const char *name, int value);

    99     bool equals(Property* p);

   100     void print(IdealGraphPrinter *printer);

   101     void print_as_attribute(IdealGraphPrinter *printer);

   102     bool is_null();

   103     void clean();

   104     const char *name();

   105 

   106     static const char* dup(const char *str) {

   107       char * copy = new char[strlen(str)+1];

   108       strcpy(copy, str);

   109       return copy;

   110     }

   111 

   112   };

   113 

   114   class Properties {

   115 

   116   private:

   117 

   118     GrowableArray<Property *> *list;

   119 

   120   public:

   121 

   122     Properties();

   123     ~Properties();

   124     void add(Property *p);

   125     void remove(const char *name);

   126     bool equals(Properties* p);

   127     void print(IdealGraphPrinter *printer);

   128     void print_as_attributes(IdealGraphPrinter *printer);

   129     void clean();

   130 

   131   };

   132 

   133 

   134   class Description {

   135 

   136   private:

   137 

   138     State _state;

   139 

   140   public:

   141 

   142     Description();

   143 

   144     State state();

   145     void set_state(State s);

   146     void print(IdealGraphPrinter *printer);

   147     virtual void print_changed(IdealGraphPrinter *printer) = 0;

   148     virtual void print_removed(IdealGraphPrinter *printer) = 0;

   149 

   150   };

   151 

   152   class NodeDescription : public Description{

   153 

   154   public:

   155 

   156     static int count;

   157 

   158   private:

   159 

   160     GrowableArray<NodeDescription *> _succs;

   161     int _block_index;

   162     uintptr_t _id;

   163     Properties _properties;

   164     Node* _node;

   165 

   166   public:

   167 

   168     NodeDescription(Node* node);

   169     ~NodeDescription();

   170     Node* node();

   171 

   172     // void set_node(Node* node);

   173     GrowableArray<NodeDescription *>* succs();

   174     void init_succs();

   175     void clear_succs();

   176     void add_succ(NodeDescription *desc);

   177     int block_index();

   178     void set_block_index(int i);

   179     Properties* properties();

   180     virtual void print_changed(IdealGraphPrinter *printer);

   181     virtual void print_removed(IdealGraphPrinter *printer);

   182     bool equals(NodeDescription *desc);

   183     uint id();

   184 

   185   };

   186 

   187   class Block {

   188 

   189   private:

   190 

   191     NodeDescription *_start;

   192     NodeDescription *_proj;

   193     GrowableArray<int> _succs;

   194     GrowableArray<NodeDescription *> _nodes;

   195     GrowableArray<int> _dominates;

   196     GrowableArray<int> _children;

   197     int _semi;

   198     int _parent;

   199     GrowableArray<int> _pred;

   200     GrowableArray<int> _bucket;

   201     int _index;

   202     int _dominator;

   203     int _ancestor;

   204     int _label;

   205 

   206   public:

   207 

   208     Block();

   209     Block(int index);

   210 

   211     void add_node(NodeDescription *n);

   212     GrowableArray<NodeDescription *>* nodes();

   213     GrowableArray<int>* children();

   214     void add_child(int i);

   215     void add_succ(int index);

   216     GrowableArray<int>* succs();

   217     GrowableArray<int>* dominates();

   218     void add_dominates(int i);

   219     NodeDescription *start();

   220     NodeDescription *proj();

   221     void set_start(NodeDescription *n);

   222     void set_proj(NodeDescription *n);

   223 

   224     int label();

   225     void set_label(int i);

   226     int ancestor();

   227     void set_ancestor(int i);

   228     int index();

   229     int dominator();

   230     void set_dominator(int i);

   231     int parent();

   232     void set_parent(int i);

   233     int semi();

   234     GrowableArray<int>* bucket();

   235     void add_to_bucket(int i);

   236     void clear_bucket();

   237     GrowableArray<int>* pred();

   238     void set_semi(int i);

   239     void add_pred(int i);

   240 

   241   };

   242 

   243   class EdgeDescription : public Description {

   244 

   245   private:

   246 

   247     int _from;

   248     int _to;

   249     int _index;

   250   public:

   251 

   252     EdgeDescription(int from, int to, int index);

   253     ~EdgeDescription();

   254 

   255     virtual void print_changed(IdealGraphPrinter *printer);

   256     virtual void print_removed(IdealGraphPrinter *printer);

   257     bool equals(EdgeDescription *desc);

   258     int from();

   259     int to();

   260   };

   261 

   277 

    99   Compile *C;

   278   void start_element_helper(const char *name, Properties *properties, bool endElement, bool print_indent = false, bool print_return = true);

   279   NodeDescription *create_node_description(Node* node);

   299   void clear_nodes();

   107   void visit_node(Node *n, void *param);

   300 

   108   void walk_nodes(Node *start, void *param);

   109   void begin_elem(const char *s);

   110   void end_elem();

   111   void begin_head(const char *s);

   112   void end_head();

   113   void print_attr(const char *name, const char *val);

   114   void print_attr(const char *name, intptr_t val);

   115   void print_prop(const char *name, const char *val);

   116   void print_prop(const char *name, int val);

   117   void tail(const char *name);

   118   void head(const char *name);

   119   void text(const char *s);

   120   intptr_t get_node_id(Node *n);