1 /*
   2  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 // DFA.CPP - Method definitions for outputting the matcher DFA from ADLC
  26 #include "adlc.hpp"
  27 
  28 //---------------------------Switches for debugging output---------------------
  29 static bool debug_output   = false;
  30 static bool debug_output1  = false;    // top level chain rules
  31 
  32 //---------------------------Access to internals of class State----------------
  33 static const char *sLeft   = "_kids[0]";
  34 static const char *sRight  = "_kids[1]";
  35 
  36 //---------------------------DFA productions-----------------------------------
  37 static const char *dfa_production           = "DFA_PRODUCTION";
  38 static const char *dfa_production_set_valid = "DFA_PRODUCTION__SET_VALID";
  39 
  40 //---------------------------Production State----------------------------------
  41 static const char *knownInvalid = "knownInvalid";    // The result does NOT have a rule defined
  42 static const char *knownValid   = "knownValid";      // The result must be produced by a rule
  43 static const char *unknownValid = "unknownValid";    // Unknown (probably due to a child or predicate constraint)
  44 
  45 static const char *noConstraint  = "noConstraint";   // No constraints seen so far
  46 static const char *hasConstraint = "hasConstraint";  // Within the first constraint
  47 
  48 
  49 //------------------------------Production------------------------------------
  50 // Track the status of productions for a particular result
  51 class Production {
  52 public:
  53   const char *_result;
  54   const char *_constraint;
  55   const char *_valid;
  56   Expr       *_cost_lb;            // Cost lower bound for this production
  57   Expr       *_cost_ub;            // Cost upper bound for this production
  58 
  59 public:
  60   Production(const char *result, const char *constraint, const char *valid);
  61   ~Production() {};
  62 
  63   void        initialize();        // reset to be an empty container
  64 
  65   const char   *valid()  const { return _valid; }
  66   Expr       *cost_lb()  const { return (Expr *)_cost_lb;  }
  67   Expr       *cost_ub()  const { return (Expr *)_cost_ub;  }
  68 
  69   void print();
  70 };
  71 
  72 
  73 //------------------------------ProductionState--------------------------------
  74 // Track the status of all production rule results
  75 // Reset for each root opcode (e.g., Op_RegI, Op_AddI, ...)
  76 class ProductionState {
  77 private:
  78   Dict _production;    // map result of production, char*, to information or NULL
  79   const char *_constraint;
  80 
  81 public:
  82   // cmpstr does string comparisions.  hashstr computes a key.
  83   ProductionState(Arena *arena) : _production(cmpstr, hashstr, arena) { initialize(); };
  84   ~ProductionState() { };
  85 
  86   void        initialize();                // reset local and dictionary state
  87 
  88   const char *constraint();
  89   void    set_constraint(const char *constraint); // currently working inside of constraints
  90 
  91   const char *valid(const char *result);   // unknownValid, or status for this production
  92   void    set_valid(const char *result);   // if not constrained, set status to knownValid
  93 
  94   Expr           *cost_lb(const char *result);
  95   Expr           *cost_ub(const char *result);
  96   void    set_cost_bounds(const char *result, const Expr *cost, bool has_state_check, bool has_cost_check);
  97 
  98   // Return the Production associated with the result,
  99   // or create a new Production and insert it into the dictionary.
 100   Production *getProduction(const char *result);
 101 
 102   void print();
 103 
 104 private:
 105     // Disable public use of constructor, copy-ctor,  ...
 106   ProductionState( )                         : _production(cmpstr, hashstr, Form::arena) {  assert( false, "NotImplemented");  };
 107   ProductionState( const ProductionState & ) : _production(cmpstr, hashstr, Form::arena) {  assert( false, "NotImplemented");  }; // Deep-copy
 108 };
 109 
 110 
 111 //---------------------------Helper Functions----------------------------------
 112 // cost_check template:
 113 // 1)      if (STATE__NOT_YET_VALID(EBXREGI) || _cost[EBXREGI] > c) {
 114 // 2)        DFA_PRODUCTION__SET_VALID(EBXREGI, cmovI_memu_rule, c)
 115 // 3)      }
 116 //
 117 static void cost_check(FILE *fp, const char *spaces,
 118                        const char *arrayIdx, const Expr *cost, const char *rule, ProductionState &status) {
 119   bool state_check               = false;  // true if this production needs to check validity
 120   bool cost_check                = false;  // true if this production needs to check cost
 121   bool cost_is_above_upper_bound = false;  // true if this production is unnecessary due to high cost
 122   bool cost_is_below_lower_bound = false;  // true if this production replaces a higher cost production
 123 
 124   // Get information about this production
 125   const Expr *previous_ub = status.cost_ub(arrayIdx);
 126   if( !previous_ub->is_unknown() ) {
 127     if( previous_ub->less_than_or_equal(cost) ) {
 128       cost_is_above_upper_bound = true;
 129       if( debug_output ) { fprintf(fp, "// Previous rule with lower cost than: %s === %s_rule costs %s\n", arrayIdx, rule, cost->as_string()); }
 130     }
 131   }
 132 
 133   const Expr *previous_lb = status.cost_lb(arrayIdx);
 134   if( !previous_lb->is_unknown() ) {
 135     if( cost->less_than_or_equal(previous_lb) ) {
 136       cost_is_below_lower_bound = true;
 137       if( debug_output ) { fprintf(fp, "// Previous rule with higher cost\n"); }
 138     }
 139   }
 140 
 141   // line 1)
 142   // Check for validity and compare to other match costs
 143   const char *validity_check = status.valid(arrayIdx);
 144   if( validity_check == unknownValid ) {
 145     fprintf(fp, "%sif (STATE__NOT_YET_VALID(%s) || _cost[%s] > %s) {\n",  spaces, arrayIdx, arrayIdx, cost->as_string());
 146     state_check = true;
 147     cost_check  = true;
 148   }
 149   else if( validity_check == knownInvalid ) {
 150     if( debug_output ) { fprintf(fp, "%s// %s KNOWN_INVALID \n",  spaces, arrayIdx); }
 151   }
 152   else if( validity_check == knownValid ) {
 153     if( cost_is_above_upper_bound ) {
 154       // production cost is known to be too high.
 155       return;
 156     } else if( cost_is_below_lower_bound ) {
 157       // production will unconditionally overwrite a previous production that had higher cost
 158     } else {
 159       fprintf(fp, "%sif ( /* %s KNOWN_VALID || */ _cost[%s] > %s) {\n",  spaces, arrayIdx, arrayIdx, cost->as_string());
 160       cost_check  = true;
 161     }
 162   }
 163 
 164   // line 2)
 165   // no need to set State vector if our state is knownValid
 166   const char *production = (validity_check == knownValid) ? dfa_production : dfa_production_set_valid;
 167   fprintf(fp, "%s  %s(%s, %s_rule, %s)", spaces, production, arrayIdx, rule, cost->as_string() );
 168   if( validity_check == knownValid ) {
 169     if( cost_is_below_lower_bound ) { fprintf(fp, "\t  // overwrites higher cost rule"); }
 170    }
 171    fprintf(fp, "\n");
 172 
 173   // line 3)
 174   if( cost_check || state_check ) {
 175     fprintf(fp, "%s}\n", spaces);
 176   }
 177 
 178   status.set_cost_bounds(arrayIdx, cost, state_check, cost_check);
 179 
 180   // Update ProductionState
 181   if( validity_check != knownValid ) {
 182     // set State vector if not previously known
 183     status.set_valid(arrayIdx);
 184   }
 185 }
 186 
 187 
 188 //---------------------------child_test----------------------------------------
 189 // Example:
 190 //   STATE__VALID_CHILD(_kids[0], FOO) &&  STATE__VALID_CHILD(_kids[1], BAR)
 191 // Macro equivalent to: _kids[0]->valid(FOO) && _kids[1]->valid(BAR)
 192 //
 193 static void child_test(FILE *fp, MatchList &mList) {
 194   if (mList._lchild) { // If left child, check it
 195     const char* lchild_to_upper = ArchDesc::getMachOperEnum(mList._lchild);
 196     fprintf(fp, "STATE__VALID_CHILD(_kids[0], %s)", lchild_to_upper);
 197     delete[] lchild_to_upper;
 198   }
 199   if (mList._lchild && mList._rchild) { // If both, add the "&&"
 200     fprintf(fp, " && ");
 201   }
 202   if (mList._rchild) { // If right child, check it
 203     const char* rchild_to_upper = ArchDesc::getMachOperEnum(mList._rchild);
 204     fprintf(fp, "STATE__VALID_CHILD(_kids[1], %s)", rchild_to_upper);
 205     delete[] rchild_to_upper;
 206   }
 207 }
 208 
 209 //---------------------------calc_cost-----------------------------------------
 210 // Example:
 211 //           unsigned int c = _kids[0]->_cost[FOO] + _kids[1]->_cost[BAR] + 5;
 212 //
 213 Expr *ArchDesc::calc_cost(FILE *fp, const char *spaces, MatchList &mList, ProductionState &status) {
 214   fprintf(fp, "%sunsigned int c = ", spaces);
 215   Expr *c = new Expr("0");
 216   if (mList._lchild) { // If left child, add it in
 217     const char* lchild_to_upper = ArchDesc::getMachOperEnum(mList._lchild);
 218     sprintf(Expr::buffer(), "_kids[0]->_cost[%s]", lchild_to_upper);
 219     c->add(Expr::buffer());
 220     delete[] lchild_to_upper;
 221 }
 222   if (mList._rchild) { // If right child, add it in
 223     const char* rchild_to_upper = ArchDesc::getMachOperEnum(mList._rchild);
 224     sprintf(Expr::buffer(), "_kids[1]->_cost[%s]", rchild_to_upper);
 225     c->add(Expr::buffer());
 226     delete[] rchild_to_upper;
 227   }
 228   // Add in cost of this rule
 229   const char *mList_cost = mList.get_cost();
 230   c->add(mList_cost, *this);
 231 
 232   fprintf(fp, "%s;\n", c->as_string());
 233   c->set_external_name("c");
 234   return c;
 235 }
 236 
 237 
 238 //---------------------------gen_match-----------------------------------------
 239 void ArchDesc::gen_match(FILE *fp, MatchList &mList, ProductionState &status, Dict &operands_chained_from) {
 240   const char *spaces4 = "    ";
 241   const char *spaces6 = "      ";
 242 
 243   fprintf(fp, "%s", spaces4);
 244   // Only generate child tests if this is not a leaf node
 245   bool has_child_constraints = mList._lchild || mList._rchild;
 246   const char *predicate_test = mList.get_pred();
 247   if (has_child_constraints || predicate_test) {
 248     // Open the child-and-predicate-test braces
 249     fprintf(fp, "if( ");
 250     status.set_constraint(hasConstraint);
 251     child_test(fp, mList);
 252     // Only generate predicate test if one exists for this match
 253     if (predicate_test) {
 254       if (has_child_constraints) {
 255         fprintf(fp," &&\n");
 256       }
 257       fprintf(fp, "%s  %s", spaces6, predicate_test);
 258     }
 259     // End of outer tests
 260     fprintf(fp," ) ");
 261   } else {
 262     // No child or predicate test needed
 263     status.set_constraint(noConstraint);
 264   }
 265 
 266   // End of outer tests
 267   fprintf(fp,"{\n");
 268 
 269   // Calculate cost of this match
 270   const Expr *cost = calc_cost(fp, spaces6, mList, status);
 271   // Check against other match costs, and update cost & rule vectors
 272   cost_check(fp, spaces6, ArchDesc::getMachOperEnum(mList._resultStr), cost, mList._opcode, status);
 273 
 274   // If this is a member of an operand class, update the class cost & rule
 275   expand_opclass( fp, spaces6, cost, mList._resultStr, status);
 276 
 277   // Check if this rule should be used to generate the chains as well.
 278   const char *rule = /* set rule to "Invalid" for internal operands */
 279     strcmp(mList._opcode,mList._resultStr) ? mList._opcode : "Invalid";
 280 
 281   // If this rule produces an operand which has associated chain rules,
 282   // update the operands with the chain rule + this rule cost & this rule.
 283   chain_rule(fp, spaces6, mList._resultStr, cost, rule, operands_chained_from, status);
 284 
 285   // Close the child-and-predicate-test braces
 286   fprintf(fp, "    }\n");
 287 
 288 }
 289 
 290 
 291 //---------------------------expand_opclass------------------------------------
 292 // Chain from one result_type to all other members of its operand class
 293 void ArchDesc::expand_opclass(FILE *fp, const char *indent, const Expr *cost,
 294                               const char *result_type, ProductionState &status) {
 295   const Form *form = _globalNames[result_type];
 296   OperandForm *op = form ? form->is_operand() : NULL;
 297   if( op && op->_classes.count() > 0 ) {
 298     if( debug_output ) { fprintf(fp, "// expand operand classes for operand: %s \n", (char *)op->_ident  ); } // %%%%% Explanation
 299     // Iterate through all operand classes which include this operand
 300     op->_classes.reset();
 301     const char *oclass;
 302     // Expr *cCost = new Expr(cost);
 303     while( (oclass = op->_classes.iter()) != NULL )
 304       // Check against other match costs, and update cost & rule vectors
 305       cost_check(fp, indent, ArchDesc::getMachOperEnum(oclass), cost, result_type, status);
 306   }
 307 }
 308 
 309 //---------------------------chain_rule----------------------------------------
 310 // Starting at 'operand', check if we know how to automatically generate other results
 311 void ArchDesc::chain_rule(FILE *fp, const char *indent, const char *operand,
 312      const Expr *icost, const char *irule, Dict &operands_chained_from,  ProductionState &status) {
 313 
 314   // Check if we have already generated chains from this starting point
 315   if( operands_chained_from[operand] != NULL ) {
 316     return;
 317   } else {
 318     operands_chained_from.Insert( operand, operand);
 319   }
 320   if( debug_output ) { fprintf(fp, "// chain rules starting from: %s  and  %s \n", (char *)operand, (char *)irule); } // %%%%% Explanation
 321 
 322   ChainList *lst = (ChainList *)_chainRules[operand];
 323   if (lst) {
 324     // printf("\nChain from <%s> at cost #%s\n",operand, icost ? icost : "_");
 325     const char *result, *cost, *rule;
 326     for(lst->reset(); (lst->iter(result,cost,rule)) == true; ) {
 327       // Do not generate operands that are already available
 328       if( operands_chained_from[result] != NULL ) {
 329         continue;
 330       } else {
 331         // Compute the cost for previous match + chain_rule_cost
 332         // total_cost = icost + cost;
 333         Expr *total_cost = icost->clone();  // icost + cost
 334         total_cost->add(cost, *this);
 335 
 336         // Check for transitive chain rules
 337         Form *form = (Form *)_globalNames[rule];
 338         if ( ! form->is_instruction()) {
 339           // printf("   result=%s cost=%s rule=%s\n", result, total_cost, rule);
 340           // Check against other match costs, and update cost & rule vectors
 341           const char *reduce_rule = strcmp(irule,"Invalid") ? irule : rule;
 342           cost_check(fp, indent, ArchDesc::getMachOperEnum(result), total_cost, reduce_rule, status);
 343           chain_rule(fp, indent, result, total_cost, irule, operands_chained_from, status);
 344         } else {
 345           // printf("   result=%s cost=%s rule=%s\n", result, total_cost, rule);
 346           // Check against other match costs, and update cost & rule vectors
 347           cost_check(fp, indent, ArchDesc::getMachOperEnum(result), total_cost, rule, status);
 348           chain_rule(fp, indent, result, total_cost, rule, operands_chained_from, status);
 349         }
 350 
 351         // If this is a member of an operand class, update class cost & rule
 352         expand_opclass( fp, indent, total_cost, result, status );
 353       }
 354     }
 355   }
 356 }
 357 
 358 //---------------------------prune_matchlist-----------------------------------
 359 // Check for duplicate entries in a matchlist, and prune out the higher cost
 360 // entry.
 361 void ArchDesc::prune_matchlist(Dict &minimize, MatchList &mlist) {
 362 
 363 }
 364 
 365 //---------------------------buildDFA------------------------------------------
 366 // DFA is a large switch with case statements for each ideal opcode encountered
 367 // in any match rule in the ad file.  Each case has a series of if's to handle
 368 // the match or fail decisions.  The matches test the cost function of that
 369 // rule, and prune any cases which are higher cost for the same reduction.
 370 // In order to generate the DFA we walk the table of ideal opcode/MatchList
 371 // pairs generated by the ADLC front end to build the contents of the case
 372 // statements (a series of if statements).
 373 void ArchDesc::buildDFA(FILE* fp) {
 374   int i;
 375   // Remember operands that are the starting points for chain rules.
 376   // Prevent cycles by checking if we have already generated chain.
 377   Dict operands_chained_from(cmpstr, hashstr, Form::arena);
 378 
 379   // Hash inputs to match rules so that final DFA contains only one entry for
 380   // each match pattern which is the low cost entry.
 381   Dict minimize(cmpstr, hashstr, Form::arena);
 382 
 383   // Track status of dfa for each resulting production
 384   // reset for each ideal root.
 385   ProductionState status(Form::arena);
 386 
 387   // Output the start of the DFA method into the output file
 388 
 389   fprintf(fp, "\n");
 390   fprintf(fp, "//------------------------- Source -----------------------------------------\n");
 391   // Do not put random source code into the DFA.
 392   // If there are constants which need sharing, put them in "source_hpp" forms.
 393   // _source.output(fp);
 394   fprintf(fp, "\n");
 395   fprintf(fp, "//------------------------- Attributes -------------------------------------\n");
 396   _attributes.output(fp);
 397   fprintf(fp, "\n");
 398   fprintf(fp, "//------------------------- Macros -----------------------------------------\n");
 399   // #define DFA_PRODUCTION(result, rule, cost)\
 400   //   _cost[ (result) ] = cost; _rule[ (result) ] = rule;
 401   fprintf(fp, "#define %s(result, rule, cost)\\\n", dfa_production);
 402   fprintf(fp, "  _cost[ (result) ] = cost; _rule[ (result) ] = rule;\n");
 403   fprintf(fp, "\n");
 404 
 405   // #define DFA_PRODUCTION__SET_VALID(result, rule, cost)\
 406   //     DFA_PRODUCTION( (result), (rule), (cost) ); STATE__SET_VALID( (result) );
 407   fprintf(fp, "#define %s(result, rule, cost)\\\n", dfa_production_set_valid);
 408   fprintf(fp, "  %s( (result), (rule), (cost) ); STATE__SET_VALID( (result) );\n", dfa_production);
 409   fprintf(fp, "\n");
 410 
 411   fprintf(fp, "//------------------------- DFA --------------------------------------------\n");
 412 
 413   fprintf(fp,
 414 "// DFA is a large switch with case statements for each ideal opcode encountered\n"
 415 "// in any match rule in the ad file.  Each case has a series of if's to handle\n"
 416 "// the match or fail decisions.  The matches test the cost function of that\n"
 417 "// rule, and prune any cases which are higher cost for the same reduction.\n"
 418 "// In order to generate the DFA we walk the table of ideal opcode/MatchList\n"
 419 "// pairs generated by the ADLC front end to build the contents of the case\n"
 420 "// statements (a series of if statements).\n"
 421 );
 422   fprintf(fp, "\n");
 423   fprintf(fp, "\n");
 424   if (_dfa_small) {
 425     // Now build the individual routines just like the switch entries in large version
 426     // Iterate over the table of MatchLists, start at first valid opcode of 1
 427     for (i = 1; i < _last_opcode; i++) {
 428       if (_mlistab[i] == NULL) continue;
 429       // Generate the routine header statement for this opcode
 430       fprintf(fp, "void  State::_sub_Op_%s(const Node *n){\n", NodeClassNames[i]);
 431       // Generate body. Shared for both inline and out-of-line version
 432       gen_dfa_state_body(fp, minimize, status, operands_chained_from, i);
 433       // End of routine
 434       fprintf(fp, "}\n");
 435     }
 436   }
 437   fprintf(fp, "bool State::DFA");
 438   fprintf(fp, "(int opcode, const Node *n) {\n");
 439   fprintf(fp, "  switch(opcode) {\n");
 440 
 441   // Iterate over the table of MatchLists, start at first valid opcode of 1
 442   for (i = 1; i < _last_opcode; i++) {
 443     if (_mlistab[i] == NULL) continue;
 444     // Generate the case statement for this opcode
 445     if (_dfa_small) {
 446       fprintf(fp, "  case Op_%s: { _sub_Op_%s(n);\n", NodeClassNames[i], NodeClassNames[i]);
 447     } else {
 448       fprintf(fp, "  case Op_%s: {\n", NodeClassNames[i]);
 449       // Walk the list, compacting it
 450       gen_dfa_state_body(fp, minimize, status, operands_chained_from, i);
 451     }
 452     // Print the "break"
 453     fprintf(fp, "    break;\n");
 454     fprintf(fp, "  }\n");
 455   }
 456 
 457   // Generate the default case for switch(opcode)
 458   fprintf(fp, "  \n");
 459   fprintf(fp, "  default:\n");
 460   fprintf(fp, "    tty->print(\"Default case invoked for: \\n\");\n");
 461   fprintf(fp, "    tty->print(\"   opcode  = %cd, \\\"%cs\\\"\\n\", opcode, NodeClassNames[opcode]);\n", '%', '%');
 462   fprintf(fp, "    return false;\n");
 463   fprintf(fp, "  }\n");
 464 
 465   // Return status, indicating a successful match.
 466   fprintf(fp, "  return true;\n");
 467   // Generate the closing brace for method Matcher::DFA
 468   fprintf(fp, "}\n");
 469   Expr::check_buffers();
 470 }
 471 
 472 
 473 class dfa_shared_preds {
 474   enum { count = 4 };
 475 
 476   static bool        _found[count];
 477   static const char* _type [count];
 478   static const char* _var  [count];
 479   static const char* _pred [count];
 480 
 481   static void check_index(int index) { assert( 0 <= index && index < count, "Invalid index"); }
 482 
 483   // Confirm that this is a separate sub-expression.
 484   // Only need to catch common cases like " ... && shared ..."
 485   // and avoid hazardous ones like "...->shared"
 486   static bool valid_loc(char *pred, char *shared) {
 487     // start of predicate is valid
 488     if( shared == pred ) return true;
 489 
 490     // Check previous character and recurse if needed
 491     char *prev = shared - 1;
 492     char c  = *prev;
 493     switch( c ) {
 494     case ' ':
 495     case '\n':
 496       return dfa_shared_preds::valid_loc(pred, prev);
 497     case '!':
 498     case '(':
 499     case '<':
 500     case '=':
 501       return true;
 502     case '"':  // such as: #line 10 "myfile.ad"\n mypredicate
 503       return true;
 504     case '|':
 505       if( prev != pred && *(prev-1) == '|' ) return true;
 506     case '&':
 507       if( prev != pred && *(prev-1) == '&' ) return true;
 508     default:
 509       return false;
 510     }
 511 
 512     return false;
 513   }
 514 
 515 public:
 516 
 517   static bool        found(int index){ check_index(index); return _found[index]; }
 518   static void    set_found(int index, bool val) { check_index(index); _found[index] = val; }
 519   static void  reset_found() {
 520     for( int i = 0; i < count; ++i ) { _found[i] = false; }
 521   };
 522 
 523   static const char* type(int index) { check_index(index); return _type[index]; }
 524   static const char* var (int index) { check_index(index); return _var [index];  }
 525   static const char* pred(int index) { check_index(index); return _pred[index]; }
 526 
 527   // Check each predicate in the MatchList for common sub-expressions
 528   static void cse_matchlist(MatchList *matchList) {
 529     for( MatchList *mList = matchList; mList != NULL; mList = mList->get_next() ) {
 530       Predicate* predicate = mList->get_pred_obj();
 531       char*      pred      = mList->get_pred();
 532       if( pred != NULL ) {
 533         for(int index = 0; index < count; ++index ) {
 534           const char *shared_pred      = dfa_shared_preds::pred(index);
 535           const char *shared_pred_var  = dfa_shared_preds::var(index);
 536           bool result = dfa_shared_preds::cse_predicate(predicate, shared_pred, shared_pred_var);
 537           if( result ) dfa_shared_preds::set_found(index, true);
 538         }
 539       }
 540     }
 541   }
 542 
 543   // If the Predicate contains a common sub-expression, replace the Predicate's
 544   // string with one that uses the variable name.
 545   static bool cse_predicate(Predicate* predicate, const char *shared_pred, const char *shared_pred_var) {
 546     bool result = false;
 547     char *pred = predicate->_pred;
 548     if( pred != NULL ) {
 549       char *new_pred = pred;
 550       for( char *shared_pred_loc = strstr(new_pred, shared_pred);
 551       shared_pred_loc != NULL && dfa_shared_preds::valid_loc(new_pred,shared_pred_loc);
 552       shared_pred_loc = strstr(new_pred, shared_pred) ) {
 553         // Do not modify the original predicate string, it is shared
 554         if( new_pred == pred ) {
 555           new_pred = strdup(pred);
 556           shared_pred_loc = strstr(new_pred, shared_pred);
 557         }
 558         // Replace shared_pred with variable name
 559         strncpy(shared_pred_loc, shared_pred_var, strlen(shared_pred_var));
 560       }
 561       // Install new predicate
 562       if( new_pred != pred ) {
 563         predicate->_pred = new_pred;
 564         result = true;
 565       }
 566     }
 567     return result;
 568   }
 569 
 570   // Output the hoisted common sub-expression if we found it in predicates
 571   static void generate_cse(FILE *fp) {
 572     for(int j = 0; j < count; ++j ) {
 573       if( dfa_shared_preds::found(j) ) {
 574         const char *shared_pred_type = dfa_shared_preds::type(j);
 575         const char *shared_pred_var  = dfa_shared_preds::var(j);
 576         const char *shared_pred      = dfa_shared_preds::pred(j);
 577         fprintf(fp, "    %s %s = %s;\n", shared_pred_type, shared_pred_var, shared_pred);
 578       }
 579     }
 580   }
 581 };
 582 // shared predicates, _var and _pred entry should be the same length
 583 bool         dfa_shared_preds::_found[dfa_shared_preds::count]
 584   = { false, false, false, false };
 585 const char*  dfa_shared_preds::_type[dfa_shared_preds::count]
 586   = { "int", "jlong", "intptr_t", "bool" };
 587 const char*  dfa_shared_preds::_var [dfa_shared_preds::count]
 588   = { "_n_get_int__", "_n_get_long__", "_n_get_intptr_t__", "Compile__current____select_24_bit_instr__" };
 589 const char*  dfa_shared_preds::_pred[dfa_shared_preds::count]
 590   = { "n->get_int()", "n->get_long()", "n->get_intptr_t()", "Compile::current()->select_24_bit_instr()" };
 591 
 592 
 593 void ArchDesc::gen_dfa_state_body(FILE* fp, Dict &minimize, ProductionState &status, Dict &operands_chained_from, int i) {
 594   // Start the body of each Op_XXX sub-dfa with a clean state.
 595   status.initialize();
 596 
 597   // Walk the list, compacting it
 598   MatchList* mList = _mlistab[i];
 599   do {
 600     // Hash each entry using inputs as key and pointer as data.
 601     // If there is already an entry, keep the one with lower cost, and
 602     // remove the other one from the list.
 603     prune_matchlist(minimize, *mList);
 604     // Iterate
 605     mList = mList->get_next();
 606   } while(mList != NULL);
 607 
 608   // Hoist previously specified common sub-expressions out of predicates
 609   dfa_shared_preds::reset_found();
 610   dfa_shared_preds::cse_matchlist(_mlistab[i]);
 611   dfa_shared_preds::generate_cse(fp);
 612 
 613   mList = _mlistab[i];
 614 
 615   // Walk the list again, generating code
 616   do {
 617     // Each match can generate its own chains
 618     operands_chained_from.Clear();
 619     gen_match(fp, *mList, status, operands_chained_from);
 620     mList = mList->get_next();
 621   } while(mList != NULL);
 622   // Fill in any chain rules which add instructions
 623   // These can generate their own chains as well.
 624   operands_chained_from.Clear();  //
 625   if( debug_output1 ) { fprintf(fp, "// top level chain rules for: %s \n", (char *)NodeClassNames[i]); } // %%%%% Explanation
 626   const Expr *zeroCost = new Expr("0");
 627   chain_rule(fp, "   ", (char *)NodeClassNames[i], zeroCost, "Invalid",
 628              operands_chained_from, status);
 629 }
 630 
 631 
 632 
 633 //------------------------------Expr------------------------------------------
 634 Expr *Expr::_unknown_expr = NULL;
 635 char  Expr::string_buffer[STRING_BUFFER_LENGTH];
 636 char  Expr::external_buffer[STRING_BUFFER_LENGTH];
 637 bool  Expr::_init_buffers = Expr::init_buffers();
 638 
 639 Expr::Expr() {
 640   _external_name = NULL;
 641   _expr          = "Invalid_Expr";
 642   _min_value     = Expr::Max;
 643   _max_value     = Expr::Zero;
 644 }
 645 Expr::Expr(const char *cost) {
 646   _external_name = NULL;
 647 
 648   int intval = 0;
 649   if( cost == NULL ) {
 650     _expr = "0";
 651     _min_value = Expr::Zero;
 652     _max_value = Expr::Zero;
 653   }
 654   else if( ADLParser::is_int_token(cost, intval) ) {
 655     _expr = cost;
 656     _min_value = intval;
 657     _max_value = intval;
 658   }
 659   else {
 660     assert( strcmp(cost,"0") != 0, "Recognize string zero as an int");
 661     _expr = cost;
 662     _min_value = Expr::Zero;
 663     _max_value = Expr::Max;
 664   }
 665 }
 666 
 667 Expr::Expr(const char *name, const char *expression, int min_value, int max_value) {
 668   _external_name = name;
 669   _expr          = expression ? expression : name;
 670   _min_value     = min_value;
 671   _max_value     = max_value;
 672   assert(_min_value >= 0 && _min_value <= Expr::Max, "value out of range");
 673   assert(_max_value >= 0 && _max_value <= Expr::Max, "value out of range");
 674 }
 675 
 676 Expr *Expr::clone() const {
 677   Expr *cost = new Expr();
 678   cost->_external_name = _external_name;
 679   cost->_expr          = _expr;
 680   cost->_min_value     = _min_value;
 681   cost->_max_value     = _max_value;
 682 
 683   return cost;
 684 }
 685 
 686 void Expr::add(const Expr *c) {
 687   // Do not update fields until all computation is complete
 688   const char *external  = compute_external(this, c);
 689   const char *expr      = compute_expr(this, c);
 690   int         min_value = compute_min (this, c);
 691   int         max_value = compute_max (this, c);
 692 
 693   _external_name = external;
 694   _expr      = expr;
 695   _min_value = min_value;
 696   _max_value = max_value;
 697 }
 698 
 699 void Expr::add(const char *c) {
 700   Expr *cost = new Expr(c);
 701   add(cost);
 702 }
 703 
 704 void Expr::add(const char *c, ArchDesc &AD) {
 705   const Expr *e = AD.globalDefs()[c];
 706   if( e != NULL ) {
 707     // use the value of 'c' defined in <arch>.ad
 708     add(e);
 709   } else {
 710     Expr *cost = new Expr(c);
 711     add(cost);
 712   }
 713 }
 714 
 715 const char *Expr::compute_external(const Expr *c1, const Expr *c2) {
 716   const char * result = NULL;
 717 
 718   // Preserve use of external name which has a zero value
 719   if (c1->_external_name != NULL) {
 720     if (c2->is_zero()) {
 721       snprintf(string_buffer, STRING_BUFFER_LENGTH, "%s", c1->as_string());
 722     } else {
 723       snprintf(string_buffer, STRING_BUFFER_LENGTH, "%s + %s", c1->as_string(), c2->as_string());
 724     }
 725     result = strdup(string_buffer);
 726   } else if (c2->_external_name != NULL) {
 727     if (!c1->is_zero()) {
 728       snprintf(string_buffer, STRING_BUFFER_LENGTH, "%s + %s", c1->as_string(), c2->_external_name);
 729     } else {
 730       snprintf(string_buffer, STRING_BUFFER_LENGTH, "%s", c2->_external_name);
 731     }
 732     result = strdup(string_buffer);
 733   }
 734   return result;
 735 }
 736 
 737 const char *Expr::compute_expr(const Expr *c1, const Expr *c2) {
 738   if (!c1->is_zero()) {
 739     if (c2->is_zero()) {
 740       snprintf(string_buffer, STRING_BUFFER_LENGTH, "%s", c1->_expr);
 741     } else {
 742       snprintf(string_buffer, STRING_BUFFER_LENGTH, "%s + %s", c1->_expr, c2->_expr);
 743     }
 744   } else if (!c2->is_zero()) {
 745     sprintf(string_buffer, "%s", c2->_expr);
 746   } else {
 747     sprintf(string_buffer, "0");
 748   }
 749   char *cost = strdup(string_buffer);
 750 
 751   return cost;
 752 }
 753 
 754 int Expr::compute_min(const Expr *c1, const Expr *c2) {
 755   int result = c1->_min_value + c2->_min_value;
 756   assert( result >= 0, "Invalid cost computation");
 757 
 758   return result;
 759 }
 760 
 761 int Expr::compute_max(const Expr *c1, const Expr *c2) {
 762   int result = c1->_max_value + c2->_max_value;
 763   if( result < 0 ) {  // check for overflow
 764     result = Expr::Max;
 765   }
 766 
 767   return result;
 768 }
 769 
 770 void Expr::print() const {
 771   if( _external_name != NULL ) {
 772     printf("  %s == (%s) === [%d, %d]\n", _external_name, _expr, _min_value, _max_value);
 773   } else {
 774     printf("  %s === [%d, %d]\n", _expr, _min_value, _max_value);
 775   }
 776 }
 777 
 778 void Expr::print_define(FILE *fp) const {
 779   assert( _external_name != NULL, "definition does not have a name");
 780   assert( _min_value == _max_value, "Expect user definitions to have constant value");
 781   fprintf(fp, "#define  %s  (%s)  \n", _external_name, _expr);
 782   fprintf(fp, "// value == %d \n", _min_value);
 783 }
 784 
 785 void Expr::print_assert(FILE *fp) const {
 786   assert( _external_name != NULL, "definition does not have a name");
 787   assert( _min_value == _max_value, "Expect user definitions to have constant value");
 788   fprintf(fp, "  assert( %s == %d, \"Expect (%s) to equal %d\");\n", _external_name, _min_value, _expr, _min_value);
 789 }
 790 
 791 Expr *Expr::get_unknown() {
 792   if( Expr::_unknown_expr == NULL ) {
 793     Expr::_unknown_expr = new Expr();
 794   }
 795 
 796   return Expr::_unknown_expr;
 797 }
 798 
 799 bool Expr::init_buffers() {
 800   // Fill buffers with 0
 801   for( int i = 0; i < STRING_BUFFER_LENGTH; ++i ) {
 802     external_buffer[i] = '\0';
 803     string_buffer[i]   = '\0';
 804   }
 805 
 806   return true;
 807 }
 808 
 809 bool Expr::check_buffers() {
 810   // returns 'true' if buffer use may have overflowed
 811   bool ok = true;
 812   for( int i = STRING_BUFFER_LENGTH - 100; i < STRING_BUFFER_LENGTH; ++i) {
 813     if( external_buffer[i] != '\0' || string_buffer[i]   != '\0' ) {
 814       ok = false;
 815       assert( false, "Expr:: Buffer overflow");
 816     }
 817   }
 818 
 819   return ok;
 820 }
 821 
 822 
 823 //------------------------------ExprDict---------------------------------------
 824 // Constructor
 825 ExprDict::ExprDict( CmpKey cmp, Hash hash, Arena *arena )
 826   : _expr(cmp, hash, arena), _defines()  {
 827 }
 828 ExprDict::~ExprDict() {
 829 }
 830 
 831 // Return # of name-Expr pairs in dict
 832 int ExprDict::Size(void) const {
 833   return _expr.Size();
 834 }
 835 
 836 // define inserts the given key-value pair into the dictionary,
 837 // and records the name in order for later output, ...
 838 const Expr  *ExprDict::define(const char *name, Expr *expr) {
 839   const Expr *old_expr = (*this)[name];
 840   assert(old_expr == NULL, "Implementation does not support redefinition");
 841 
 842   _expr.Insert(name, expr);
 843   _defines.addName(name);
 844 
 845   return old_expr;
 846 }
 847 
 848 // Insert inserts the given key-value pair into the dictionary.  The prior
 849 // value of the key is returned; NULL if the key was not previously defined.
 850 const Expr  *ExprDict::Insert(const char *name, Expr *expr) {
 851   return (Expr*)_expr.Insert((void*)name, (void*)expr);
 852 }
 853 
 854 // Finds the value of a given key; or NULL if not found.
 855 // The dictionary is NOT changed.
 856 const Expr  *ExprDict::operator [](const char *name) const {
 857   return (Expr*)_expr[name];
 858 }
 859 
 860 void ExprDict::print_defines(FILE *fp) {
 861   fprintf(fp, "\n");
 862   const char *name = NULL;
 863   for( _defines.reset(); (name = _defines.iter()) != NULL; ) {
 864     const Expr *expr = (const Expr*)_expr[name];
 865     assert( expr != NULL, "name in ExprDict without matching Expr in dictionary");
 866     expr->print_define(fp);
 867   }
 868 }
 869 void ExprDict::print_asserts(FILE *fp) {
 870   fprintf(fp, "\n");
 871   fprintf(fp, "  // Following assertions generated from definition section\n");
 872   const char *name = NULL;
 873   for( _defines.reset(); (name = _defines.iter()) != NULL; ) {
 874     const Expr *expr = (const Expr*)_expr[name];
 875     assert( expr != NULL, "name in ExprDict without matching Expr in dictionary");
 876     expr->print_assert(fp);
 877   }
 878 }
 879 
 880 // Print out the dictionary contents as key-value pairs
 881 static void dumpekey(const void* key)  { fprintf(stdout, "%s", (char*) key); }
 882 static void dumpexpr(const void* expr) { fflush(stdout); ((Expr*)expr)->print(); }
 883 
 884 void ExprDict::dump() {
 885   _expr.print(dumpekey, dumpexpr);
 886 }
 887 
 888 
 889 //------------------------------ExprDict::private------------------------------
 890 // Disable public use of constructor, copy-ctor, operator =, operator ==
 891 ExprDict::ExprDict( ) : _expr(cmpkey,hashkey), _defines()  {
 892   assert( false, "NotImplemented");
 893 }
 894 ExprDict::ExprDict( const ExprDict & ) : _expr(cmpkey,hashkey), _defines() {
 895   assert( false, "NotImplemented");
 896 }
 897 ExprDict &ExprDict::operator =( const ExprDict &rhs) {
 898   assert( false, "NotImplemented");
 899   _expr = rhs._expr;
 900   return *this;
 901 }
 902 // == compares two dictionaries; they must have the same keys (their keys
 903 // must match using CmpKey) and they must have the same values (pointer
 904 // comparison).  If so 1 is returned, if not 0 is returned.
 905 bool ExprDict::operator ==(const ExprDict &d) const {
 906   assert( false, "NotImplemented");
 907   return false;
 908 }
 909 
 910 
 911 //------------------------------Production-------------------------------------
 912 Production::Production(const char *result, const char *constraint, const char *valid) {
 913   initialize();
 914   _result     = result;
 915   _constraint = constraint;
 916   _valid      = valid;
 917 }
 918 
 919 void Production::initialize() {
 920   _result     = NULL;
 921   _constraint = NULL;
 922   _valid      = knownInvalid;
 923   _cost_lb    = Expr::get_unknown();
 924   _cost_ub    = Expr::get_unknown();
 925 }
 926 
 927 void Production::print() {
 928   printf("%s", (_result     == NULL ? "NULL" : _result ) );
 929   printf("%s", (_constraint == NULL ? "NULL" : _constraint ) );
 930   printf("%s", (_valid      == NULL ? "NULL" : _valid ) );
 931   _cost_lb->print();
 932   _cost_ub->print();
 933 }
 934 
 935 
 936 //------------------------------ProductionState--------------------------------
 937 void ProductionState::initialize() {
 938   _constraint = noConstraint;
 939 
 940   // reset each Production currently in the dictionary
 941   DictI iter( &_production );
 942   const void *x, *y = NULL;
 943   for( ; iter.test(); ++iter) {
 944     x = iter._key;
 945     y = iter._value;
 946     Production *p = (Production*)y;
 947     if( p != NULL ) {
 948       p->initialize();
 949     }
 950   }
 951 }
 952 
 953 Production *ProductionState::getProduction(const char *result) {
 954   Production *p = (Production *)_production[result];
 955   if( p == NULL ) {
 956     p = new Production(result, _constraint, knownInvalid);
 957     _production.Insert(result, p);
 958   }
 959 
 960   return p;
 961 }
 962 
 963 void ProductionState::set_constraint(const char *constraint) {
 964   _constraint = constraint;
 965 }
 966 
 967 const char *ProductionState::valid(const char *result) {
 968   return getProduction(result)->valid();
 969 }
 970 
 971 void ProductionState::set_valid(const char *result) {
 972   Production *p = getProduction(result);
 973 
 974   // Update valid as allowed by current constraints
 975   if( _constraint == noConstraint ) {
 976     p->_valid = knownValid;
 977   } else {
 978     if( p->_valid != knownValid ) {
 979       p->_valid = unknownValid;
 980     }
 981   }
 982 }
 983 
 984 Expr *ProductionState::cost_lb(const char *result) {
 985   return getProduction(result)->cost_lb();
 986 }
 987 
 988 Expr *ProductionState::cost_ub(const char *result) {
 989   return getProduction(result)->cost_ub();
 990 }
 991 
 992 void ProductionState::set_cost_bounds(const char *result, const Expr *cost, bool has_state_check, bool has_cost_check) {
 993   Production *p = getProduction(result);
 994 
 995   if( p->_valid == knownInvalid ) {
 996     // Our cost bounds are not unknown, just not defined.
 997     p->_cost_lb = cost->clone();
 998     p->_cost_ub = cost->clone();
 999   } else if (has_state_check || _constraint != noConstraint) {
1000     // The production is protected by a condition, so
1001     // the cost bounds may expand.
1002     // _cost_lb = min(cost, _cost_lb)
1003     if( cost->less_than_or_equal(p->_cost_lb) ) {
1004       p->_cost_lb = cost->clone();
1005     }
1006     // _cost_ub = max(cost, _cost_ub)
1007     if( p->_cost_ub->less_than_or_equal(cost) ) {
1008       p->_cost_ub = cost->clone();
1009     }
1010   } else if (has_cost_check) {
1011     // The production has no condition check, but does
1012     // have a cost check that could reduce the upper
1013     // and/or lower bound.
1014     // _cost_lb = min(cost, _cost_lb)
1015     if( cost->less_than_or_equal(p->_cost_lb) ) {
1016       p->_cost_lb = cost->clone();
1017     }
1018     // _cost_ub = min(cost, _cost_ub)
1019     if( cost->less_than_or_equal(p->_cost_ub) ) {
1020       p->_cost_ub = cost->clone();
1021     }
1022   } else {
1023     // The costs are unconditionally set.
1024     p->_cost_lb = cost->clone();
1025     p->_cost_ub = cost->clone();
1026   }
1027 
1028 }
1029 
1030 // Print out the dictionary contents as key-value pairs
1031 static void print_key (const void* key)              { fprintf(stdout, "%s", (char*) key); }
1032 static void print_production(const void* production) { fflush(stdout); ((Production*)production)->print(); }
1033 
1034 void ProductionState::print() {
1035   _production.print(print_key, print_production);
1036 }