1 /*
   2  * Copyright (c) 1998, 2021, 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 // FORMS.CPP - Definitions for ADL Parser Forms Classes
  26 #include "adlc.hpp"
  27 
  28 //==============================Instructions===================================
  29 //------------------------------InstructForm-----------------------------------
  30 InstructForm::InstructForm(const char *id, bool ideal_only)
  31   : _ident(id), _ideal_only(ideal_only),
  32     _localNames(cmpstr, hashstr, Form::arena),
  33     _effects(cmpstr, hashstr, Form::arena),
  34     _is_mach_constant(false),
  35     _needs_constant_base(false),
  36     _has_call(false)
  37 {
  38       _ftype = Form::INS;
  39 
  40       _matrule              = NULL;
  41       _insencode            = NULL;
  42       _constant             = NULL;
  43       _is_postalloc_expand  = false;
  44       _opcode               = NULL;
  45       _size                 = NULL;
  46       _attribs              = NULL;
  47       _predicate            = NULL;
  48       _exprule              = NULL;
  49       _rewrule              = NULL;
  50       _format               = NULL;
  51       _peephole             = NULL;
  52       _ins_pipe             = NULL;
  53       _uniq_idx             = NULL;
  54       _num_uniq             = 0;
  55       _cisc_spill_operand   = Not_cisc_spillable;// Which operand may cisc-spill
  56       _cisc_spill_alternate = NULL;            // possible cisc replacement
  57       _cisc_reg_mask_name   = NULL;
  58       _is_cisc_alternate    = false;
  59       _is_short_branch      = false;
  60       _short_branch_form    = NULL;
  61       _alignment            = 1;
  62 }
  63 
  64 InstructForm::InstructForm(const char *id, InstructForm *instr, MatchRule *rule)
  65   : _ident(id), _ideal_only(false),
  66     _localNames(instr->_localNames),
  67     _effects(instr->_effects),
  68     _is_mach_constant(false),
  69     _needs_constant_base(false),
  70     _has_call(false)
  71 {
  72       _ftype = Form::INS;
  73 
  74       _matrule               = rule;
  75       _insencode             = instr->_insencode;
  76       _constant              = instr->_constant;
  77       _is_postalloc_expand   = instr->_is_postalloc_expand;
  78       _opcode                = instr->_opcode;
  79       _size                  = instr->_size;
  80       _attribs               = instr->_attribs;
  81       _predicate             = instr->_predicate;
  82       _exprule               = instr->_exprule;
  83       _rewrule               = instr->_rewrule;
  84       _format                = instr->_format;
  85       _peephole              = instr->_peephole;
  86       _ins_pipe              = instr->_ins_pipe;
  87       _uniq_idx              = instr->_uniq_idx;
  88       _num_uniq              = instr->_num_uniq;
  89       _cisc_spill_operand    = Not_cisc_spillable; // Which operand may cisc-spill
  90       _cisc_spill_alternate  = NULL;               // possible cisc replacement
  91       _cisc_reg_mask_name    = NULL;
  92       _is_cisc_alternate     = false;
  93       _is_short_branch       = false;
  94       _short_branch_form     = NULL;
  95       _alignment             = 1;
  96      // Copy parameters
  97      const char *name;
  98      instr->_parameters.reset();
  99      for (; (name = instr->_parameters.iter()) != NULL;)
 100        _parameters.addName(name);
 101 }
 102 
 103 InstructForm::~InstructForm() {
 104 }
 105 
 106 InstructForm *InstructForm::is_instruction() const {
 107   return (InstructForm*)this;
 108 }
 109 
 110 bool InstructForm::ideal_only() const {
 111   return _ideal_only;
 112 }
 113 
 114 bool InstructForm::sets_result() const {
 115   return (_matrule != NULL && _matrule->sets_result());
 116 }
 117 
 118 bool InstructForm::needs_projections() {
 119   _components.reset();
 120   for( Component *comp; (comp = _components.iter()) != NULL; ) {
 121     if (comp->isa(Component::KILL)) {
 122       return true;
 123     }
 124   }
 125   return false;
 126 }
 127 
 128 
 129 bool InstructForm::has_temps() {
 130   if (_matrule) {
 131     // Examine each component to see if it is a TEMP
 132     _components.reset();
 133     // Skip the first component, if already handled as (SET dst (...))
 134     Component *comp = NULL;
 135     if (sets_result())  comp = _components.iter();
 136     while ((comp = _components.iter()) != NULL) {
 137       if (comp->isa(Component::TEMP)) {
 138         return true;
 139       }
 140     }
 141   }
 142 
 143   return false;
 144 }
 145 
 146 uint InstructForm::num_defs_or_kills() {
 147   uint   defs_or_kills = 0;
 148 
 149   _components.reset();
 150   for( Component *comp; (comp = _components.iter()) != NULL; ) {
 151     if( comp->isa(Component::DEF) || comp->isa(Component::KILL) ) {
 152       ++defs_or_kills;
 153     }
 154   }
 155 
 156   return  defs_or_kills;
 157 }
 158 
 159 // This instruction has an expand rule?
 160 bool InstructForm::expands() const {
 161   return ( _exprule != NULL );
 162 }
 163 
 164 // This instruction has a late expand rule?
 165 bool InstructForm::postalloc_expands() const {
 166   return _is_postalloc_expand;
 167 }
 168 
 169 // This instruction has a peephole rule?
 170 Peephole *InstructForm::peepholes() const {
 171   return _peephole;
 172 }
 173 
 174 // This instruction has a peephole rule?
 175 void InstructForm::append_peephole(Peephole *peephole) {
 176   if( _peephole == NULL ) {
 177     _peephole = peephole;
 178   } else {
 179     _peephole->append_peephole(peephole);
 180   }
 181 }
 182 
 183 
 184 // ideal opcode enumeration
 185 const char *InstructForm::ideal_Opcode( FormDict &globalNames )  const {
 186   if( !_matrule ) return "Node"; // Something weird
 187   // Chain rules do not really have ideal Opcodes; use their source
 188   // operand ideal Opcode instead.
 189   if( is_simple_chain_rule(globalNames) ) {
 190     const char *src = _matrule->_rChild->_opType;
 191     OperandForm *src_op = globalNames[src]->is_operand();
 192     assert( src_op, "Not operand class of chain rule" );
 193     if( !src_op->_matrule ) return "Node";
 194     return src_op->_matrule->_opType;
 195   }
 196   // Operand chain rules do not really have ideal Opcodes
 197   if( _matrule->is_chain_rule(globalNames) )
 198     return "Node";
 199   return strcmp(_matrule->_opType,"Set")
 200     ? _matrule->_opType
 201     : _matrule->_rChild->_opType;
 202 }
 203 
 204 // Recursive check on all operands' match rules in my match rule
 205 bool InstructForm::is_pinned(FormDict &globals) {
 206   if ( ! _matrule)  return false;
 207 
 208   int  index   = 0;
 209   if (_matrule->find_type("Goto",          index)) return true;
 210   if (_matrule->find_type("If",            index)) return true;
 211   if (_matrule->find_type("CountedLoopEnd",index)) return true;
 212   if (_matrule->find_type("Return",        index)) return true;
 213   if (_matrule->find_type("Rethrow",       index)) return true;
 214   if (_matrule->find_type("TailCall",      index)) return true;
 215   if (_matrule->find_type("TailJump",      index)) return true;
 216   if (_matrule->find_type("Halt",          index)) return true;
 217   if (_matrule->find_type("Jump",          index)) return true;
 218 
 219   return is_parm(globals);
 220 }
 221 
 222 // Recursive check on all operands' match rules in my match rule
 223 bool InstructForm::is_projection(FormDict &globals) {
 224   if ( ! _matrule)  return false;
 225 
 226   int  index   = 0;
 227   if (_matrule->find_type("Goto",    index)) return true;
 228   if (_matrule->find_type("Return",  index)) return true;
 229   if (_matrule->find_type("Rethrow", index)) return true;
 230   if (_matrule->find_type("TailCall",index)) return true;
 231   if (_matrule->find_type("TailJump",index)) return true;
 232   if (_matrule->find_type("Halt",    index)) return true;
 233 
 234   return false;
 235 }
 236 
 237 // Recursive check on all operands' match rules in my match rule
 238 bool InstructForm::is_parm(FormDict &globals) {
 239   if ( ! _matrule)  return false;
 240 
 241   int  index   = 0;
 242   if (_matrule->find_type("Parm",index)) return true;
 243 
 244   return false;
 245 }
 246 
 247 bool InstructForm::is_ideal_negD() const {
 248   return (_matrule && _matrule->_rChild && strcmp(_matrule->_rChild->_opType, "NegD") == 0);
 249 }
 250 
 251 // Return 'true' if this instruction matches an ideal 'Copy*' node
 252 int InstructForm::is_ideal_copy() const {
 253   return _matrule ? _matrule->is_ideal_copy() : 0;
 254 }
 255 
 256 // Return 'true' if this instruction is too complex to rematerialize.
 257 int InstructForm::is_expensive() const {
 258   // We can prove it is cheap if it has an empty encoding.
 259   // This helps with platform-specific nops like ThreadLocal and RoundFloat.
 260   if (is_empty_encoding())
 261     return 0;
 262 
 263   if (is_tls_instruction())
 264     return 1;
 265 
 266   if (_matrule == NULL)  return 0;
 267 
 268   return _matrule->is_expensive();
 269 }
 270 
 271 // Has an empty encoding if _size is a constant zero or there
 272 // are no ins_encode tokens.
 273 int InstructForm::is_empty_encoding() const {
 274   if (_insencode != NULL) {
 275     _insencode->reset();
 276     if (_insencode->encode_class_iter() == NULL) {
 277       return 1;
 278     }
 279   }
 280   if (_size != NULL && strcmp(_size, "0") == 0) {
 281     return 1;
 282   }
 283   return 0;
 284 }
 285 
 286 int InstructForm::is_tls_instruction() const {
 287   if (_ident != NULL &&
 288       ( ! strcmp( _ident,"tlsLoadP") ||
 289         ! strncmp(_ident,"tlsLoadP_",9)) ) {
 290     return 1;
 291   }
 292 
 293   if (_matrule != NULL && _insencode != NULL) {
 294     const char* opType = _matrule->_opType;
 295     if (strcmp(opType, "Set")==0)
 296       opType = _matrule->_rChild->_opType;
 297     if (strcmp(opType,"ThreadLocal")==0) {
 298       fprintf(stderr, "Warning: ThreadLocal instruction %s should be named 'tlsLoadP_*'\n",
 299               (_ident == NULL ? "NULL" : _ident));
 300       return 1;
 301     }
 302   }
 303 
 304   return 0;
 305 }
 306 
 307 
 308 // Return 'true' if this instruction matches an ideal 'If' node
 309 bool InstructForm::is_ideal_if() const {
 310   if( _matrule == NULL ) return false;
 311 
 312   return _matrule->is_ideal_if();
 313 }
 314 
 315 // Return 'true' if this instruction matches an ideal 'FastLock' node
 316 bool InstructForm::is_ideal_fastlock() const {
 317   if( _matrule == NULL ) return false;
 318 
 319   return _matrule->is_ideal_fastlock();
 320 }
 321 
 322 // Return 'true' if this instruction matches an ideal 'MemBarXXX' node
 323 bool InstructForm::is_ideal_membar() const {
 324   if( _matrule == NULL ) return false;
 325 
 326   return _matrule->is_ideal_membar();
 327 }
 328 
 329 // Return 'true' if this instruction matches an ideal 'LoadPC' node
 330 bool InstructForm::is_ideal_loadPC() const {
 331   if( _matrule == NULL ) return false;
 332 
 333   return _matrule->is_ideal_loadPC();
 334 }
 335 
 336 // Return 'true' if this instruction matches an ideal 'Box' node
 337 bool InstructForm::is_ideal_box() const {
 338   if( _matrule == NULL ) return false;
 339 
 340   return _matrule->is_ideal_box();
 341 }
 342 
 343 // Return 'true' if this instruction matches an ideal 'Goto' node
 344 bool InstructForm::is_ideal_goto() const {
 345   if( _matrule == NULL ) return false;
 346 
 347   return _matrule->is_ideal_goto();
 348 }
 349 
 350 // Return 'true' if this instruction matches an ideal 'Jump' node
 351 bool InstructForm::is_ideal_jump() const {
 352   if( _matrule == NULL ) return false;
 353 
 354   return _matrule->is_ideal_jump();
 355 }
 356 
 357 // Return 'true' if instruction matches ideal 'If' | 'Goto' | 'CountedLoopEnd'
 358 bool InstructForm::is_ideal_branch() const {
 359   if( _matrule == NULL ) return false;
 360 
 361   return _matrule->is_ideal_if() || _matrule->is_ideal_goto();
 362 }
 363 
 364 
 365 // Return 'true' if this instruction matches an ideal 'Return' node
 366 bool InstructForm::is_ideal_return() const {
 367   if( _matrule == NULL ) return false;
 368 
 369   // Check MatchRule to see if the first entry is the ideal "Return" node
 370   int  index   = 0;
 371   if (_matrule->find_type("Return",index)) return true;
 372   if (_matrule->find_type("Rethrow",index)) return true;
 373   if (_matrule->find_type("TailCall",index)) return true;
 374   if (_matrule->find_type("TailJump",index)) return true;
 375 
 376   return false;
 377 }
 378 
 379 // Return 'true' if this instruction matches an ideal 'Halt' node
 380 bool InstructForm::is_ideal_halt() const {
 381   int  index   = 0;
 382   return _matrule && _matrule->find_type("Halt",index);
 383 }
 384 
 385 // Return 'true' if this instruction matches an ideal 'SafePoint' node
 386 bool InstructForm::is_ideal_safepoint() const {
 387   int  index   = 0;
 388   return _matrule && _matrule->find_type("SafePoint",index);
 389 }
 390 
 391 // Return 'true' if this instruction matches an ideal 'Nop' node
 392 bool InstructForm::is_ideal_nop() const {
 393   return _ident && _ident[0] == 'N' && _ident[1] == 'o' && _ident[2] == 'p' && _ident[3] == '_';
 394 }
 395 
 396 bool InstructForm::is_ideal_control() const {
 397   if ( ! _matrule)  return false;
 398 
 399   return is_ideal_return() || is_ideal_branch() || _matrule->is_ideal_jump() || is_ideal_halt();
 400 }
 401 
 402 // Return 'true' if this instruction matches an ideal 'Call' node
 403 Form::CallType InstructForm::is_ideal_call() const {
 404   if( _matrule == NULL ) return Form::invalid_type;
 405 
 406   // Check MatchRule to see if the first entry is the ideal "Call" node
 407   int  idx   = 0;
 408   if(_matrule->find_type("CallStaticJava",idx))   return Form::JAVA_STATIC;
 409   idx = 0;
 410   if(_matrule->find_type("Lock",idx))             return Form::JAVA_STATIC;
 411   idx = 0;
 412   if(_matrule->find_type("Unlock",idx))           return Form::JAVA_STATIC;
 413   idx = 0;
 414   if(_matrule->find_type("CallDynamicJava",idx))  return Form::JAVA_DYNAMIC;
 415   idx = 0;
 416   if(_matrule->find_type("CallRuntime",idx))      return Form::JAVA_RUNTIME;
 417   idx = 0;
 418   if(_matrule->find_type("CallLeaf",idx))         return Form::JAVA_LEAF;
 419   idx = 0;
 420   if(_matrule->find_type("CallLeafNoFP",idx))     return Form::JAVA_LEAF;
 421   idx = 0;
 422   if(_matrule->find_type("CallLeafVector",idx))   return Form::JAVA_LEAF;
 423   idx = 0;
 424   if(_matrule->find_type("CallNative",idx))       return Form::JAVA_NATIVE;
 425   idx = 0;
 426 
 427   return Form::invalid_type;
 428 }
 429 
 430 // Return 'true' if this instruction matches an ideal 'Load?' node
 431 Form::DataType InstructForm::is_ideal_load() const {
 432   if( _matrule == NULL ) return Form::none;
 433 
 434   return  _matrule->is_ideal_load();
 435 }
 436 
 437 // Return 'true' if this instruction matches an ideal 'LoadKlass' node
 438 bool InstructForm::skip_antidep_check() const {
 439   if( _matrule == NULL ) return false;
 440 
 441   return  _matrule->skip_antidep_check();
 442 }
 443 
 444 // Return 'true' if this instruction matches an ideal 'Load?' node
 445 Form::DataType InstructForm::is_ideal_store() const {
 446   if( _matrule == NULL ) return Form::none;
 447 
 448   return  _matrule->is_ideal_store();
 449 }
 450 
 451 // Return 'true' if this instruction matches an ideal vector node
 452 bool InstructForm::is_vector() const {
 453   if( _matrule == NULL ) return false;
 454 
 455   return _matrule->is_vector();
 456 }
 457 
 458 
 459 // Return the input register that must match the output register
 460 // If this is not required, return 0
 461 uint InstructForm::two_address(FormDict &globals) {
 462   uint  matching_input = 0;
 463   if(_components.count() == 0) return 0;
 464 
 465   _components.reset();
 466   Component *comp = _components.iter();
 467   // Check if there is a DEF
 468   if( comp->isa(Component::DEF) ) {
 469     // Check that this is a register
 470     const char  *def_type = comp->_type;
 471     const Form  *form     = globals[def_type];
 472     OperandForm *op       = form->is_operand();
 473     if( op ) {
 474       if( op->constrained_reg_class() != NULL &&
 475           op->interface_type(globals) == Form::register_interface ) {
 476         // Remember the local name for equality test later
 477         const char *def_name = comp->_name;
 478         // Check if a component has the same name and is a USE
 479         do {
 480           if( comp->isa(Component::USE) && strcmp(comp->_name,def_name)==0 ) {
 481             return operand_position_format(def_name);
 482           }
 483         } while( (comp = _components.iter()) != NULL);
 484       }
 485     }
 486   }
 487 
 488   return 0;
 489 }
 490 
 491 
 492 // when chaining a constant to an instruction, returns 'true' and sets opType
 493 Form::DataType InstructForm::is_chain_of_constant(FormDict &globals) {
 494   const char *dummy  = NULL;
 495   const char *dummy2 = NULL;
 496   return is_chain_of_constant(globals, dummy, dummy2);
 497 }
 498 Form::DataType InstructForm::is_chain_of_constant(FormDict &globals,
 499                 const char * &opTypeParam) {
 500   const char *result = NULL;
 501 
 502   return is_chain_of_constant(globals, opTypeParam, result);
 503 }
 504 
 505 Form::DataType InstructForm::is_chain_of_constant(FormDict &globals,
 506                 const char * &opTypeParam, const char * &resultParam) {
 507   Form::DataType  data_type = Form::none;
 508   if ( ! _matrule)  return data_type;
 509 
 510   // !!!!!
 511   // The source of the chain rule is 'position = 1'
 512   uint         position = 1;
 513   const char  *result   = NULL;
 514   const char  *name     = NULL;
 515   const char  *opType   = NULL;
 516   // Here base_operand is looking for an ideal type to be returned (opType).
 517   if ( _matrule->is_chain_rule(globals)
 518        && _matrule->base_operand(position, globals, result, name, opType) ) {
 519     data_type = ideal_to_const_type(opType);
 520 
 521     // if it isn't an ideal constant type, just return
 522     if ( data_type == Form::none ) return data_type;
 523 
 524     // Ideal constant types also adjust the opType parameter.
 525     resultParam = result;
 526     opTypeParam = opType;
 527     return data_type;
 528   }
 529 
 530   return data_type;
 531 }
 532 
 533 // Check if a simple chain rule
 534 bool InstructForm::is_simple_chain_rule(FormDict &globals) const {
 535   if( _matrule && _matrule->sets_result()
 536       && _matrule->_rChild->_lChild == NULL
 537       && globals[_matrule->_rChild->_opType]
 538       && globals[_matrule->_rChild->_opType]->is_opclass() ) {
 539     return true;
 540   }
 541   return false;
 542 }
 543 
 544 // check for structural rematerialization
 545 bool InstructForm::rematerialize(FormDict &globals, RegisterForm *registers ) {
 546   bool   rematerialize = false;
 547 
 548   Form::DataType data_type = is_chain_of_constant(globals);
 549   if( data_type != Form::none )
 550     rematerialize = true;
 551 
 552   // Constants
 553   if( _components.count() == 1 && _components[0]->is(Component::USE_DEF) )
 554     rematerialize = true;
 555 
 556   // Pseudo-constants (values easily available to the runtime)
 557   if (is_empty_encoding() && is_tls_instruction())
 558     rematerialize = true;
 559 
 560   // 1-input, 1-output, such as copies or increments.
 561   if( _components.count() == 2 &&
 562       _components[0]->is(Component::DEF) &&
 563       _components[1]->isa(Component::USE) )
 564     rematerialize = true;
 565 
 566   // Check for an ideal 'Load?' and eliminate rematerialize option
 567   if ( is_ideal_load() != Form::none || // Ideal load?  Do not rematerialize
 568        is_ideal_copy() != Form::none || // Ideal copy?  Do not rematerialize
 569        is_expensive()  != Form::none) { // Expensive?   Do not rematerialize
 570     rematerialize = false;
 571   }
 572 
 573   // Always rematerialize the flags.  They are more expensive to save &
 574   // restore than to recompute (and possibly spill the compare's inputs).
 575   if( _components.count() >= 1 ) {
 576     Component *c = _components[0];
 577     const Form *form = globals[c->_type];
 578     OperandForm *opform = form->is_operand();
 579     if( opform ) {
 580       // Avoid the special stack_slots register classes
 581       const char *rc_name = opform->constrained_reg_class();
 582       if( rc_name ) {
 583         if( strcmp(rc_name,"stack_slots") ) {
 584           // Check for ideal_type of RegFlags
 585           const char *type = opform->ideal_type( globals, registers );
 586           if( (type != NULL) && !strcmp(type, "RegFlags") )
 587             rematerialize = true;
 588         } else
 589           rematerialize = false; // Do not rematerialize things target stk
 590       }
 591     }
 592   }
 593 
 594   return rematerialize;
 595 }
 596 
 597 // loads from memory, so must check for anti-dependence
 598 bool InstructForm::needs_anti_dependence_check(FormDict &globals) const {
 599   if ( skip_antidep_check() ) return false;
 600 
 601   // Machine independent loads must be checked for anti-dependences
 602   if( is_ideal_load() != Form::none )  return true;
 603 
 604   // !!!!! !!!!! !!!!!
 605   // TEMPORARY
 606   // if( is_simple_chain_rule(globals) )  return false;
 607 
 608   // String.(compareTo/equals/indexOf) and Arrays.equals use many memorys edges,
 609   // but writes none
 610   if( _matrule && _matrule->_rChild &&
 611       ( strcmp(_matrule->_rChild->_opType,"StrComp"    )==0 ||
 612         strcmp(_matrule->_rChild->_opType,"StrEquals"  )==0 ||
 613         strcmp(_matrule->_rChild->_opType,"StrIndexOf" )==0 ||
 614         strcmp(_matrule->_rChild->_opType,"StrIndexOfChar" )==0 ||
 615         strcmp(_matrule->_rChild->_opType,"HasNegatives" )==0 ||
 616         strcmp(_matrule->_rChild->_opType,"AryEq"      )==0 ))
 617     return true;
 618 
 619   // Check if instruction has a USE of a memory operand class, but no defs
 620   bool USE_of_memory  = false;
 621   bool DEF_of_memory  = false;
 622   Component     *comp = NULL;
 623   ComponentList &components = (ComponentList &)_components;
 624 
 625   components.reset();
 626   while( (comp = components.iter()) != NULL ) {
 627     const Form  *form = globals[comp->_type];
 628     if( !form ) continue;
 629     OpClassForm *op   = form->is_opclass();
 630     if( !op ) continue;
 631     if( form->interface_type(globals) == Form::memory_interface ) {
 632       if( comp->isa(Component::USE) ) USE_of_memory = true;
 633       if( comp->isa(Component::DEF) ) {
 634         OperandForm *oper = form->is_operand();
 635         if( oper && oper->is_user_name_for_sReg() ) {
 636           // Stack slots are unaliased memory handled by allocator
 637           oper = oper;  // debug stopping point !!!!!
 638         } else {
 639           DEF_of_memory = true;
 640         }
 641       }
 642     }
 643   }
 644   return (USE_of_memory && !DEF_of_memory);
 645 }
 646 
 647 
 648 int InstructForm::memory_operand(FormDict &globals) const {
 649   // Machine independent loads must be checked for anti-dependences
 650   // Check if instruction has a USE of a memory operand class, or a def.
 651   int USE_of_memory  = 0;
 652   int DEF_of_memory  = 0;
 653   const char*    last_memory_DEF = NULL; // to test DEF/USE pairing in asserts
 654   const char*    last_memory_USE = NULL;
 655   Component     *unique          = NULL;
 656   Component     *comp            = NULL;
 657   ComponentList &components      = (ComponentList &)_components;
 658 
 659   components.reset();
 660   while( (comp = components.iter()) != NULL ) {
 661     const Form  *form = globals[comp->_type];
 662     if( !form ) continue;
 663     OpClassForm *op   = form->is_opclass();
 664     if( !op ) continue;
 665     if( op->stack_slots_only(globals) )  continue;
 666     if( form->interface_type(globals) == Form::memory_interface ) {
 667       if( comp->isa(Component::DEF) ) {
 668         last_memory_DEF = comp->_name;
 669         DEF_of_memory++;
 670         unique = comp;
 671       } else if( comp->isa(Component::USE) ) {
 672         if( last_memory_DEF != NULL ) {
 673           assert(0 == strcmp(last_memory_DEF, comp->_name), "every memory DEF is followed by a USE of the same name");
 674           last_memory_DEF = NULL;
 675         }
 676         // Handles same memory being used multiple times in the case of BMI1 instructions.
 677         if (last_memory_USE != NULL) {
 678           if (strcmp(comp->_name, last_memory_USE) != 0) {
 679             USE_of_memory++;
 680           }
 681         } else {
 682           USE_of_memory++;
 683         }
 684         last_memory_USE = comp->_name;
 685 
 686         if (DEF_of_memory == 0)  // defs take precedence
 687           unique = comp;
 688       } else {
 689         assert(last_memory_DEF == NULL, "unpaired memory DEF");
 690       }
 691     }
 692   }
 693   assert(last_memory_DEF == NULL, "unpaired memory DEF");
 694   assert(USE_of_memory >= DEF_of_memory, "unpaired memory DEF");
 695   USE_of_memory -= DEF_of_memory;   // treat paired DEF/USE as one occurrence
 696   if( (USE_of_memory + DEF_of_memory) > 0 ) {
 697     if( is_simple_chain_rule(globals) ) {
 698       //fprintf(stderr, "Warning: chain rule is not really a memory user.\n");
 699       //((InstructForm*)this)->dump();
 700       // Preceding code prints nothing on sparc and these insns on intel:
 701       // leaP8 leaP32 leaPIdxOff leaPIdxScale leaPIdxScaleOff leaP8 leaP32
 702       // leaPIdxOff leaPIdxScale leaPIdxScaleOff
 703       return NO_MEMORY_OPERAND;
 704     }
 705 
 706     if( DEF_of_memory == 1 ) {
 707       assert(unique != NULL, "");
 708       if( USE_of_memory == 0 ) {
 709         // unique def, no uses
 710       } else {
 711         // // unique def, some uses
 712         // // must return bottom unless all uses match def
 713         // unique = NULL;
 714 #ifdef S390
 715         // This case is important for move instructions on s390x.
 716         // On other platforms (e.g. x86), all uses always match the def.
 717         unique = NULL;
 718 #endif
 719       }
 720     } else if( DEF_of_memory > 0 ) {
 721       // multiple defs, don't care about uses
 722       unique = NULL;
 723     } else if( USE_of_memory == 1) {
 724       // unique use, no defs
 725       assert(unique != NULL, "");
 726     } else if( USE_of_memory > 0 ) {
 727       // multiple uses, no defs
 728       unique = NULL;
 729     } else {
 730       assert(false, "bad case analysis");
 731     }
 732     // process the unique DEF or USE, if there is one
 733     if( unique == NULL ) {
 734       return MANY_MEMORY_OPERANDS;
 735     } else {
 736       int pos = components.operand_position(unique->_name);
 737       if( unique->isa(Component::DEF) ) {
 738         pos += 1;                // get corresponding USE from DEF
 739       }
 740       assert(pos >= 1, "I was just looking at it!");
 741       return pos;
 742     }
 743   }
 744 
 745   // missed the memory op??
 746   if( true ) {  // %%% should not be necessary
 747     if( is_ideal_store() != Form::none ) {
 748       fprintf(stderr, "Warning: cannot find memory opnd in instr.\n");
 749       ((InstructForm*)this)->dump();
 750       // pretend it has multiple defs and uses
 751       return MANY_MEMORY_OPERANDS;
 752     }
 753     if( is_ideal_load()  != Form::none ) {
 754       fprintf(stderr, "Warning: cannot find memory opnd in instr.\n");
 755       ((InstructForm*)this)->dump();
 756       // pretend it has multiple uses and no defs
 757       return MANY_MEMORY_OPERANDS;
 758     }
 759   }
 760 
 761   return NO_MEMORY_OPERAND;
 762 }
 763 
 764 // This instruction captures the machine-independent bottom_type
 765 // Expected use is for pointer vs oop determination for LoadP
 766 bool InstructForm::captures_bottom_type(FormDict &globals) const {
 767   if (_matrule && _matrule->_rChild &&
 768       (!strcmp(_matrule->_rChild->_opType,"CastPP")       ||  // new result type
 769        !strcmp(_matrule->_rChild->_opType,"CastDD")       ||
 770        !strcmp(_matrule->_rChild->_opType,"CastFF")       ||
 771        !strcmp(_matrule->_rChild->_opType,"CastII")       ||
 772        !strcmp(_matrule->_rChild->_opType,"CastLL")       ||
 773        !strcmp(_matrule->_rChild->_opType,"CastVV")       ||
 774        !strcmp(_matrule->_rChild->_opType,"CastX2P")      ||  // new result type
 775        !strcmp(_matrule->_rChild->_opType,"DecodeN")      ||
 776        !strcmp(_matrule->_rChild->_opType,"EncodeP")      ||
 777        !strcmp(_matrule->_rChild->_opType,"DecodeNKlass") ||
 778        !strcmp(_matrule->_rChild->_opType,"EncodePKlass") ||
 779        !strcmp(_matrule->_rChild->_opType,"LoadN")        ||
 780        !strcmp(_matrule->_rChild->_opType,"LoadNKlass")   ||
 781        !strcmp(_matrule->_rChild->_opType,"CreateEx")     ||  // type of exception
 782        !strcmp(_matrule->_rChild->_opType,"CheckCastPP")  ||
 783        !strcmp(_matrule->_rChild->_opType,"GetAndSetP")   ||
 784        !strcmp(_matrule->_rChild->_opType,"GetAndSetN")   ||
 785        !strcmp(_matrule->_rChild->_opType,"RotateLeft")   ||
 786        !strcmp(_matrule->_rChild->_opType,"RotateRight")   ||
 787 #if INCLUDE_SHENANDOAHGC
 788        !strcmp(_matrule->_rChild->_opType,"ShenandoahCompareAndExchangeP") ||
 789        !strcmp(_matrule->_rChild->_opType,"ShenandoahCompareAndExchangeN") ||
 790 #endif
 791        !strcmp(_matrule->_rChild->_opType,"StrInflatedCopy") ||
 792        !strcmp(_matrule->_rChild->_opType,"VectorCmpMasked")||
 793        !strcmp(_matrule->_rChild->_opType,"VectorMaskGen")||
 794        !strcmp(_matrule->_rChild->_opType,"CompareAndExchangeP") ||
 795        !strcmp(_matrule->_rChild->_opType,"CompareAndExchangeN"))) return true;
 796   else if ( is_ideal_load() == Form::idealP )                return true;
 797   else if ( is_ideal_store() != Form::none  )                return true;
 798 
 799   if (needs_base_oop_edge(globals)) return true;
 800 
 801   if (is_vector()) return true;
 802   if (is_mach_constant()) return true;
 803 
 804   return  false;
 805 }
 806 
 807 
 808 // Access instr_cost attribute or return NULL.
 809 const char* InstructForm::cost() {
 810   for (Attribute* cur = _attribs; cur != NULL; cur = (Attribute*)cur->_next) {
 811     if( strcmp(cur->_ident,AttributeForm::_ins_cost) == 0 ) {
 812       return cur->_val;
 813     }
 814   }
 815   return NULL;
 816 }
 817 
 818 // Return count of top-level operands.
 819 uint InstructForm::num_opnds() {
 820   int  num_opnds = _components.num_operands();
 821 
 822   // Need special handling for matching some ideal nodes
 823   // i.e. Matching a return node
 824   /*
 825   if( _matrule ) {
 826     if( strcmp(_matrule->_opType,"Return"   )==0 ||
 827         strcmp(_matrule->_opType,"Halt"     )==0 )
 828       return 3;
 829   }
 830     */
 831   return num_opnds;
 832 }
 833 
 834 const char* InstructForm::opnd_ident(int idx) {
 835   return _components.at(idx)->_name;
 836 }
 837 
 838 const char* InstructForm::unique_opnd_ident(uint idx) {
 839   uint i;
 840   for (i = 1; i < num_opnds(); ++i) {
 841     if (unique_opnds_idx(i) == idx) {
 842       break;
 843     }
 844   }
 845   return (_components.at(i) != NULL) ? _components.at(i)->_name : "";
 846 }
 847 
 848 // Return count of unmatched operands.
 849 uint InstructForm::num_post_match_opnds() {
 850   uint  num_post_match_opnds = _components.count();
 851   uint  num_match_opnds = _components.match_count();
 852   num_post_match_opnds = num_post_match_opnds - num_match_opnds;
 853 
 854   return num_post_match_opnds;
 855 }
 856 
 857 // Return the number of leaves below this complex operand
 858 uint InstructForm::num_consts(FormDict &globals) const {
 859   if ( ! _matrule) return 0;
 860 
 861   // This is a recursive invocation on all operands in the matchrule
 862   return _matrule->num_consts(globals);
 863 }
 864 
 865 // Constants in match rule with specified type
 866 uint InstructForm::num_consts(FormDict &globals, Form::DataType type) const {
 867   if ( ! _matrule) return 0;
 868 
 869   // This is a recursive invocation on all operands in the matchrule
 870   return _matrule->num_consts(globals, type);
 871 }
 872 
 873 
 874 // Return the register class associated with 'leaf'.
 875 const char *InstructForm::out_reg_class(FormDict &globals) {
 876   assert( false, "InstructForm::out_reg_class(FormDict &globals); Not Implemented");
 877 
 878   return NULL;
 879 }
 880 
 881 
 882 
 883 // Lookup the starting position of inputs we are interested in wrt. ideal nodes
 884 uint InstructForm::oper_input_base(FormDict &globals) {
 885   if( !_matrule ) return 1;     // Skip control for most nodes
 886 
 887   // Need special handling for matching some ideal nodes
 888   // i.e. Matching a return node
 889   if( strcmp(_matrule->_opType,"Return"    )==0 ||
 890       strcmp(_matrule->_opType,"Rethrow"   )==0 ||
 891       strcmp(_matrule->_opType,"TailCall"  )==0 ||
 892       strcmp(_matrule->_opType,"TailJump"  )==0 ||
 893       strcmp(_matrule->_opType,"SafePoint" )==0 ||
 894       strcmp(_matrule->_opType,"Halt"      )==0 )
 895     return AdlcVMDeps::Parms;   // Skip the machine-state edges
 896 
 897   if( _matrule->_rChild &&
 898       ( strcmp(_matrule->_rChild->_opType,"AryEq"     )==0 ||
 899         strcmp(_matrule->_rChild->_opType,"StrComp"   )==0 ||
 900         strcmp(_matrule->_rChild->_opType,"StrEquals" )==0 ||
 901         strcmp(_matrule->_rChild->_opType,"StrInflatedCopy"   )==0 ||
 902         strcmp(_matrule->_rChild->_opType,"StrCompressedCopy" )==0 ||
 903         strcmp(_matrule->_rChild->_opType,"StrIndexOf")==0 ||
 904         strcmp(_matrule->_rChild->_opType,"StrIndexOfChar")==0 ||
 905         strcmp(_matrule->_rChild->_opType,"HasNegatives")==0 ||
 906         strcmp(_matrule->_rChild->_opType,"EncodeISOArray")==0)) {
 907         // String.(compareTo/equals/indexOf) and Arrays.equals
 908         // and sun.nio.cs.iso8859_1$Encoder.EncodeISOArray
 909         // take 1 control and 1 memory edges.
 910         // Also String.(compressedCopy/inflatedCopy).
 911     return 2;
 912   }
 913 
 914   // Check for handling of 'Memory' input/edge in the ideal world.
 915   // The AD file writer is shielded from knowledge of these edges.
 916   int base = 1;                 // Skip control
 917   base += _matrule->needs_ideal_memory_edge(globals);
 918 
 919   // Also skip the base-oop value for uses of derived oops.
 920   // The AD file writer is shielded from knowledge of these edges.
 921   base += needs_base_oop_edge(globals);
 922 
 923   return base;
 924 }
 925 
 926 // This function determines the order of the MachOper in _opnds[]
 927 // by writing the operand names into the _components list.
 928 //
 929 // Implementation does not modify state of internal structures
 930 void InstructForm::build_components() {
 931   // Add top-level operands to the components
 932   if (_matrule)  _matrule->append_components(_localNames, _components);
 933 
 934   // Add parameters that "do not appear in match rule".
 935   bool has_temp = false;
 936   const char *name;
 937   const char *kill_name = NULL;
 938   for (_parameters.reset(); (name = _parameters.iter()) != NULL;) {
 939     OpClassForm *opForm = _localNames[name]->is_opclass();
 940     assert(opForm != NULL, "sanity");
 941 
 942     Effect* e = NULL;
 943     {
 944       const Form* form = _effects[name];
 945       e = form ? form->is_effect() : NULL;
 946     }
 947 
 948     if (e != NULL) {
 949       has_temp |= e->is(Component::TEMP);
 950 
 951       // KILLs must be declared after any TEMPs because TEMPs are real
 952       // uses so their operand numbering must directly follow the real
 953       // inputs from the match rule.  Fixing the numbering seems
 954       // complex so simply enforce the restriction during parse.
 955       if (kill_name != NULL &&
 956           e->isa(Component::TEMP) && !e->isa(Component::DEF)) {
 957         OpClassForm* kill = _localNames[kill_name]->is_opclass();
 958         assert(kill != NULL, "sanity");
 959         globalAD->syntax_err(_linenum, "%s: %s %s must be at the end of the argument list\n",
 960                              _ident, kill->_ident, kill_name);
 961       } else if (e->isa(Component::KILL) && !e->isa(Component::USE)) {
 962         kill_name = name;
 963       }
 964     }
 965 
 966     const Component *component  = _components.search(name);
 967     if ( component  == NULL ) {
 968       if (e) {
 969         _components.insert(name, opForm->_ident, e->_use_def, false);
 970         component = _components.search(name);
 971         if (component->isa(Component::USE) && !component->isa(Component::TEMP) && _matrule) {
 972           const Form *form = globalAD->globalNames()[component->_type];
 973           assert( form, "component type must be a defined form");
 974           OperandForm *op   = form->is_operand();
 975           if (op->_interface && op->_interface->is_RegInterface()) {
 976             globalAD->syntax_err(_linenum, "%s: illegal USE of non-input: %s %s\n",
 977                                  _ident, opForm->_ident, name);
 978           }
 979         }
 980       } else {
 981         // This would be a nice warning but it triggers in a few places in a benign way
 982         // if (_matrule != NULL && !expands()) {
 983         //   globalAD->syntax_err(_linenum, "%s: %s %s not mentioned in effect or match rule\n",
 984         //                        _ident, opForm->_ident, name);
 985         // }
 986         _components.insert(name, opForm->_ident, Component::INVALID, false);
 987       }
 988     }
 989     else if (e) {
 990       // Component was found in the list
 991       // Check if there is a new effect that requires an extra component.
 992       // This happens when adding 'USE' to a component that is not yet one.
 993       if ((!component->isa( Component::USE) && ((e->_use_def & Component::USE) != 0))) {
 994         if (component->isa(Component::USE) && _matrule) {
 995           const Form *form = globalAD->globalNames()[component->_type];
 996           assert( form, "component type must be a defined form");
 997           OperandForm *op   = form->is_operand();
 998           if (op->_interface && op->_interface->is_RegInterface()) {
 999             globalAD->syntax_err(_linenum, "%s: illegal USE of non-input: %s %s\n",
1000                                  _ident, opForm->_ident, name);
1001           }
1002         }
1003         _components.insert(name, opForm->_ident, e->_use_def, false);
1004       } else {
1005         Component  *comp = (Component*)component;
1006         comp->promote_use_def_info(e->_use_def);
1007       }
1008       // Component positions are zero based.
1009       int  pos  = _components.operand_position(name);
1010       assert( ! (component->isa(Component::DEF) && (pos >= 1)),
1011               "Component::DEF can only occur in the first position");
1012     }
1013   }
1014 
1015   // Resolving the interactions between expand rules and TEMPs would
1016   // be complex so simply disallow it.
1017   if (_matrule == NULL && has_temp) {
1018     globalAD->syntax_err(_linenum, "%s: TEMPs without match rule isn't supported\n", _ident);
1019   }
1020 
1021   return;
1022 }
1023 
1024 // Return zero-based position in component list;  -1 if not in list.
1025 int   InstructForm::operand_position(const char *name, int usedef) {
1026   return unique_opnds_idx(_components.operand_position(name, usedef, this));
1027 }
1028 
1029 int   InstructForm::operand_position_format(const char *name) {
1030   return unique_opnds_idx(_components.operand_position_format(name, this));
1031 }
1032 
1033 // Return zero-based position in component list; -1 if not in list.
1034 int   InstructForm::label_position() {
1035   return unique_opnds_idx(_components.label_position());
1036 }
1037 
1038 int   InstructForm::method_position() {
1039   return unique_opnds_idx(_components.method_position());
1040 }
1041 
1042 // Return number of relocation entries needed for this instruction.
1043 uint  InstructForm::reloc(FormDict &globals) {
1044   uint reloc_entries  = 0;
1045   // Check for "Call" nodes
1046   if ( is_ideal_call() )      ++reloc_entries;
1047   if ( is_ideal_return() )    ++reloc_entries;
1048   if ( is_ideal_safepoint() ) ++reloc_entries;
1049 
1050 
1051   // Check if operands MAYBE oop pointers, by checking for ConP elements
1052   // Proceed through the leaves of the match-tree and check for ConPs
1053   if ( _matrule != NULL ) {
1054     uint         position = 0;
1055     const char  *result   = NULL;
1056     const char  *name     = NULL;
1057     const char  *opType   = NULL;
1058     while (_matrule->base_operand(position, globals, result, name, opType)) {
1059       if ( strcmp(opType,"ConP") == 0 ) {
1060         ++reloc_entries;
1061       }
1062       ++position;
1063     }
1064   }
1065 
1066   // Above is only a conservative estimate
1067   // because it did not check contents of operand classes.
1068   // !!!!! !!!!!
1069   // Add 1 to reloc info for each operand class in the component list.
1070   Component  *comp;
1071   _components.reset();
1072   while ( (comp = _components.iter()) != NULL ) {
1073     const Form        *form = globals[comp->_type];
1074     assert( form, "Did not find component's type in global names");
1075     const OpClassForm *opc  = form->is_opclass();
1076     const OperandForm *oper = form->is_operand();
1077     if ( opc && (oper == NULL) ) {
1078       ++reloc_entries;
1079     } else if ( oper ) {
1080       // floats and doubles loaded out of method's constant pool require reloc info
1081       Form::DataType type = oper->is_base_constant(globals);
1082       if ( (type == Form::idealF) || (type == Form::idealD) ) {
1083         ++reloc_entries;
1084       }
1085     }
1086   }
1087 
1088   // Float and Double constants may come from the CodeBuffer table
1089   // and require relocatable addresses for access
1090   // !!!!!
1091   // Check for any component being an immediate float or double.
1092   Form::DataType data_type = is_chain_of_constant(globals);
1093   if( data_type==idealD || data_type==idealF ) {
1094     reloc_entries++;
1095   }
1096 
1097   return reloc_entries;
1098 }
1099 
1100 // Utility function defined in archDesc.cpp
1101 extern bool is_def(int usedef);
1102 
1103 // Return the result of reducing an instruction
1104 const char *InstructForm::reduce_result() {
1105   const char* result = "Universe";  // default
1106   _components.reset();
1107   Component *comp = _components.iter();
1108   if (comp != NULL && comp->isa(Component::DEF)) {
1109     result = comp->_type;
1110     // Override this if the rule is a store operation:
1111     if (_matrule && _matrule->_rChild &&
1112         is_store_to_memory(_matrule->_rChild->_opType))
1113       result = "Universe";
1114   }
1115   return result;
1116 }
1117 
1118 // Return the name of the operand on the right hand side of the binary match
1119 // Return NULL if there is no right hand side
1120 const char *InstructForm::reduce_right(FormDict &globals)  const {
1121   if( _matrule == NULL ) return NULL;
1122   return  _matrule->reduce_right(globals);
1123 }
1124 
1125 // Similar for left
1126 const char *InstructForm::reduce_left(FormDict &globals)   const {
1127   if( _matrule == NULL ) return NULL;
1128   return  _matrule->reduce_left(globals);
1129 }
1130 
1131 
1132 // Base class for this instruction, MachNode except for calls
1133 const char *InstructForm::mach_base_class(FormDict &globals)  const {
1134   if( is_ideal_call() == Form::JAVA_STATIC ) {
1135     return "MachCallStaticJavaNode";
1136   }
1137   else if( is_ideal_call() == Form::JAVA_DYNAMIC ) {
1138     return "MachCallDynamicJavaNode";
1139   }
1140   else if( is_ideal_call() == Form::JAVA_RUNTIME ) {
1141     return "MachCallRuntimeNode";
1142   }
1143   else if( is_ideal_call() == Form::JAVA_LEAF ) {
1144     return "MachCallLeafNode";
1145   }
1146   else if( is_ideal_call() == Form::JAVA_NATIVE ) {
1147     return "MachCallNativeNode";
1148   }
1149   else if (is_ideal_return()) {
1150     return "MachReturnNode";
1151   }
1152   else if (is_ideal_halt()) {
1153     return "MachHaltNode";
1154   }
1155   else if (is_ideal_safepoint()) {
1156     return "MachSafePointNode";
1157   }
1158   else if (is_ideal_if()) {
1159     return "MachIfNode";
1160   }
1161   else if (is_ideal_goto()) {
1162     return "MachGotoNode";
1163   }
1164   else if (is_ideal_fastlock()) {
1165     return "MachFastLockNode";
1166   }
1167   else if (is_ideal_nop()) {
1168     return "MachNopNode";
1169   }
1170   else if( is_ideal_membar()) {
1171     return "MachMemBarNode";
1172   }
1173   else if (is_ideal_jump()) {
1174     return "MachJumpNode";
1175   }
1176   else if (is_mach_constant()) {
1177     return "MachConstantNode";
1178   }
1179   else if (captures_bottom_type(globals)) {
1180     return "MachTypeNode";
1181   } else {
1182     return "MachNode";
1183   }
1184   assert( false, "ShouldNotReachHere()");
1185   return NULL;
1186 }
1187 
1188 // Compare the instruction predicates for textual equality
1189 bool equivalent_predicates( const InstructForm *instr1, const InstructForm *instr2 ) {
1190   const Predicate *pred1  = instr1->_predicate;
1191   const Predicate *pred2  = instr2->_predicate;
1192   if( pred1 == NULL && pred2 == NULL ) {
1193     // no predicates means they are identical
1194     return true;
1195   }
1196   if( pred1 != NULL && pred2 != NULL ) {
1197     // compare the predicates
1198     if (ADLParser::equivalent_expressions(pred1->_pred, pred2->_pred)) {
1199       return true;
1200     }
1201   }
1202 
1203   return false;
1204 }
1205 
1206 // Check if this instruction can cisc-spill to 'alternate'
1207 bool InstructForm::cisc_spills_to(ArchDesc &AD, InstructForm *instr) {
1208   assert( _matrule != NULL && instr->_matrule != NULL, "must have match rules");
1209   // Do not replace if a cisc-version has been found.
1210   if( cisc_spill_operand() != Not_cisc_spillable ) return false;
1211 
1212   int         cisc_spill_operand = Maybe_cisc_spillable;
1213   char       *result             = NULL;
1214   char       *result2            = NULL;
1215   const char *op_name            = NULL;
1216   const char *reg_type           = NULL;
1217   FormDict   &globals            = AD.globalNames();
1218   cisc_spill_operand = _matrule->matchrule_cisc_spill_match(globals, AD.get_registers(), instr->_matrule, op_name, reg_type);
1219   if( (cisc_spill_operand != Not_cisc_spillable) && (op_name != NULL) && equivalent_predicates(this, instr) ) {
1220     cisc_spill_operand = operand_position(op_name, Component::USE);
1221     int def_oper  = operand_position(op_name, Component::DEF);
1222     if( def_oper == NameList::Not_in_list && instr->num_opnds() == num_opnds()) {
1223       // Do not support cisc-spilling for destination operands and
1224       // make sure they have the same number of operands.
1225       _cisc_spill_alternate = instr;
1226       instr->set_cisc_alternate(true);
1227       if( AD._cisc_spill_debug ) {
1228         fprintf(stderr, "Instruction %s cisc-spills-to %s\n", _ident, instr->_ident);
1229         fprintf(stderr, "   using operand %s %s at index %d\n", reg_type, op_name, cisc_spill_operand);
1230       }
1231       // Record that a stack-version of the reg_mask is needed
1232       // !!!!!
1233       OperandForm *oper = (OperandForm*)(globals[reg_type]->is_operand());
1234       assert( oper != NULL, "cisc-spilling non operand");
1235       const char *reg_class_name = oper->constrained_reg_class();
1236       AD.set_stack_or_reg(reg_class_name);
1237       const char *reg_mask_name  = AD.reg_mask(*oper);
1238       set_cisc_reg_mask_name(reg_mask_name);
1239       const char *stack_or_reg_mask_name = AD.stack_or_reg_mask(*oper);
1240     } else {
1241       cisc_spill_operand = Not_cisc_spillable;
1242     }
1243   } else {
1244     cisc_spill_operand = Not_cisc_spillable;
1245   }
1246 
1247   set_cisc_spill_operand(cisc_spill_operand);
1248   return (cisc_spill_operand != Not_cisc_spillable);
1249 }
1250 
1251 // Check to see if this instruction can be replaced with the short branch
1252 // instruction `short-branch'
1253 bool InstructForm::check_branch_variant(ArchDesc &AD, InstructForm *short_branch) {
1254   if (_matrule != NULL &&
1255       this != short_branch &&   // Don't match myself
1256       !is_short_branch() &&     // Don't match another short branch variant
1257       reduce_result() != NULL &&
1258       strstr(_ident, "restoreMask") == NULL && // Don't match side effects
1259       strcmp(reduce_result(), short_branch->reduce_result()) == 0 &&
1260       _matrule->equivalent(AD.globalNames(), short_branch->_matrule)) {
1261     // The instructions are equivalent.
1262 
1263     // Now verify that both instructions have the same parameters and
1264     // the same effects. Both branch forms should have the same inputs
1265     // and resulting projections to correctly replace a long branch node
1266     // with corresponding short branch node during code generation.
1267 
1268     bool different = false;
1269     if (short_branch->_components.count() != _components.count()) {
1270        different = true;
1271     } else if (_components.count() > 0) {
1272       short_branch->_components.reset();
1273       _components.reset();
1274       Component *comp;
1275       while ((comp = _components.iter()) != NULL) {
1276         Component *short_comp = short_branch->_components.iter();
1277         if (short_comp == NULL ||
1278             short_comp->_type != comp->_type ||
1279             short_comp->_usedef != comp->_usedef) {
1280           different = true;
1281           break;
1282         }
1283       }
1284       if (short_branch->_components.iter() != NULL)
1285         different = true;
1286     }
1287     if (different) {
1288       globalAD->syntax_err(short_branch->_linenum, "Instruction %s and its short form %s have different parameters\n", _ident, short_branch->_ident);
1289     }
1290     if (AD._adl_debug > 1 || AD._short_branch_debug) {
1291       fprintf(stderr, "Instruction %s has short form %s\n", _ident, short_branch->_ident);
1292     }
1293     _short_branch_form = short_branch;
1294     return true;
1295   }
1296   return false;
1297 }
1298 
1299 
1300 // --------------------------- FILE *output_routines
1301 //
1302 // Generate the format call for the replacement variable
1303 void InstructForm::rep_var_format(FILE *fp, const char *rep_var) {
1304   // Handle special constant table variables.
1305   if (strcmp(rep_var, "constanttablebase") == 0) {
1306     fprintf(fp, "char reg[128];  ra->dump_register(in(mach_constant_base_node_input()), reg);\n");
1307     fprintf(fp, "    st->print(\"%%s\", reg);\n");
1308     return;
1309   }
1310   if (strcmp(rep_var, "constantoffset") == 0) {
1311     fprintf(fp, "st->print(\"#%%d\", constant_offset_unchecked());\n");
1312     return;
1313   }
1314   if (strcmp(rep_var, "constantaddress") == 0) {
1315     fprintf(fp, "st->print(\"constant table base + #%%d\", constant_offset_unchecked());\n");
1316     return;
1317   }
1318 
1319   // Find replacement variable's type
1320   const Form *form   = _localNames[rep_var];
1321   if (form == NULL) {
1322     globalAD->syntax_err(_linenum, "Unknown replacement variable %s in format statement of %s.",
1323                          rep_var, _ident);
1324     return;
1325   }
1326   OpClassForm *opc   = form->is_opclass();
1327   assert( opc, "replacement variable was not found in local names");
1328   // Lookup the index position of the replacement variable
1329   int idx  = operand_position_format(rep_var);
1330   if ( idx == -1 ) {
1331     globalAD->syntax_err(_linenum, "Could not find replacement variable %s in format statement of %s.\n",
1332                          rep_var, _ident);
1333     assert(strcmp(opc->_ident, "label") == 0, "Unimplemented");
1334     return;
1335   }
1336 
1337   if (is_noninput_operand(idx)) {
1338     // This component isn't in the input array.  Print out the static
1339     // name of the register.
1340     OperandForm* oper = form->is_operand();
1341     if (oper != NULL && oper->is_bound_register()) {
1342       const RegDef* first = oper->get_RegClass()->find_first_elem();
1343       fprintf(fp, "    st->print_raw(\"%s\");\n", first->_regname);
1344     } else {
1345       globalAD->syntax_err(_linenum, "In %s can't find format for %s %s", _ident, opc->_ident, rep_var);
1346     }
1347   } else {
1348     // Output the format call for this operand
1349     fprintf(fp,"opnd_array(%d)->",idx);
1350     if (idx == 0)
1351       fprintf(fp,"int_format(ra, this, st); // %s\n", rep_var);
1352     else
1353       fprintf(fp,"ext_format(ra, this,idx%d, st); // %s\n", idx, rep_var );
1354   }
1355 }
1356 
1357 // Seach through operands to determine parameters unique positions.
1358 void InstructForm::set_unique_opnds() {
1359   uint* uniq_idx = NULL;
1360   uint  nopnds = num_opnds();
1361   uint  num_uniq = nopnds;
1362   uint i;
1363   _uniq_idx_length = 0;
1364   if (nopnds > 0) {
1365     // Allocate index array.  Worst case we're mapping from each
1366     // component back to an index and any DEF always goes at 0 so the
1367     // length of the array has to be the number of components + 1.
1368     _uniq_idx_length = _components.count() + 1;
1369     uniq_idx = (uint*) AllocateHeap(sizeof(uint) * _uniq_idx_length);
1370     for (i = 0; i < _uniq_idx_length; i++) {
1371       uniq_idx[i] = i;
1372     }
1373   }
1374   // Do it only if there is a match rule and no expand rule.  With an
1375   // expand rule it is done by creating new mach node in Expand()
1376   // method.
1377   if (nopnds > 0 && _matrule != NULL && _exprule == NULL) {
1378     const char *name;
1379     uint count;
1380     bool has_dupl_use = false;
1381 
1382     _parameters.reset();
1383     while ((name = _parameters.iter()) != NULL) {
1384       count = 0;
1385       uint position = 0;
1386       uint uniq_position = 0;
1387       _components.reset();
1388       Component *comp = NULL;
1389       if (sets_result()) {
1390         comp = _components.iter();
1391         position++;
1392       }
1393       // The next code is copied from the method operand_position().
1394       for (; (comp = _components.iter()) != NULL; ++position) {
1395         // When the first component is not a DEF,
1396         // leave space for the result operand!
1397         if (position==0 && (!comp->isa(Component::DEF))) {
1398           ++position;
1399         }
1400         if (strcmp(name, comp->_name) == 0) {
1401           if (++count > 1) {
1402             assert(position < _uniq_idx_length, "out of bounds");
1403             uniq_idx[position] = uniq_position;
1404             has_dupl_use = true;
1405           } else {
1406             uniq_position = position;
1407           }
1408         }
1409         if (comp->isa(Component::DEF) && comp->isa(Component::USE)) {
1410           ++position;
1411           if (position != 1)
1412             --position;   // only use two slots for the 1st USE_DEF
1413         }
1414       }
1415     }
1416     if (has_dupl_use) {
1417       for (i = 1; i < nopnds; i++) {
1418         if (i != uniq_idx[i]) {
1419           break;
1420         }
1421       }
1422       uint j = i;
1423       for (; i < nopnds; i++) {
1424         if (i == uniq_idx[i]) {
1425           uniq_idx[i] = j++;
1426         }
1427       }
1428       num_uniq = j;
1429     }
1430   }
1431   _uniq_idx = uniq_idx;
1432   _num_uniq = num_uniq;
1433 }
1434 
1435 // Generate index values needed for determining the operand position
1436 void InstructForm::index_temps(FILE *fp, FormDict &globals, const char *prefix, const char *receiver) {
1437   uint  idx = 0;                  // position of operand in match rule
1438   int   cur_num_opnds = num_opnds();
1439 
1440   // Compute the index into vector of operand pointers:
1441   // idx0=0 is used to indicate that info comes from this same node, not from input edge.
1442   // idx1 starts at oper_input_base()
1443   if ( cur_num_opnds >= 1 ) {
1444     fprintf(fp,"  // Start at oper_input_base() and count operands\n");
1445     fprintf(fp,"  unsigned %sidx0 = %d;\n", prefix, oper_input_base(globals));
1446     fprintf(fp,"  unsigned %sidx1 = %d;", prefix, oper_input_base(globals));
1447     fprintf(fp," \t// %s\n", unique_opnd_ident(1));
1448 
1449     // Generate starting points for other unique operands if they exist
1450     for ( idx = 2; idx < num_unique_opnds(); ++idx ) {
1451       if( *receiver == 0 ) {
1452         fprintf(fp,"  unsigned %sidx%d = %sidx%d + opnd_array(%d)->num_edges();",
1453                 prefix, idx, prefix, idx-1, idx-1 );
1454       } else {
1455         fprintf(fp,"  unsigned %sidx%d = %sidx%d + %s_opnds[%d]->num_edges();",
1456                 prefix, idx, prefix, idx-1, receiver, idx-1 );
1457       }
1458       fprintf(fp," \t// %s\n", unique_opnd_ident(idx));
1459     }
1460   }
1461   if( *receiver != 0 ) {
1462     // This value is used by generate_peepreplace when copying a node.
1463     // Don't emit it in other cases since it can hide bugs with the
1464     // use invalid idx's.
1465     fprintf(fp,"  unsigned %sidx%d = %sreq(); \n", prefix, idx, receiver);
1466   }
1467 
1468 }
1469 
1470 // ---------------------------
1471 bool InstructForm::verify() {
1472   // !!!!! !!!!!
1473   // Check that a "label" operand occurs last in the operand list, if present
1474   return true;
1475 }
1476 
1477 void InstructForm::dump() {
1478   output(stderr);
1479 }
1480 
1481 void InstructForm::output(FILE *fp) {
1482   fprintf(fp,"\nInstruction: %s\n", (_ident?_ident:""));
1483   if (_matrule)   _matrule->output(fp);
1484   if (_insencode) _insencode->output(fp);
1485   if (_constant)  _constant->output(fp);
1486   if (_opcode)    _opcode->output(fp);
1487   if (_attribs)   _attribs->output(fp);
1488   if (_predicate) _predicate->output(fp);
1489   if (_effects.Size()) {
1490     fprintf(fp,"Effects\n");
1491     _effects.dump();
1492   }
1493   if (_exprule)   _exprule->output(fp);
1494   if (_rewrule)   _rewrule->output(fp);
1495   if (_format)    _format->output(fp);
1496   if (_peephole)  _peephole->output(fp);
1497 }
1498 
1499 void MachNodeForm::dump() {
1500   output(stderr);
1501 }
1502 
1503 void MachNodeForm::output(FILE *fp) {
1504   fprintf(fp,"\nMachNode: %s\n", (_ident?_ident:""));
1505 }
1506 
1507 //------------------------------build_predicate--------------------------------
1508 // Build instruction predicates.  If the user uses the same operand name
1509 // twice, we need to check that the operands are pointer-eequivalent in
1510 // the DFA during the labeling process.
1511 Predicate *InstructForm::build_predicate() {
1512   const int buflen = 1024;
1513   char buf[buflen], *s=buf;
1514   Dict names(cmpstr,hashstr,Form::arena);       // Map Names to counts
1515 
1516   MatchNode *mnode =
1517     strcmp(_matrule->_opType, "Set") ? _matrule : _matrule->_rChild;
1518   if (mnode != NULL) mnode->count_instr_names(names);
1519 
1520   uint first = 1;
1521   // Start with the predicate supplied in the .ad file.
1522   if (_predicate) {
1523     if (first) first = 0;
1524     strcpy(s, "("); s += strlen(s);
1525     strncpy(s, _predicate->_pred, buflen - strlen(s) - 1);
1526     s += strlen(s);
1527     strcpy(s, ")"); s += strlen(s);
1528   }
1529   for( DictI i(&names); i.test(); ++i ) {
1530     uintptr_t cnt = (uintptr_t)i._value;
1531     if( cnt > 1 ) {             // Need a predicate at all?
1532       int path_bitmask = 0;
1533       assert( cnt == 2, "Unimplemented" );
1534       // Handle many pairs
1535       if( first ) first=0;
1536       else {                    // All tests must pass, so use '&&'
1537         strcpy(s," && ");
1538         s += strlen(s);
1539       }
1540       // Add predicate to working buffer
1541       sprintf(s,"/*%s*/(",(char*)i._key);
1542       s += strlen(s);
1543       mnode->build_instr_pred(s,(char*)i._key, 0, path_bitmask, 0);
1544       s += strlen(s);
1545       strcpy(s," == "); s += strlen(s);
1546       mnode->build_instr_pred(s,(char*)i._key, 1, path_bitmask, 0);
1547       s += strlen(s);
1548       strcpy(s,")"); s += strlen(s);
1549     }
1550   }
1551   if( s == buf ) s = NULL;
1552   else {
1553     assert( strlen(buf) < sizeof(buf), "String buffer overflow" );
1554     s = strdup(buf);
1555   }
1556   return new Predicate(s);
1557 }
1558 
1559 //------------------------------EncodeForm-------------------------------------
1560 // Constructor
1561 EncodeForm::EncodeForm()
1562   : _encClass(cmpstr,hashstr, Form::arena) {
1563 }
1564 EncodeForm::~EncodeForm() {
1565 }
1566 
1567 // record a new register class
1568 EncClass *EncodeForm::add_EncClass(const char *className) {
1569   EncClass *encClass = new EncClass(className);
1570   _eclasses.addName(className);
1571   _encClass.Insert(className,encClass);
1572   return encClass;
1573 }
1574 
1575 // Lookup the function body for an encoding class
1576 EncClass  *EncodeForm::encClass(const char *className) {
1577   assert( className != NULL, "Must provide a defined encoding name");
1578 
1579   EncClass *encClass = (EncClass*)_encClass[className];
1580   return encClass;
1581 }
1582 
1583 // Lookup the function body for an encoding class
1584 const char *EncodeForm::encClassBody(const char *className) {
1585   if( className == NULL ) return NULL;
1586 
1587   EncClass *encClass = (EncClass*)_encClass[className];
1588   assert( encClass != NULL, "Encode Class is missing.");
1589   encClass->_code.reset();
1590   const char *code = (const char*)encClass->_code.iter();
1591   assert( code != NULL, "Found an empty encode class body.");
1592 
1593   return code;
1594 }
1595 
1596 // Lookup the function body for an encoding class
1597 const char *EncodeForm::encClassPrototype(const char *className) {
1598   assert( className != NULL, "Encode class name must be non NULL.");
1599 
1600   return className;
1601 }
1602 
1603 void EncodeForm::dump() {                  // Debug printer
1604   output(stderr);
1605 }
1606 
1607 void EncodeForm::output(FILE *fp) {          // Write info to output files
1608   const char *name;
1609   fprintf(fp,"\n");
1610   fprintf(fp,"-------------------- Dump EncodeForm --------------------\n");
1611   for (_eclasses.reset(); (name = _eclasses.iter()) != NULL;) {
1612     ((EncClass*)_encClass[name])->output(fp);
1613   }
1614   fprintf(fp,"-------------------- end  EncodeForm --------------------\n");
1615 }
1616 //------------------------------EncClass---------------------------------------
1617 EncClass::EncClass(const char *name)
1618   : _localNames(cmpstr,hashstr, Form::arena), _name(name) {
1619 }
1620 EncClass::~EncClass() {
1621 }
1622 
1623 // Add a parameter <type,name> pair
1624 void EncClass::add_parameter(const char *parameter_type, const char *parameter_name) {
1625   _parameter_type.addName( parameter_type );
1626   _parameter_name.addName( parameter_name );
1627 }
1628 
1629 // Verify operand types in parameter list
1630 bool EncClass::check_parameter_types(FormDict &globals) {
1631   // !!!!!
1632   return false;
1633 }
1634 
1635 // Add the decomposed "code" sections of an encoding's code-block
1636 void EncClass::add_code(const char *code) {
1637   _code.addName(code);
1638 }
1639 
1640 // Add the decomposed "replacement variables" of an encoding's code-block
1641 void EncClass::add_rep_var(char *replacement_var) {
1642   _code.addName(NameList::_signal);
1643   _rep_vars.addName(replacement_var);
1644 }
1645 
1646 // Lookup the function body for an encoding class
1647 int EncClass::rep_var_index(const char *rep_var) {
1648   uint        position = 0;
1649   const char *name     = NULL;
1650 
1651   _parameter_name.reset();
1652   while ( (name = _parameter_name.iter()) != NULL ) {
1653     if ( strcmp(rep_var,name) == 0 ) return position;
1654     ++position;
1655   }
1656 
1657   return -1;
1658 }
1659 
1660 // Check after parsing
1661 bool EncClass::verify() {
1662   // 1!!!!
1663   // Check that each replacement variable, '$name' in architecture description
1664   // is actually a local variable for this encode class, or a reserved name
1665   // "primary, secondary, tertiary"
1666   return true;
1667 }
1668 
1669 void EncClass::dump() {
1670   output(stderr);
1671 }
1672 
1673 // Write info to output files
1674 void EncClass::output(FILE *fp) {
1675   fprintf(fp,"EncClass: %s", (_name ? _name : ""));
1676 
1677   // Output the parameter list
1678   _parameter_type.reset();
1679   _parameter_name.reset();
1680   const char *type = _parameter_type.iter();
1681   const char *name = _parameter_name.iter();
1682   fprintf(fp, " ( ");
1683   for ( ; (type != NULL) && (name != NULL);
1684         (type = _parameter_type.iter()), (name = _parameter_name.iter()) ) {
1685     fprintf(fp, " %s %s,", type, name);
1686   }
1687   fprintf(fp, " ) ");
1688 
1689   // Output the code block
1690   _code.reset();
1691   _rep_vars.reset();
1692   const char *code;
1693   while ( (code = _code.iter()) != NULL ) {
1694     if ( _code.is_signal(code) ) {
1695       // A replacement variable
1696       const char *rep_var = _rep_vars.iter();
1697       fprintf(fp,"($%s)", rep_var);
1698     } else {
1699       // A section of code
1700       fprintf(fp,"%s", code);
1701     }
1702   }
1703 
1704 }
1705 
1706 //------------------------------Opcode-----------------------------------------
1707 Opcode::Opcode(char *primary, char *secondary, char *tertiary)
1708   : _primary(primary), _secondary(secondary), _tertiary(tertiary) {
1709 }
1710 
1711 Opcode::~Opcode() {
1712 }
1713 
1714 Opcode::opcode_type Opcode::as_opcode_type(const char *param) {
1715   if( strcmp(param,"primary") == 0 ) {
1716     return Opcode::PRIMARY;
1717   }
1718   else if( strcmp(param,"secondary") == 0 ) {
1719     return Opcode::SECONDARY;
1720   }
1721   else if( strcmp(param,"tertiary") == 0 ) {
1722     return Opcode::TERTIARY;
1723   }
1724   return Opcode::NOT_AN_OPCODE;
1725 }
1726 
1727 bool Opcode::print_opcode(FILE *fp, Opcode::opcode_type desired_opcode) {
1728   // Default values previously provided by MachNode::primary()...
1729   const char *description = NULL;
1730   const char *value       = NULL;
1731   // Check if user provided any opcode definitions
1732   // Update 'value' if user provided a definition in the instruction
1733   switch (desired_opcode) {
1734   case PRIMARY:
1735     description = "primary()";
1736     if( _primary   != NULL)  { value = _primary;     }
1737     break;
1738   case SECONDARY:
1739     description = "secondary()";
1740     if( _secondary != NULL ) { value = _secondary;   }
1741     break;
1742   case TERTIARY:
1743     description = "tertiary()";
1744     if( _tertiary  != NULL ) { value = _tertiary;    }
1745     break;
1746   default:
1747     assert( false, "ShouldNotReachHere();");
1748     break;
1749   }
1750 
1751   if (value != NULL) {
1752     fprintf(fp, "(%s /*%s*/)", value, description);
1753   }
1754   return value != NULL;
1755 }
1756 
1757 void Opcode::dump() {
1758   output(stderr);
1759 }
1760 
1761 // Write info to output files
1762 void Opcode::output(FILE *fp) {
1763   if (_primary   != NULL) fprintf(fp,"Primary   opcode: %s\n", _primary);
1764   if (_secondary != NULL) fprintf(fp,"Secondary opcode: %s\n", _secondary);
1765   if (_tertiary  != NULL) fprintf(fp,"Tertiary  opcode: %s\n", _tertiary);
1766 }
1767 
1768 //------------------------------InsEncode--------------------------------------
1769 InsEncode::InsEncode() {
1770 }
1771 InsEncode::~InsEncode() {
1772 }
1773 
1774 // Add "encode class name" and its parameters
1775 NameAndList *InsEncode::add_encode(char *encoding) {
1776   assert( encoding != NULL, "Must provide name for encoding");
1777 
1778   // add_parameter(NameList::_signal);
1779   NameAndList *encode = new NameAndList(encoding);
1780   _encoding.addName((char*)encode);
1781 
1782   return encode;
1783 }
1784 
1785 // Access the list of encodings
1786 void InsEncode::reset() {
1787   _encoding.reset();
1788   // _parameter.reset();
1789 }
1790 const char* InsEncode::encode_class_iter() {
1791   NameAndList  *encode_class = (NameAndList*)_encoding.iter();
1792   return  ( encode_class != NULL ? encode_class->name() : NULL );
1793 }
1794 // Obtain parameter name from zero based index
1795 const char *InsEncode::rep_var_name(InstructForm &inst, uint param_no) {
1796   NameAndList *params = (NameAndList*)_encoding.current();
1797   assert( params != NULL, "Internal Error");
1798   const char *param = (*params)[param_no];
1799 
1800   // Remove '$' if parser placed it there.
1801   return ( param != NULL && *param == '$') ? (param+1) : param;
1802 }
1803 
1804 void InsEncode::dump() {
1805   output(stderr);
1806 }
1807 
1808 // Write info to output files
1809 void InsEncode::output(FILE *fp) {
1810   NameAndList *encoding  = NULL;
1811   const char  *parameter = NULL;
1812 
1813   fprintf(fp,"InsEncode: ");
1814   _encoding.reset();
1815 
1816   while ( (encoding = (NameAndList*)_encoding.iter()) != 0 ) {
1817     // Output the encoding being used
1818     fprintf(fp,"%s(", encoding->name() );
1819 
1820     // Output its parameter list, if any
1821     bool first_param = true;
1822     encoding->reset();
1823     while (  (parameter = encoding->iter()) != 0 ) {
1824       // Output the ',' between parameters
1825       if ( ! first_param )  fprintf(fp,", ");
1826       first_param = false;
1827       // Output the parameter
1828       fprintf(fp,"%s", parameter);
1829     } // done with parameters
1830     fprintf(fp,")  ");
1831   } // done with encodings
1832 
1833   fprintf(fp,"\n");
1834 }
1835 
1836 //------------------------------Effect-----------------------------------------
1837 static int effect_lookup(const char *name) {
1838   if (!strcmp(name, "USE")) return Component::USE;
1839   if (!strcmp(name, "DEF")) return Component::DEF;
1840   if (!strcmp(name, "USE_DEF")) return Component::USE_DEF;
1841   if (!strcmp(name, "KILL")) return Component::KILL;
1842   if (!strcmp(name, "USE_KILL")) return Component::USE_KILL;
1843   if (!strcmp(name, "TEMP")) return Component::TEMP;
1844   if (!strcmp(name, "TEMP_DEF")) return Component::TEMP_DEF;
1845   if (!strcmp(name, "INVALID")) return Component::INVALID;
1846   if (!strcmp(name, "CALL")) return Component::CALL;
1847   assert(false,"Invalid effect name specified\n");
1848   return Component::INVALID;
1849 }
1850 
1851 const char *Component::getUsedefName() {
1852   switch (_usedef) {
1853     case Component::INVALID:  return "INVALID";  break;
1854     case Component::USE:      return "USE";      break;
1855     case Component::USE_DEF:  return "USE_DEF";  break;
1856     case Component::USE_KILL: return "USE_KILL"; break;
1857     case Component::KILL:     return "KILL";     break;
1858     case Component::TEMP:     return "TEMP";     break;
1859     case Component::TEMP_DEF: return "TEMP_DEF"; break;
1860     case Component::DEF:      return "DEF";      break;
1861     case Component::CALL:     return "CALL";     break;
1862     default: assert(false, "unknown effect");
1863   }
1864   return "Undefined Use/Def info";
1865 }
1866 
1867 Effect::Effect(const char *name) : _name(name), _use_def(effect_lookup(name)) {
1868   _ftype = Form::EFF;
1869 }
1870 
1871 Effect::~Effect() {
1872 }
1873 
1874 // Dynamic type check
1875 Effect *Effect::is_effect() const {
1876   return (Effect*)this;
1877 }
1878 
1879 
1880 // True if this component is equal to the parameter.
1881 bool Effect::is(int use_def_kill_enum) const {
1882   return (_use_def == use_def_kill_enum ? true : false);
1883 }
1884 // True if this component is used/def'd/kill'd as the parameter suggests.
1885 bool Effect::isa(int use_def_kill_enum) const {
1886   return (_use_def & use_def_kill_enum) == use_def_kill_enum;
1887 }
1888 
1889 void Effect::dump() {
1890   output(stderr);
1891 }
1892 
1893 void Effect::output(FILE *fp) {          // Write info to output files
1894   fprintf(fp,"Effect: %s\n", (_name?_name:""));
1895 }
1896 
1897 //------------------------------ExpandRule-------------------------------------
1898 ExpandRule::ExpandRule() : _expand_instrs(),
1899                            _newopconst(cmpstr, hashstr, Form::arena) {
1900   _ftype = Form::EXP;
1901 }
1902 
1903 ExpandRule::~ExpandRule() {                  // Destructor
1904 }
1905 
1906 void ExpandRule::add_instruction(NameAndList *instruction_name_and_operand_list) {
1907   _expand_instrs.addName((char*)instruction_name_and_operand_list);
1908 }
1909 
1910 void ExpandRule::reset_instructions() {
1911   _expand_instrs.reset();
1912 }
1913 
1914 NameAndList* ExpandRule::iter_instructions() {
1915   return (NameAndList*)_expand_instrs.iter();
1916 }
1917 
1918 
1919 void ExpandRule::dump() {
1920   output(stderr);
1921 }
1922 
1923 void ExpandRule::output(FILE *fp) {         // Write info to output files
1924   NameAndList *expand_instr = NULL;
1925   const char *opid = NULL;
1926 
1927   fprintf(fp,"\nExpand Rule:\n");
1928 
1929   // Iterate over the instructions 'node' expands into
1930   for(reset_instructions(); (expand_instr = iter_instructions()) != NULL; ) {
1931     fprintf(fp,"%s(", expand_instr->name());
1932 
1933     // iterate over the operand list
1934     for( expand_instr->reset(); (opid = expand_instr->iter()) != NULL; ) {
1935       fprintf(fp,"%s ", opid);
1936     }
1937     fprintf(fp,");\n");
1938   }
1939 }
1940 
1941 //------------------------------RewriteRule------------------------------------
1942 RewriteRule::RewriteRule(char* params, char* block)
1943   : _tempParams(params), _tempBlock(block) { };  // Constructor
1944 RewriteRule::~RewriteRule() {                 // Destructor
1945 }
1946 
1947 void RewriteRule::dump() {
1948   output(stderr);
1949 }
1950 
1951 void RewriteRule::output(FILE *fp) {         // Write info to output files
1952   fprintf(fp,"\nRewrite Rule:\n%s\n%s\n",
1953           (_tempParams?_tempParams:""),
1954           (_tempBlock?_tempBlock:""));
1955 }
1956 
1957 
1958 //==============================MachNodes======================================
1959 //------------------------------MachNodeForm-----------------------------------
1960 MachNodeForm::MachNodeForm(char *id)
1961   : _ident(id) {
1962 }
1963 
1964 MachNodeForm::~MachNodeForm() {
1965 }
1966 
1967 MachNodeForm *MachNodeForm::is_machnode() const {
1968   return (MachNodeForm*)this;
1969 }
1970 
1971 //==============================Operand Classes================================
1972 //------------------------------OpClassForm------------------------------------
1973 OpClassForm::OpClassForm(const char* id) : _ident(id) {
1974   _ftype = Form::OPCLASS;
1975 }
1976 
1977 OpClassForm::~OpClassForm() {
1978 }
1979 
1980 bool OpClassForm::ideal_only() const { return 0; }
1981 
1982 OpClassForm *OpClassForm::is_opclass() const {
1983   return (OpClassForm*)this;
1984 }
1985 
1986 Form::InterfaceType OpClassForm::interface_type(FormDict &globals) const {
1987   if( _oplst.count() == 0 ) return Form::no_interface;
1988 
1989   // Check that my operands have the same interface type
1990   Form::InterfaceType  interface;
1991   bool  first = true;
1992   NameList &op_list = (NameList &)_oplst;
1993   op_list.reset();
1994   const char *op_name;
1995   while( (op_name = op_list.iter()) != NULL ) {
1996     const Form  *form    = globals[op_name];
1997     OperandForm *operand = form->is_operand();
1998     assert( operand, "Entry in operand class that is not an operand");
1999     if( first ) {
2000       first     = false;
2001       interface = operand->interface_type(globals);
2002     } else {
2003       interface = (interface == operand->interface_type(globals) ? interface : Form::no_interface);
2004     }
2005   }
2006   return interface;
2007 }
2008 
2009 bool OpClassForm::stack_slots_only(FormDict &globals) const {
2010   if( _oplst.count() == 0 ) return false;  // how?
2011 
2012   NameList &op_list = (NameList &)_oplst;
2013   op_list.reset();
2014   const char *op_name;
2015   while( (op_name = op_list.iter()) != NULL ) {
2016     const Form  *form    = globals[op_name];
2017     OperandForm *operand = form->is_operand();
2018     assert( operand, "Entry in operand class that is not an operand");
2019     if( !operand->stack_slots_only(globals) )  return false;
2020   }
2021   return true;
2022 }
2023 
2024 
2025 void OpClassForm::dump() {
2026   output(stderr);
2027 }
2028 
2029 void OpClassForm::output(FILE *fp) {
2030   const char *name;
2031   fprintf(fp,"\nOperand Class: %s\n", (_ident?_ident:""));
2032   fprintf(fp,"\nCount = %d\n", _oplst.count());
2033   for(_oplst.reset(); (name = _oplst.iter()) != NULL;) {
2034     fprintf(fp,"%s, ",name);
2035   }
2036   fprintf(fp,"\n");
2037 }
2038 
2039 
2040 //==============================Operands=======================================
2041 //------------------------------OperandForm------------------------------------
2042 OperandForm::OperandForm(const char* id)
2043   : OpClassForm(id), _ideal_only(false),
2044     _localNames(cmpstr, hashstr, Form::arena) {
2045       _ftype = Form::OPER;
2046 
2047       _matrule   = NULL;
2048       _interface = NULL;
2049       _attribs   = NULL;
2050       _predicate = NULL;
2051       _constraint= NULL;
2052       _construct = NULL;
2053       _format    = NULL;
2054 }
2055 OperandForm::OperandForm(const char* id, bool ideal_only)
2056   : OpClassForm(id), _ideal_only(ideal_only),
2057     _localNames(cmpstr, hashstr, Form::arena) {
2058       _ftype = Form::OPER;
2059 
2060       _matrule   = NULL;
2061       _interface = NULL;
2062       _attribs   = NULL;
2063       _predicate = NULL;
2064       _constraint= NULL;
2065       _construct = NULL;
2066       _format    = NULL;
2067 }
2068 OperandForm::~OperandForm() {
2069 }
2070 
2071 
2072 OperandForm *OperandForm::is_operand() const {
2073   return (OperandForm*)this;
2074 }
2075 
2076 bool OperandForm::ideal_only() const {
2077   return _ideal_only;
2078 }
2079 
2080 Form::InterfaceType OperandForm::interface_type(FormDict &globals) const {
2081   if( _interface == NULL )  return Form::no_interface;
2082 
2083   return _interface->interface_type(globals);
2084 }
2085 
2086 
2087 bool OperandForm::stack_slots_only(FormDict &globals) const {
2088   if( _constraint == NULL )  return false;
2089   return _constraint->stack_slots_only();
2090 }
2091 
2092 
2093 // Access op_cost attribute or return NULL.
2094 const char* OperandForm::cost() {
2095   for (Attribute* cur = _attribs; cur != NULL; cur = (Attribute*)cur->_next) {
2096     if( strcmp(cur->_ident,AttributeForm::_op_cost) == 0 ) {
2097       return cur->_val;
2098     }
2099   }
2100   return NULL;
2101 }
2102 
2103 // Return the number of leaves below this complex operand
2104 uint OperandForm::num_leaves() const {
2105   if ( ! _matrule) return 0;
2106 
2107   int num_leaves = _matrule->_numleaves;
2108   return num_leaves;
2109 }
2110 
2111 // Return the number of constants contained within this complex operand
2112 uint OperandForm::num_consts(FormDict &globals) const {
2113   if ( ! _matrule) return 0;
2114 
2115   // This is a recursive invocation on all operands in the matchrule
2116   return _matrule->num_consts(globals);
2117 }
2118 
2119 // Return the number of constants in match rule with specified type
2120 uint OperandForm::num_consts(FormDict &globals, Form::DataType type) const {
2121   if ( ! _matrule) return 0;
2122 
2123   // This is a recursive invocation on all operands in the matchrule
2124   return _matrule->num_consts(globals, type);
2125 }
2126 
2127 // Return the number of pointer constants contained within this complex operand
2128 uint OperandForm::num_const_ptrs(FormDict &globals) const {
2129   if ( ! _matrule) return 0;
2130 
2131   // This is a recursive invocation on all operands in the matchrule
2132   return _matrule->num_const_ptrs(globals);
2133 }
2134 
2135 uint OperandForm::num_edges(FormDict &globals) const {
2136   uint edges  = 0;
2137   uint leaves = num_leaves();
2138   uint consts = num_consts(globals);
2139 
2140   // If we are matching a constant directly, there are no leaves.
2141   edges = ( leaves > consts ) ? leaves - consts : 0;
2142 
2143   // !!!!!
2144   // Special case operands that do not have a corresponding ideal node.
2145   if( (edges == 0) && (consts == 0) ) {
2146     if( constrained_reg_class() != NULL ) {
2147       edges = 1;
2148     } else {
2149       if( _matrule
2150           && (_matrule->_lChild == NULL) && (_matrule->_rChild == NULL) ) {
2151         const Form *form = globals[_matrule->_opType];
2152         OperandForm *oper = form ? form->is_operand() : NULL;
2153         if( oper ) {
2154           return oper->num_edges(globals);
2155         }
2156       }
2157     }
2158   }
2159 
2160   return edges;
2161 }
2162 
2163 
2164 // Check if this operand is usable for cisc-spilling
2165 bool  OperandForm::is_cisc_reg(FormDict &globals) const {
2166   const char *ideal = ideal_type(globals);
2167   bool is_cisc_reg = (ideal && (ideal_to_Reg_type(ideal) != none));
2168   return is_cisc_reg;
2169 }
2170 
2171 bool  OpClassForm::is_cisc_mem(FormDict &globals) const {
2172   Form::InterfaceType my_interface = interface_type(globals);
2173   return (my_interface == memory_interface);
2174 }
2175 
2176 
2177 // node matches ideal 'Bool'
2178 bool OperandForm::is_ideal_bool() const {
2179   if( _matrule == NULL ) return false;
2180 
2181   return _matrule->is_ideal_bool();
2182 }
2183 
2184 // Require user's name for an sRegX to be stackSlotX
2185 Form::DataType OperandForm::is_user_name_for_sReg() const {
2186   DataType data_type = none;
2187   if( _ident != NULL ) {
2188     if(      strcmp(_ident,"stackSlotI") == 0 ) data_type = Form::idealI;
2189     else if( strcmp(_ident,"stackSlotP") == 0 ) data_type = Form::idealP;
2190     else if( strcmp(_ident,"stackSlotD") == 0 ) data_type = Form::idealD;
2191     else if( strcmp(_ident,"stackSlotF") == 0 ) data_type = Form::idealF;
2192     else if( strcmp(_ident,"stackSlotL") == 0 ) data_type = Form::idealL;
2193   }
2194   assert((data_type == none) || (_matrule == NULL), "No match-rule for stackSlotX");
2195 
2196   return data_type;
2197 }
2198 
2199 
2200 // Return ideal type, if there is a single ideal type for this operand
2201 const char *OperandForm::ideal_type(FormDict &globals, RegisterForm *registers) const {
2202   const char *type = NULL;
2203   if (ideal_only()) type = _ident;
2204   else if( _matrule == NULL ) {
2205     // Check for condition code register
2206     const char *rc_name = constrained_reg_class();
2207     // !!!!!
2208     if (rc_name == NULL) return NULL;
2209     // !!!!! !!!!!
2210     // Check constraints on result's register class
2211     if( registers ) {
2212       RegClass *reg_class  = registers->getRegClass(rc_name);
2213       assert( reg_class != NULL, "Register class is not defined");
2214 
2215       // Check for ideal type of entries in register class, all are the same type
2216       reg_class->reset();
2217       RegDef *reg_def = reg_class->RegDef_iter();
2218       assert( reg_def != NULL, "No entries in register class");
2219       assert( reg_def->_idealtype != NULL, "Did not define ideal type for register");
2220       // Return substring that names the register's ideal type
2221       type = reg_def->_idealtype + 3;
2222       assert( *(reg_def->_idealtype + 0) == 'O', "Expect Op_ prefix");
2223       assert( *(reg_def->_idealtype + 1) == 'p', "Expect Op_ prefix");
2224       assert( *(reg_def->_idealtype + 2) == '_', "Expect Op_ prefix");
2225     }
2226   }
2227   else if( _matrule->_lChild == NULL && _matrule->_rChild == NULL ) {
2228     // This operand matches a single type, at the top level.
2229     // Check for ideal type
2230     type = _matrule->_opType;
2231     if( strcmp(type,"Bool") == 0 )
2232       return "Bool";
2233     // transitive lookup
2234     const Form *frm = globals[type];
2235     OperandForm *op = frm->is_operand();
2236     type = op->ideal_type(globals, registers);
2237   }
2238   return type;
2239 }
2240 
2241 
2242 // If there is a single ideal type for this interface field, return it.
2243 const char *OperandForm::interface_ideal_type(FormDict &globals,
2244                                               const char *field) const {
2245   const char  *ideal_type = NULL;
2246   const char  *value      = NULL;
2247 
2248   // Check if "field" is valid for this operand's interface
2249   if ( ! is_interface_field(field, value) )   return ideal_type;
2250 
2251   // !!!!! !!!!! !!!!!
2252   // If a valid field has a constant value, identify "ConI" or "ConP" or ...
2253 
2254   // Else, lookup type of field's replacement variable
2255 
2256   return ideal_type;
2257 }
2258 
2259 
2260 RegClass* OperandForm::get_RegClass() const {
2261   if (_interface && !_interface->is_RegInterface()) return NULL;
2262   return globalAD->get_registers()->getRegClass(constrained_reg_class());
2263 }
2264 
2265 
2266 bool OperandForm::is_bound_register() const {
2267   RegClass* reg_class = get_RegClass();
2268   if (reg_class == NULL) {
2269     return false;
2270   }
2271 
2272   const char* name = ideal_type(globalAD->globalNames());
2273   if (name == NULL) {
2274     return false;
2275   }
2276 
2277   uint size = 0;
2278   if (strcmp(name, "RegFlags") == 0) size = 1;
2279   if (strcmp(name, "RegI") == 0) size = 1;
2280   if (strcmp(name, "RegF") == 0) size = 1;
2281   if (strcmp(name, "RegD") == 0) size = 2;
2282   if (strcmp(name, "RegL") == 0) size = 2;
2283   if (strcmp(name, "RegN") == 0) size = 1;
2284   if (strcmp(name, "VecX") == 0) size = 4;
2285   if (strcmp(name, "VecY") == 0) size = 8;
2286   if (strcmp(name, "VecZ") == 0) size = 16;
2287   if (strcmp(name, "RegP") == 0) size = globalAD->get_preproc_def("_LP64") ? 2 : 1;
2288   if (size == 0) {
2289     return false;
2290   }
2291   return size == reg_class->size();
2292 }
2293 
2294 
2295 // Check if this is a valid field for this operand,
2296 // Return 'true' if valid, and set the value to the string the user provided.
2297 bool  OperandForm::is_interface_field(const char *field,
2298                                       const char * &value) const {
2299   return false;
2300 }
2301 
2302 
2303 // Return register class name if a constraint specifies the register class.
2304 const char *OperandForm::constrained_reg_class() const {
2305   const char *reg_class  = NULL;
2306   if ( _constraint ) {
2307     // !!!!!
2308     Constraint *constraint = _constraint;
2309     if ( strcmp(_constraint->_func,"ALLOC_IN_RC") == 0 ) {
2310       reg_class = _constraint->_arg;
2311     }
2312   }
2313 
2314   return reg_class;
2315 }
2316 
2317 
2318 // Return the register class associated with 'leaf'.
2319 const char *OperandForm::in_reg_class(uint leaf, FormDict &globals) {
2320   const char *reg_class = NULL; // "RegMask::Empty";
2321 
2322   if((_matrule == NULL) || (_matrule->is_chain_rule(globals))) {
2323     reg_class = constrained_reg_class();
2324     return reg_class;
2325   }
2326   const char *result   = NULL;
2327   const char *name     = NULL;
2328   const char *type     = NULL;
2329   // iterate through all base operands
2330   // until we reach the register that corresponds to "leaf"
2331   // This function is not looking for an ideal type.  It needs the first
2332   // level user type associated with the leaf.
2333   for(uint idx = 0;_matrule->base_operand(idx,globals,result,name,type);++idx) {
2334     const Form *form = (_localNames[name] ? _localNames[name] : globals[result]);
2335     OperandForm *oper = form ? form->is_operand() : NULL;
2336     if( oper ) {
2337       reg_class = oper->constrained_reg_class();
2338       if( reg_class ) {
2339         reg_class = reg_class;
2340       } else {
2341         // ShouldNotReachHere();
2342       }
2343     } else {
2344       // ShouldNotReachHere();
2345     }
2346 
2347     // Increment our target leaf position if current leaf is not a candidate.
2348     if( reg_class == NULL)    ++leaf;
2349     // Exit the loop with the value of reg_class when at the correct index
2350     if( idx == leaf )         break;
2351     // May iterate through all base operands if reg_class for 'leaf' is NULL
2352   }
2353   return reg_class;
2354 }
2355 
2356 
2357 // Recursive call to construct list of top-level operands.
2358 // Implementation does not modify state of internal structures
2359 void OperandForm::build_components() {
2360   if (_matrule)  _matrule->append_components(_localNames, _components);
2361 
2362   // Add parameters that "do not appear in match rule".
2363   const char *name;
2364   for (_parameters.reset(); (name = _parameters.iter()) != NULL;) {
2365     OpClassForm *opForm = _localNames[name]->is_opclass();
2366     assert(opForm != NULL, "sanity");
2367 
2368     if ( _components.operand_position(name) == -1 ) {
2369       _components.insert(name, opForm->_ident, Component::INVALID, false);
2370     }
2371   }
2372 
2373   return;
2374 }
2375 
2376 int OperandForm::operand_position(const char *name, int usedef) {
2377   return _components.operand_position(name, usedef, this);
2378 }
2379 
2380 
2381 // Return zero-based position in component list, only counting constants;
2382 // Return -1 if not in list.
2383 int OperandForm::constant_position(FormDict &globals, const Component *last) {
2384   // Iterate through components and count constants preceding 'constant'
2385   int position = 0;
2386   Component *comp;
2387   _components.reset();
2388   while( (comp = _components.iter()) != NULL  && (comp != last) ) {
2389     // Special case for operands that take a single user-defined operand
2390     // Skip the initial definition in the component list.
2391     if( strcmp(comp->_name,this->_ident) == 0 ) continue;
2392 
2393     const char *type = comp->_type;
2394     // Lookup operand form for replacement variable's type
2395     const Form *form = globals[type];
2396     assert( form != NULL, "Component's type not found");
2397     OperandForm *oper = form ? form->is_operand() : NULL;
2398     if( oper ) {
2399       if( oper->_matrule->is_base_constant(globals) != Form::none ) {
2400         ++position;
2401       }
2402     }
2403   }
2404 
2405   // Check for being passed a component that was not in the list
2406   if( comp != last )  position = -1;
2407 
2408   return position;
2409 }
2410 // Provide position of constant by "name"
2411 int OperandForm::constant_position(FormDict &globals, const char *name) {
2412   const Component *comp = _components.search(name);
2413   int idx = constant_position( globals, comp );
2414 
2415   return idx;
2416 }
2417 
2418 
2419 // Return zero-based position in component list, only counting constants;
2420 // Return -1 if not in list.
2421 int OperandForm::register_position(FormDict &globals, const char *reg_name) {
2422   // Iterate through components and count registers preceding 'last'
2423   uint  position = 0;
2424   Component *comp;
2425   _components.reset();
2426   while( (comp = _components.iter()) != NULL
2427          && (strcmp(comp->_name,reg_name) != 0) ) {
2428     // Special case for operands that take a single user-defined operand
2429     // Skip the initial definition in the component list.
2430     if( strcmp(comp->_name,this->_ident) == 0 ) continue;
2431 
2432     const char *type = comp->_type;
2433     // Lookup operand form for component's type
2434     const Form *form = globals[type];
2435     assert( form != NULL, "Component's type not found");
2436     OperandForm *oper = form ? form->is_operand() : NULL;
2437     if( oper ) {
2438       if( oper->_matrule->is_base_register(globals) ) {
2439         ++position;
2440       }
2441     }
2442   }
2443 
2444   return position;
2445 }
2446 
2447 
2448 const char *OperandForm::reduce_result()  const {
2449   return _ident;
2450 }
2451 // Return the name of the operand on the right hand side of the binary match
2452 // Return NULL if there is no right hand side
2453 const char *OperandForm::reduce_right(FormDict &globals)  const {
2454   return  ( _matrule ? _matrule->reduce_right(globals) : NULL );
2455 }
2456 
2457 // Similar for left
2458 const char *OperandForm::reduce_left(FormDict &globals)   const {
2459   return  ( _matrule ? _matrule->reduce_left(globals) : NULL );
2460 }
2461 
2462 
2463 // --------------------------- FILE *output_routines
2464 //
2465 // Output code for disp_is_oop, if true.
2466 void OperandForm::disp_is_oop(FILE *fp, FormDict &globals) {
2467   //  Check it is a memory interface with a non-user-constant disp field
2468   if ( this->_interface == NULL ) return;
2469   MemInterface *mem_interface = this->_interface->is_MemInterface();
2470   if ( mem_interface == NULL )    return;
2471   const char   *disp  = mem_interface->_disp;
2472   if ( *disp != '$' )             return;
2473 
2474   // Lookup replacement variable in operand's component list
2475   const char   *rep_var = disp + 1;
2476   const Component *comp = this->_components.search(rep_var);
2477   assert( comp != NULL, "Replacement variable not found in components");
2478   // Lookup operand form for replacement variable's type
2479   const char      *type = comp->_type;
2480   Form            *form = (Form*)globals[type];
2481   assert( form != NULL, "Replacement variable's type not found");
2482   OperandForm     *op   = form->is_operand();
2483   assert( op, "Memory Interface 'disp' can only emit an operand form");
2484   // Check if this is a ConP, which may require relocation
2485   if ( op->is_base_constant(globals) == Form::idealP ) {
2486     // Find the constant's index:  _c0, _c1, _c2, ... , _cN
2487     uint idx  = op->constant_position( globals, rep_var);
2488     fprintf(fp,"  virtual relocInfo::relocType disp_reloc() const {");
2489     fprintf(fp,  "  return _c%d->reloc();", idx);
2490     fprintf(fp, " }\n");
2491   }
2492 }
2493 
2494 // Generate code for internal and external format methods
2495 //
2496 // internal access to reg# node->_idx
2497 // access to subsumed constant _c0, _c1,
2498 void  OperandForm::int_format(FILE *fp, FormDict &globals, uint index) {
2499   Form::DataType dtype;
2500   if (_matrule && (_matrule->is_base_register(globals) ||
2501                    strcmp(ideal_type(globalAD->globalNames()), "RegFlags") == 0)) {
2502     // !!!!! !!!!!
2503     fprintf(fp,"  { char reg_str[128];\n");
2504     fprintf(fp,"    ra->dump_register(node,reg_str);\n");
2505     fprintf(fp,"    st->print(\"%cs\",reg_str);\n",'%');
2506     fprintf(fp,"  }\n");
2507   } else if (_matrule && (dtype = _matrule->is_base_constant(globals)) != Form::none) {
2508     format_constant( fp, index, dtype );
2509   } else if (ideal_to_sReg_type(_ident) != Form::none) {
2510     // Special format for Stack Slot Register
2511     fprintf(fp,"  { char reg_str[128];\n");
2512     fprintf(fp,"    ra->dump_register(node,reg_str);\n");
2513     fprintf(fp,"    st->print(\"%cs\",reg_str);\n",'%');
2514     fprintf(fp,"  }\n");
2515   } else {
2516     fprintf(fp,"  st->print(\"No format defined for %s\n\");\n", _ident);
2517     fflush(fp);
2518     fprintf(stderr,"No format defined for %s\n", _ident);
2519     dump();
2520     assert( false,"Internal error:\n  output_internal_operand() attempting to output other than a Register or Constant");
2521   }
2522 }
2523 
2524 // Similar to "int_format" but for cases where data is external to operand
2525 // external access to reg# node->in(idx)->_idx,
2526 void  OperandForm::ext_format(FILE *fp, FormDict &globals, uint index) {
2527   Form::DataType dtype;
2528   if (_matrule && (_matrule->is_base_register(globals) ||
2529                    strcmp(ideal_type(globalAD->globalNames()), "RegFlags") == 0)) {
2530     fprintf(fp,"  { char reg_str[128];\n");
2531     fprintf(fp,"    ra->dump_register(node->in(idx");
2532     if ( index != 0 ) fprintf(fp,              "+%d",index);
2533     fprintf(fp,                                      "),reg_str);\n");
2534     fprintf(fp,"    st->print(\"%cs\",reg_str);\n",'%');
2535     fprintf(fp,"  }\n");
2536   } else if (_matrule && (dtype = _matrule->is_base_constant(globals)) != Form::none) {
2537     format_constant( fp, index, dtype );
2538   } else if (ideal_to_sReg_type(_ident) != Form::none) {
2539     // Special format for Stack Slot Register
2540     fprintf(fp,"  { char reg_str[128];\n");
2541     fprintf(fp,"    ra->dump_register(node->in(idx");
2542     if ( index != 0 ) fprintf(fp,                  "+%d",index);
2543     fprintf(fp,                                       "),reg_str);\n");
2544     fprintf(fp,"    st->print(\"%cs\",reg_str);\n",'%');
2545     fprintf(fp,"  }\n");
2546   } else {
2547     fprintf(fp,"  st->print(\"No format defined for %s\n\");\n", _ident);
2548     assert( false,"Internal error:\n  output_external_operand() attempting to output other than a Register or Constant");
2549   }
2550 }
2551 
2552 void OperandForm::format_constant(FILE *fp, uint const_index, uint const_type) {
2553   switch(const_type) {
2554   case Form::idealI: fprintf(fp,"  st->print(\"#%%d\", _c%d);\n", const_index); break;
2555   case Form::idealP: fprintf(fp,"  if (_c%d) _c%d->dump_on(st);\n", const_index, const_index); break;
2556   case Form::idealNKlass:
2557   case Form::idealN: fprintf(fp,"  if (_c%d) _c%d->dump_on(st);\n", const_index, const_index); break;
2558   case Form::idealL: fprintf(fp,"  st->print(\"#\" INT64_FORMAT, (int64_t)_c%d);\n", const_index); break;
2559   case Form::idealF: fprintf(fp,"  st->print(\"#%%f\", _c%d);\n", const_index); break;
2560   case Form::idealD: fprintf(fp,"  st->print(\"#%%f\", _c%d);\n", const_index); break;
2561   default:
2562     assert( false, "ShouldNotReachHere()");
2563   }
2564 }
2565 
2566 // Return the operand form corresponding to the given index, else NULL.
2567 OperandForm *OperandForm::constant_operand(FormDict &globals,
2568                                            uint      index) {
2569   // !!!!!
2570   // Check behavior on complex operands
2571   uint n_consts = num_consts(globals);
2572   if( n_consts > 0 ) {
2573     uint i = 0;
2574     const char *type;
2575     Component  *comp;
2576     _components.reset();
2577     if ((comp = _components.iter()) == NULL) {
2578       assert(n_consts == 1, "Bad component list detected.\n");
2579       // Current operand is THE operand
2580       if ( index == 0 ) {
2581         return this;
2582       }
2583     } // end if NULL
2584     else {
2585       // Skip the first component, it can not be a DEF of a constant
2586       do {
2587         type = comp->base_type(globals);
2588         // Check that "type" is a 'ConI', 'ConP', ...
2589         if ( ideal_to_const_type(type) != Form::none ) {
2590           // When at correct component, get corresponding Operand
2591           if ( index == 0 ) {
2592             return globals[comp->_type]->is_operand();
2593           }
2594           // Decrement number of constants to go
2595           --index;
2596         }
2597       } while((comp = _components.iter()) != NULL);
2598     }
2599   }
2600 
2601   // Did not find a constant for this index.
2602   return NULL;
2603 }
2604 
2605 // If this operand has a single ideal type, return its type
2606 Form::DataType OperandForm::simple_type(FormDict &globals) const {
2607   const char *type_name = ideal_type(globals);
2608   Form::DataType type   = type_name ? ideal_to_const_type( type_name )
2609                                     : Form::none;
2610   return type;
2611 }
2612 
2613 Form::DataType OperandForm::is_base_constant(FormDict &globals) const {
2614   if ( _matrule == NULL )    return Form::none;
2615 
2616   return _matrule->is_base_constant(globals);
2617 }
2618 
2619 // "true" if this operand is a simple type that is swallowed
2620 bool  OperandForm::swallowed(FormDict &globals) const {
2621   Form::DataType type   = simple_type(globals);
2622   if( type != Form::none ) {
2623     return true;
2624   }
2625 
2626   return false;
2627 }
2628 
2629 // Output code to access the value of the index'th constant
2630 void OperandForm::access_constant(FILE *fp, FormDict &globals,
2631                                   uint const_index) {
2632   OperandForm *oper = constant_operand(globals, const_index);
2633   assert( oper, "Index exceeds number of constants in operand");
2634   Form::DataType dtype = oper->is_base_constant(globals);
2635 
2636   switch(dtype) {
2637   case idealI: fprintf(fp,"_c%d",           const_index); break;
2638   case idealP: fprintf(fp,"_c%d->get_con()",const_index); break;
2639   case idealL: fprintf(fp,"_c%d",           const_index); break;
2640   case idealF: fprintf(fp,"_c%d",           const_index); break;
2641   case idealD: fprintf(fp,"_c%d",           const_index); break;
2642   default:
2643     assert( false, "ShouldNotReachHere()");
2644   }
2645 }
2646 
2647 
2648 void OperandForm::dump() {
2649   output(stderr);
2650 }
2651 
2652 void OperandForm::output(FILE *fp) {
2653   fprintf(fp,"\nOperand: %s\n", (_ident?_ident:""));
2654   if (_matrule)    _matrule->dump();
2655   if (_interface)  _interface->dump();
2656   if (_attribs)    _attribs->dump();
2657   if (_predicate)  _predicate->dump();
2658   if (_constraint) _constraint->dump();
2659   if (_construct)  _construct->dump();
2660   if (_format)     _format->dump();
2661 }
2662 
2663 //------------------------------Constraint-------------------------------------
2664 Constraint::Constraint(const char *func, const char *arg)
2665   : _func(func), _arg(arg) {
2666 }
2667 Constraint::~Constraint() { /* not owner of char* */
2668 }
2669 
2670 bool Constraint::stack_slots_only() const {
2671   return strcmp(_func, "ALLOC_IN_RC") == 0
2672       && strcmp(_arg,  "stack_slots") == 0;
2673 }
2674 
2675 void Constraint::dump() {
2676   output(stderr);
2677 }
2678 
2679 void Constraint::output(FILE *fp) {           // Write info to output files
2680   assert((_func != NULL && _arg != NULL),"missing constraint function or arg");
2681   fprintf(fp,"Constraint: %s ( %s )\n", _func, _arg);
2682 }
2683 
2684 //------------------------------Predicate--------------------------------------
2685 Predicate::Predicate(char *pr)
2686   : _pred(pr) {
2687 }
2688 Predicate::~Predicate() {
2689 }
2690 
2691 void Predicate::dump() {
2692   output(stderr);
2693 }
2694 
2695 void Predicate::output(FILE *fp) {
2696   fprintf(fp,"Predicate");  // Write to output files
2697 }
2698 //------------------------------Interface--------------------------------------
2699 Interface::Interface(const char *name) : _name(name) {
2700 }
2701 Interface::~Interface() {
2702 }
2703 
2704 Form::InterfaceType Interface::interface_type(FormDict &globals) const {
2705   Interface *thsi = (Interface*)this;
2706   if ( thsi->is_RegInterface()   ) return Form::register_interface;
2707   if ( thsi->is_MemInterface()   ) return Form::memory_interface;
2708   if ( thsi->is_ConstInterface() ) return Form::constant_interface;
2709   if ( thsi->is_CondInterface()  ) return Form::conditional_interface;
2710 
2711   return Form::no_interface;
2712 }
2713 
2714 RegInterface   *Interface::is_RegInterface() {
2715   if ( strcmp(_name,"REG_INTER") != 0 )
2716     return NULL;
2717   return (RegInterface*)this;
2718 }
2719 MemInterface   *Interface::is_MemInterface() {
2720   if ( strcmp(_name,"MEMORY_INTER") != 0 )  return NULL;
2721   return (MemInterface*)this;
2722 }
2723 ConstInterface *Interface::is_ConstInterface() {
2724   if ( strcmp(_name,"CONST_INTER") != 0 )  return NULL;
2725   return (ConstInterface*)this;
2726 }
2727 CondInterface  *Interface::is_CondInterface() {
2728   if ( strcmp(_name,"COND_INTER") != 0 )  return NULL;
2729   return (CondInterface*)this;
2730 }
2731 
2732 
2733 void Interface::dump() {
2734   output(stderr);
2735 }
2736 
2737 // Write info to output files
2738 void Interface::output(FILE *fp) {
2739   fprintf(fp,"Interface: %s\n", (_name ? _name : "") );
2740 }
2741 
2742 //------------------------------RegInterface-----------------------------------
2743 RegInterface::RegInterface() : Interface("REG_INTER") {
2744 }
2745 RegInterface::~RegInterface() {
2746 }
2747 
2748 void RegInterface::dump() {
2749   output(stderr);
2750 }
2751 
2752 // Write info to output files
2753 void RegInterface::output(FILE *fp) {
2754   Interface::output(fp);
2755 }
2756 
2757 //------------------------------ConstInterface---------------------------------
2758 ConstInterface::ConstInterface() : Interface("CONST_INTER") {
2759 }
2760 ConstInterface::~ConstInterface() {
2761 }
2762 
2763 void ConstInterface::dump() {
2764   output(stderr);
2765 }
2766 
2767 // Write info to output files
2768 void ConstInterface::output(FILE *fp) {
2769   Interface::output(fp);
2770 }
2771 
2772 //------------------------------MemInterface-----------------------------------
2773 MemInterface::MemInterface(char *base, char *index, char *scale, char *disp)
2774   : Interface("MEMORY_INTER"), _base(base), _index(index), _scale(scale), _disp(disp) {
2775 }
2776 MemInterface::~MemInterface() {
2777   // not owner of any character arrays
2778 }
2779 
2780 void MemInterface::dump() {
2781   output(stderr);
2782 }
2783 
2784 // Write info to output files
2785 void MemInterface::output(FILE *fp) {
2786   Interface::output(fp);
2787   if ( _base  != NULL ) fprintf(fp,"  base  == %s\n", _base);
2788   if ( _index != NULL ) fprintf(fp,"  index == %s\n", _index);
2789   if ( _scale != NULL ) fprintf(fp,"  scale == %s\n", _scale);
2790   if ( _disp  != NULL ) fprintf(fp,"  disp  == %s\n", _disp);
2791   // fprintf(fp,"\n");
2792 }
2793 
2794 //------------------------------CondInterface----------------------------------
2795 CondInterface::CondInterface(const char* equal,         const char* equal_format,
2796                              const char* not_equal,     const char* not_equal_format,
2797                              const char* less,          const char* less_format,
2798                              const char* greater_equal, const char* greater_equal_format,
2799                              const char* less_equal,    const char* less_equal_format,
2800                              const char* greater,       const char* greater_format,
2801                              const char* overflow,      const char* overflow_format,
2802                              const char* no_overflow,   const char* no_overflow_format)
2803   : Interface("COND_INTER"),
2804     _equal(equal),                 _equal_format(equal_format),
2805     _not_equal(not_equal),         _not_equal_format(not_equal_format),
2806     _less(less),                   _less_format(less_format),
2807     _greater_equal(greater_equal), _greater_equal_format(greater_equal_format),
2808     _less_equal(less_equal),       _less_equal_format(less_equal_format),
2809     _greater(greater),             _greater_format(greater_format),
2810     _overflow(overflow),           _overflow_format(overflow_format),
2811     _no_overflow(no_overflow),     _no_overflow_format(no_overflow_format) {
2812 }
2813 CondInterface::~CondInterface() {
2814   // not owner of any character arrays
2815 }
2816 
2817 void CondInterface::dump() {
2818   output(stderr);
2819 }
2820 
2821 // Write info to output files
2822 void CondInterface::output(FILE *fp) {
2823   Interface::output(fp);
2824   if ( _equal  != NULL )     fprintf(fp," equal        == %s\n", _equal);
2825   if ( _not_equal  != NULL ) fprintf(fp," not_equal    == %s\n", _not_equal);
2826   if ( _less  != NULL )      fprintf(fp," less         == %s\n", _less);
2827   if ( _greater_equal  != NULL ) fprintf(fp," greater_equal    == %s\n", _greater_equal);
2828   if ( _less_equal  != NULL ) fprintf(fp," less_equal   == %s\n", _less_equal);
2829   if ( _greater  != NULL )    fprintf(fp," greater      == %s\n", _greater);
2830   if ( _overflow != NULL )    fprintf(fp," overflow     == %s\n", _overflow);
2831   if ( _no_overflow != NULL ) fprintf(fp," no_overflow  == %s\n", _no_overflow);
2832   // fprintf(fp,"\n");
2833 }
2834 
2835 //------------------------------ConstructRule----------------------------------
2836 ConstructRule::ConstructRule(char *cnstr)
2837   : _construct(cnstr) {
2838 }
2839 ConstructRule::~ConstructRule() {
2840 }
2841 
2842 void ConstructRule::dump() {
2843   output(stderr);
2844 }
2845 
2846 void ConstructRule::output(FILE *fp) {
2847   fprintf(fp,"\nConstruct Rule\n");  // Write to output files
2848 }
2849 
2850 
2851 //==============================Shared Forms===================================
2852 //------------------------------AttributeForm----------------------------------
2853 int         AttributeForm::_insId   = 0;           // start counter at 0
2854 int         AttributeForm::_opId    = 0;           // start counter at 0
2855 const char* AttributeForm::_ins_cost = "ins_cost"; // required name
2856 const char* AttributeForm::_op_cost  = "op_cost";  // required name
2857 
2858 AttributeForm::AttributeForm(char *attr, int type, char *attrdef)
2859   : Form(Form::ATTR), _attrname(attr), _atype(type), _attrdef(attrdef) {
2860     if (type==OP_ATTR) {
2861       id = ++_opId;
2862     }
2863     else if (type==INS_ATTR) {
2864       id = ++_insId;
2865     }
2866     else assert( false,"");
2867 }
2868 AttributeForm::~AttributeForm() {
2869 }
2870 
2871 // Dynamic type check
2872 AttributeForm *AttributeForm::is_attribute() const {
2873   return (AttributeForm*)this;
2874 }
2875 
2876 
2877 // inlined  // int  AttributeForm::type() { return id;}
2878 
2879 void AttributeForm::dump() {
2880   output(stderr);
2881 }
2882 
2883 void AttributeForm::output(FILE *fp) {
2884   if( _attrname && _attrdef ) {
2885     fprintf(fp,"\n// AttributeForm \nstatic const int %s = %s;\n",
2886             _attrname, _attrdef);
2887   }
2888   else {
2889     fprintf(fp,"\n// AttributeForm missing name %s or definition %s\n",
2890             (_attrname?_attrname:""), (_attrdef?_attrdef:"") );
2891   }
2892 }
2893 
2894 //------------------------------Component--------------------------------------
2895 Component::Component(const char *name, const char *type, int usedef)
2896   : _name(name), _type(type), _usedef(usedef) {
2897     _ftype = Form::COMP;
2898 }
2899 Component::~Component() {
2900 }
2901 
2902 // True if this component is equal to the parameter.
2903 bool Component::is(int use_def_kill_enum) const {
2904   return (_usedef == use_def_kill_enum ? true : false);
2905 }
2906 // True if this component is used/def'd/kill'd as the parameter suggests.
2907 bool Component::isa(int use_def_kill_enum) const {
2908   return (_usedef & use_def_kill_enum) == use_def_kill_enum;
2909 }
2910 
2911 // Extend this component with additional use/def/kill behavior
2912 int Component::promote_use_def_info(int new_use_def) {
2913   _usedef |= new_use_def;
2914 
2915   return _usedef;
2916 }
2917 
2918 // Check the base type of this component, if it has one
2919 const char *Component::base_type(FormDict &globals) {
2920   const Form *frm = globals[_type];
2921   if (frm == NULL) return NULL;
2922   OperandForm *op = frm->is_operand();
2923   if (op == NULL) return NULL;
2924   if (op->ideal_only()) return op->_ident;
2925   return (char *)op->ideal_type(globals);
2926 }
2927 
2928 void Component::dump() {
2929   output(stderr);
2930 }
2931 
2932 void Component::output(FILE *fp) {
2933   fprintf(fp,"Component:");  // Write to output files
2934   fprintf(fp, "  name = %s", _name);
2935   fprintf(fp, ", type = %s", _type);
2936   assert(_usedef != 0, "unknown effect");
2937   fprintf(fp, ", use/def = %s\n", getUsedefName());
2938 }
2939 
2940 
2941 //------------------------------ComponentList---------------------------------
2942 ComponentList::ComponentList() : NameList(), _matchcnt(0) {
2943 }
2944 ComponentList::~ComponentList() {
2945   // // This list may not own its elements if copied via assignment
2946   // Component *component;
2947   // for (reset(); (component = iter()) != NULL;) {
2948   //   delete component;
2949   // }
2950 }
2951 
2952 void   ComponentList::insert(Component *component, bool mflag) {
2953   NameList::addName((char *)component);
2954   if(mflag) _matchcnt++;
2955 }
2956 void   ComponentList::insert(const char *name, const char *opType, int usedef,
2957                              bool mflag) {
2958   Component * component = new Component(name, opType, usedef);
2959   insert(component, mflag);
2960 }
2961 Component *ComponentList::current() { return (Component*)NameList::current(); }
2962 Component *ComponentList::iter()    { return (Component*)NameList::iter(); }
2963 Component *ComponentList::match_iter() {
2964   if(_iter < _matchcnt) return (Component*)NameList::iter();
2965   return NULL;
2966 }
2967 Component *ComponentList::post_match_iter() {
2968   Component *comp = iter();
2969   // At end of list?
2970   if ( comp == NULL ) {
2971     return comp;
2972   }
2973   // In post-match components?
2974   if (_iter > match_count()-1) {
2975     return comp;
2976   }
2977 
2978   return post_match_iter();
2979 }
2980 
2981 void       ComponentList::reset()   { NameList::reset(); }
2982 int        ComponentList::count()   { return NameList::count(); }
2983 
2984 Component *ComponentList::operator[](int position) {
2985   // Shortcut complete iteration if there are not enough entries
2986   if (position >= count()) return NULL;
2987 
2988   int        index     = 0;
2989   Component *component = NULL;
2990   for (reset(); (component = iter()) != NULL;) {
2991     if (index == position) {
2992       return component;
2993     }
2994     ++index;
2995   }
2996 
2997   return NULL;
2998 }
2999 
3000 const Component *ComponentList::search(const char *name) {
3001   PreserveIter pi(this);
3002   reset();
3003   for( Component *comp = NULL; ((comp = iter()) != NULL); ) {
3004     if( strcmp(comp->_name,name) == 0 ) return comp;
3005   }
3006 
3007   return NULL;
3008 }
3009 
3010 // Return number of USEs + number of DEFs
3011 // When there are no components, or the first component is a USE,
3012 // then we add '1' to hold a space for the 'result' operand.
3013 int ComponentList::num_operands() {
3014   PreserveIter pi(this);
3015   uint       count = 1;           // result operand
3016   uint       position = 0;
3017 
3018   Component *component  = NULL;
3019   for( reset(); (component = iter()) != NULL; ++position ) {
3020     if( component->isa(Component::USE) ||
3021         ( position == 0 && (! component->isa(Component::DEF))) ) {
3022       ++count;
3023     }
3024   }
3025 
3026   return count;
3027 }
3028 
3029 // Return zero-based position of operand 'name' in list;  -1 if not in list.
3030 // if parameter 'usedef' is ::USE, it will match USE, USE_DEF, ...
3031 int ComponentList::operand_position(const char *name, int usedef, Form *fm) {
3032   PreserveIter pi(this);
3033   int position = 0;
3034   int num_opnds = num_operands();
3035   Component *component;
3036   Component* preceding_non_use = NULL;
3037   Component* first_def = NULL;
3038   for (reset(); (component = iter()) != NULL; ++position) {
3039     // When the first component is not a DEF,
3040     // leave space for the result operand!
3041     if ( position==0 && (! component->isa(Component::DEF)) ) {
3042       ++position;
3043       ++num_opnds;
3044     }
3045     if (strcmp(name, component->_name)==0 && (component->isa(usedef))) {
3046       // When the first entry in the component list is a DEF and a USE
3047       // Treat them as being separate, a DEF first, then a USE
3048       if( position==0
3049           && usedef==Component::USE && component->isa(Component::DEF) ) {
3050         assert(position+1 < num_opnds, "advertised index in bounds");
3051         return position+1;
3052       } else {
3053         if( preceding_non_use && strcmp(component->_name, preceding_non_use->_name) ) {
3054           fprintf(stderr, "the name '%s(%s)' should not precede the name '%s(%s)'",
3055                   preceding_non_use->_name, preceding_non_use->getUsedefName(),
3056                   name, component->getUsedefName());
3057           if (fm && fm->is_instruction()) fprintf(stderr,  "in form '%s'", fm->is_instruction()->_ident);
3058           if (fm && fm->is_operand()) fprintf(stderr,  "in form '%s'", fm->is_operand()->_ident);
3059           fprintf(stderr,  "\n");
3060         }
3061         if( position >= num_opnds ) {
3062           fprintf(stderr, "the name '%s' is too late in its name list", name);
3063           if (fm && fm->is_instruction()) fprintf(stderr,  "in form '%s'", fm->is_instruction()->_ident);
3064           if (fm && fm->is_operand()) fprintf(stderr,  "in form '%s'", fm->is_operand()->_ident);
3065           fprintf(stderr,  "\n");
3066         }
3067         assert(position < num_opnds, "advertised index in bounds");
3068         return position;
3069       }
3070     }
3071     if( component->isa(Component::DEF)
3072         && component->isa(Component::USE) ) {
3073       ++position;
3074       if( position != 1 )  --position;   // only use two slots for the 1st USE_DEF
3075     }
3076     if( component->isa(Component::DEF) && !first_def ) {
3077       first_def = component;
3078     }
3079     if( !component->isa(Component::USE) && component != first_def ) {
3080       preceding_non_use = component;
3081     } else if( preceding_non_use && !strcmp(component->_name, preceding_non_use->_name) ) {
3082       preceding_non_use = NULL;
3083     }
3084   }
3085   return Not_in_list;
3086 }
3087 
3088 // Find position for this name, regardless of use/def information
3089 int ComponentList::operand_position(const char *name) {
3090   PreserveIter pi(this);
3091   int position = 0;
3092   Component *component;
3093   for (reset(); (component = iter()) != NULL; ++position) {
3094     // When the first component is not a DEF,
3095     // leave space for the result operand!
3096     if ( position==0 && (! component->isa(Component::DEF)) ) {
3097       ++position;
3098     }
3099     if (strcmp(name, component->_name)==0) {
3100       return position;
3101     }
3102     if( component->isa(Component::DEF)
3103         && component->isa(Component::USE) ) {
3104       ++position;
3105       if( position != 1 )  --position;   // only use two slots for the 1st USE_DEF
3106     }
3107   }
3108   return Not_in_list;
3109 }
3110 
3111 int ComponentList::operand_position_format(const char *name, Form *fm) {
3112   PreserveIter pi(this);
3113   int  first_position = operand_position(name);
3114   int  use_position   = operand_position(name, Component::USE, fm);
3115 
3116   return ((first_position < use_position) ? use_position : first_position);
3117 }
3118 
3119 int ComponentList::label_position() {
3120   PreserveIter pi(this);
3121   int position = 0;
3122   reset();
3123   for( Component *comp; (comp = iter()) != NULL; ++position) {
3124     // When the first component is not a DEF,
3125     // leave space for the result operand!
3126     if ( position==0 && (! comp->isa(Component::DEF)) ) {
3127       ++position;
3128     }
3129     if (strcmp(comp->_type, "label")==0) {
3130       return position;
3131     }
3132     if( comp->isa(Component::DEF)
3133         && comp->isa(Component::USE) ) {
3134       ++position;
3135       if( position != 1 )  --position;   // only use two slots for the 1st USE_DEF
3136     }
3137   }
3138 
3139   return -1;
3140 }
3141 
3142 int ComponentList::method_position() {
3143   PreserveIter pi(this);
3144   int position = 0;
3145   reset();
3146   for( Component *comp; (comp = iter()) != NULL; ++position) {
3147     // When the first component is not a DEF,
3148     // leave space for the result operand!
3149     if ( position==0 && (! comp->isa(Component::DEF)) ) {
3150       ++position;
3151     }
3152     if (strcmp(comp->_type, "method")==0) {
3153       return position;
3154     }
3155     if( comp->isa(Component::DEF)
3156         && comp->isa(Component::USE) ) {
3157       ++position;
3158       if( position != 1 )  --position;   // only use two slots for the 1st USE_DEF
3159     }
3160   }
3161 
3162   return -1;
3163 }
3164 
3165 void ComponentList::dump() { output(stderr); }
3166 
3167 void ComponentList::output(FILE *fp) {
3168   PreserveIter pi(this);
3169   fprintf(fp, "\n");
3170   Component *component;
3171   for (reset(); (component = iter()) != NULL;) {
3172     component->output(fp);
3173   }
3174   fprintf(fp, "\n");
3175 }
3176 
3177 //------------------------------MatchNode--------------------------------------
3178 MatchNode::MatchNode(ArchDesc &ad, const char *result, const char *mexpr,
3179                      const char *opType, MatchNode *lChild, MatchNode *rChild)
3180   : _AD(ad), _result(result), _name(mexpr), _opType(opType),
3181     _lChild(lChild), _rChild(rChild), _internalop(0), _numleaves(0),
3182     _commutative_id(0) {
3183   _numleaves = (lChild ? lChild->_numleaves : 0)
3184                + (rChild ? rChild->_numleaves : 0);
3185 }
3186 
3187 MatchNode::MatchNode(ArchDesc &ad, MatchNode& mnode)
3188   : _AD(ad), _result(mnode._result), _name(mnode._name),
3189     _opType(mnode._opType), _lChild(mnode._lChild), _rChild(mnode._rChild),
3190     _internalop(0), _numleaves(mnode._numleaves),
3191     _commutative_id(mnode._commutative_id) {
3192 }
3193 
3194 MatchNode::MatchNode(ArchDesc &ad, MatchNode& mnode, int clone)
3195   : _AD(ad), _result(mnode._result), _name(mnode._name),
3196     _opType(mnode._opType),
3197     _internalop(0), _numleaves(mnode._numleaves),
3198     _commutative_id(mnode._commutative_id) {
3199   if (mnode._lChild) {
3200     _lChild = new MatchNode(ad, *mnode._lChild, clone);
3201   } else {
3202     _lChild = NULL;
3203   }
3204   if (mnode._rChild) {
3205     _rChild = new MatchNode(ad, *mnode._rChild, clone);
3206   } else {
3207     _rChild = NULL;
3208   }
3209 }
3210 
3211 MatchNode::~MatchNode() {
3212   // // This node may not own its children if copied via assignment
3213   // if( _lChild ) delete _lChild;
3214   // if( _rChild ) delete _rChild;
3215 }
3216 
3217 bool  MatchNode::find_type(const char *type, int &position) const {
3218   if ( (_lChild != NULL) && (_lChild->find_type(type, position)) ) return true;
3219   if ( (_rChild != NULL) && (_rChild->find_type(type, position)) ) return true;
3220 
3221   if (strcmp(type,_opType)==0)  {
3222     return true;
3223   } else {
3224     ++position;
3225   }
3226   return false;
3227 }
3228 
3229 // Recursive call collecting info on top-level operands, not transitive.
3230 // Implementation does not modify state of internal structures.
3231 void MatchNode::append_components(FormDict& locals, ComponentList& components,
3232                                   bool def_flag) const {
3233   int usedef = def_flag ? Component::DEF : Component::USE;
3234   FormDict &globals = _AD.globalNames();
3235 
3236   assert (_name != NULL, "MatchNode::build_components encountered empty node\n");
3237   // Base case
3238   if (_lChild==NULL && _rChild==NULL) {
3239     // If _opType is not an operation, do not build a component for it #####
3240     const Form *f = globals[_opType];
3241     if( f != NULL ) {
3242       // Add non-ideals that are operands, operand-classes,
3243       if( ! f->ideal_only()
3244           && (f->is_opclass() || f->is_operand()) ) {
3245         components.insert(_name, _opType, usedef, true);
3246       }
3247     }
3248     return;
3249   }
3250   // Promote results of "Set" to DEF
3251   bool tmpdef_flag = (!strcmp(_opType, "Set")) ? true : false;
3252   if (_lChild) _lChild->append_components(locals, components, tmpdef_flag);
3253   tmpdef_flag = false;   // only applies to component immediately following 'Set'
3254   if (_rChild) _rChild->append_components(locals, components, tmpdef_flag);
3255 }
3256 
3257 // Find the n'th base-operand in the match node,
3258 // recursively investigates match rules of user-defined operands.
3259 //
3260 // Implementation does not modify state of internal structures since they
3261 // can be shared.
3262 bool MatchNode::base_operand(uint &position, FormDict &globals,
3263                              const char * &result, const char * &name,
3264                              const char * &opType) const {
3265   assert (_name != NULL, "MatchNode::base_operand encountered empty node\n");
3266   // Base case
3267   if (_lChild==NULL && _rChild==NULL) {
3268     // Check for special case: "Universe", "label"
3269     if (strcmp(_opType,"Universe") == 0 || strcmp(_opType,"label")==0 ) {
3270       if (position == 0) {
3271         result = _result;
3272         name   = _name;
3273         opType = _opType;
3274         return 1;
3275       } else {
3276         -- position;
3277         return 0;
3278       }
3279     }
3280 
3281     const Form *form = globals[_opType];
3282     MatchNode *matchNode = NULL;
3283     // Check for user-defined type
3284     if (form) {
3285       // User operand or instruction?
3286       OperandForm  *opForm = form->is_operand();
3287       InstructForm *inForm = form->is_instruction();
3288       if ( opForm ) {
3289         matchNode = (MatchNode*)opForm->_matrule;
3290       } else if ( inForm ) {
3291         matchNode = (MatchNode*)inForm->_matrule;
3292       }
3293     }
3294     // if this is user-defined, recurse on match rule
3295     // User-defined operand and instruction forms have a match-rule.
3296     if (matchNode) {
3297       return (matchNode->base_operand(position,globals,result,name,opType));
3298     } else {
3299       // Either not a form, or a system-defined form (no match rule).
3300       if (position==0) {
3301         result = _result;
3302         name   = _name;
3303         opType = _opType;
3304         return 1;
3305       } else {
3306         --position;
3307         return 0;
3308       }
3309     }
3310 
3311   } else {
3312     // Examine the left child and right child as well
3313     if (_lChild) {
3314       if (_lChild->base_operand(position, globals, result, name, opType))
3315         return 1;
3316     }
3317 
3318     if (_rChild) {
3319       if (_rChild->base_operand(position, globals, result, name, opType))
3320         return 1;
3321     }
3322   }
3323 
3324   return 0;
3325 }
3326 
3327 // Recursive call on all operands' match rules in my match rule.
3328 uint  MatchNode::num_consts(FormDict &globals) const {
3329   uint        index      = 0;
3330   uint        num_consts = 0;
3331   const char *result;
3332   const char *name;
3333   const char *opType;
3334 
3335   for (uint position = index;
3336        base_operand(position,globals,result,name,opType); position = index) {
3337     ++index;
3338     if( ideal_to_const_type(opType) )        num_consts++;
3339   }
3340 
3341   return num_consts;
3342 }
3343 
3344 // Recursive call on all operands' match rules in my match rule.
3345 // Constants in match rule subtree with specified type
3346 uint  MatchNode::num_consts(FormDict &globals, Form::DataType type) const {
3347   uint        index      = 0;
3348   uint        num_consts = 0;
3349   const char *result;
3350   const char *name;
3351   const char *opType;
3352 
3353   for (uint position = index;
3354        base_operand(position,globals,result,name,opType); position = index) {
3355     ++index;
3356     if( ideal_to_const_type(opType) == type ) num_consts++;
3357   }
3358 
3359   return num_consts;
3360 }
3361 
3362 // Recursive call on all operands' match rules in my match rule.
3363 uint  MatchNode::num_const_ptrs(FormDict &globals) const {
3364   return  num_consts( globals, Form::idealP );
3365 }
3366 
3367 bool  MatchNode::sets_result() const {
3368   return   ( (strcmp(_name,"Set") == 0) ? true : false );
3369 }
3370 
3371 const char *MatchNode::reduce_right(FormDict &globals) const {
3372   // If there is no right reduction, return NULL.
3373   const char      *rightStr    = NULL;
3374 
3375   // If we are a "Set", start from the right child.
3376   const MatchNode *const mnode = sets_result() ?
3377     (const MatchNode *)this->_rChild :
3378     (const MatchNode *)this;
3379 
3380   // If our right child exists, it is the right reduction
3381   if ( mnode->_rChild ) {
3382     rightStr = mnode->_rChild->_internalop ? mnode->_rChild->_internalop
3383       : mnode->_rChild->_opType;
3384   }
3385   // Else, May be simple chain rule: (Set dst operand_form), rightStr=NULL;
3386   return rightStr;
3387 }
3388 
3389 const char *MatchNode::reduce_left(FormDict &globals) const {
3390   // If there is no left reduction, return NULL.
3391   const char  *leftStr  = NULL;
3392 
3393   // If we are a "Set", start from the right child.
3394   const MatchNode *const mnode = sets_result() ?
3395     (const MatchNode *)this->_rChild :
3396     (const MatchNode *)this;
3397 
3398   // If our left child exists, it is the left reduction
3399   if ( mnode->_lChild ) {
3400     leftStr = mnode->_lChild->_internalop ? mnode->_lChild->_internalop
3401       : mnode->_lChild->_opType;
3402   } else {
3403     // May be simple chain rule: (Set dst operand_form_source)
3404     if ( sets_result() ) {
3405       OperandForm *oper = globals[mnode->_opType]->is_operand();
3406       if( oper ) {
3407         leftStr = mnode->_opType;
3408       }
3409     }
3410   }
3411   return leftStr;
3412 }
3413 
3414 //------------------------------count_instr_names------------------------------
3415 // Count occurrences of operands names in the leaves of the instruction
3416 // match rule.
3417 void MatchNode::count_instr_names( Dict &names ) {
3418   if( _lChild ) _lChild->count_instr_names(names);
3419   if( _rChild ) _rChild->count_instr_names(names);
3420   if( !_lChild && !_rChild ) {
3421     uintptr_t cnt = (uintptr_t)names[_name];
3422     cnt++;                      // One more name found
3423     names.Insert(_name,(void*)cnt);
3424   }
3425 }
3426 
3427 //------------------------------build_instr_pred-------------------------------
3428 // Build a path to 'name' in buf.  Actually only build if cnt is zero, so we
3429 // can skip some leading instances of 'name'.
3430 int MatchNode::build_instr_pred( char *buf, const char *name, int cnt, int path_bitmask, int level) {
3431   if( _lChild ) {
3432     cnt = _lChild->build_instr_pred(buf, name, cnt, path_bitmask, level+1);
3433     if( cnt < 0 ) {
3434       return cnt;   // Found it, all done
3435     }
3436   }
3437   if( _rChild ) {
3438     path_bitmask |= 1 << level;
3439     cnt = _rChild->build_instr_pred( buf, name, cnt, path_bitmask, level+1);
3440     if( cnt < 0 ) {
3441       return cnt;   // Found it, all done
3442     }
3443   }
3444   if( !_lChild && !_rChild ) {  // Found a leaf
3445     // Wrong name?  Give up...
3446     if( strcmp(name,_name) ) return cnt;
3447     if( !cnt )  {
3448       for(int i = 0; i < level; i++) {
3449         int kid = path_bitmask &  (1 << i);
3450         if (0 == kid) {
3451           strcpy( buf, "_kids[0]->" );
3452         } else {
3453           strcpy( buf, "_kids[1]->" );
3454         }
3455         buf += 10;
3456       }
3457       strcpy( buf, "_leaf" );
3458     }
3459     return cnt-1;
3460   }
3461   return cnt;
3462 }
3463 
3464 
3465 //------------------------------build_internalop-------------------------------
3466 // Build string representation of subtree
3467 void MatchNode::build_internalop( ) {
3468   char *iop, *subtree;
3469   const char *lstr, *rstr;
3470   // Build string representation of subtree
3471   // Operation lchildType rchildType
3472   int len = (int)strlen(_opType) + 4;
3473   lstr = (_lChild) ? ((_lChild->_internalop) ?
3474                        _lChild->_internalop : _lChild->_opType) : "";
3475   rstr = (_rChild) ? ((_rChild->_internalop) ?
3476                        _rChild->_internalop : _rChild->_opType) : "";
3477   len += (int)strlen(lstr) + (int)strlen(rstr);
3478   subtree = (char *)AllocateHeap(len);
3479   sprintf(subtree,"_%s_%s_%s", _opType, lstr, rstr);
3480   // Hash the subtree string in _internalOps; if a name exists, use it
3481   iop = (char *)_AD._internalOps[subtree];
3482   // Else create a unique name, and add it to the hash table
3483   if (iop == NULL) {
3484     iop = subtree;
3485     _AD._internalOps.Insert(subtree, iop);
3486     _AD._internalOpNames.addName(iop);
3487     _AD._internalMatch.Insert(iop, this);
3488   }
3489   // Add the internal operand name to the MatchNode
3490   _internalop = iop;
3491   _result = iop;
3492 }
3493 
3494 
3495 void MatchNode::dump() {
3496   output(stderr);
3497 }
3498 
3499 void MatchNode::output(FILE *fp) {
3500   if (_lChild==0 && _rChild==0) {
3501     fprintf(fp," %s",_name);    // operand
3502   }
3503   else {
3504     fprintf(fp," (%s ",_name);  // " (opcodeName "
3505     if(_lChild) _lChild->output(fp); //               left operand
3506     if(_rChild) _rChild->output(fp); //                    right operand
3507     fprintf(fp,")");                 //                                 ")"
3508   }
3509 }
3510 
3511 int MatchNode::needs_ideal_memory_edge(FormDict &globals) const {
3512   static const char *needs_ideal_memory_list[] = {
3513     "StoreI","StoreL","StoreP","StoreN","StoreNKlass","StoreD","StoreF" ,
3514     "StoreB","StoreC","Store" ,"StoreFP",
3515     "LoadI", "LoadL", "LoadP" ,"LoadN", "LoadD" ,"LoadF"  ,
3516     "LoadB" , "LoadUB", "LoadUS" ,"LoadS" ,"Load" ,
3517     "StoreVector", "LoadVector", "LoadVectorGather", "StoreVectorScatter", "LoadVectorMasked", "StoreVectorMasked",
3518     "LoadRange", "LoadKlass", "LoadNKlass", "LoadL_unaligned", "LoadD_unaligned",
3519     "LoadPLocked",
3520     "StorePConditional", "StoreIConditional", "StoreLConditional",
3521     "CompareAndSwapB", "CompareAndSwapS", "CompareAndSwapI", "CompareAndSwapL", "CompareAndSwapP", "CompareAndSwapN",
3522     "WeakCompareAndSwapB", "WeakCompareAndSwapS", "WeakCompareAndSwapI", "WeakCompareAndSwapL", "WeakCompareAndSwapP", "WeakCompareAndSwapN",
3523     "CompareAndExchangeB", "CompareAndExchangeS", "CompareAndExchangeI", "CompareAndExchangeL", "CompareAndExchangeP", "CompareAndExchangeN",
3524 #if INCLUDE_SHENANDOAHGC
3525     "ShenandoahCompareAndSwapN", "ShenandoahCompareAndSwapP", "ShenandoahWeakCompareAndSwapP", "ShenandoahWeakCompareAndSwapN", "ShenandoahCompareAndExchangeP", "ShenandoahCompareAndExchangeN",
3526 #endif
3527     "StoreCM",
3528     "GetAndSetB", "GetAndSetS", "GetAndAddI", "GetAndSetI", "GetAndSetP",
3529     "GetAndAddB", "GetAndAddS", "GetAndAddL", "GetAndSetL", "GetAndSetN",
3530     "ClearArray"
3531   };
3532   int cnt = sizeof(needs_ideal_memory_list)/sizeof(char*);
3533   if( strcmp(_opType,"PrefetchAllocation")==0 )
3534     return 1;
3535   if( strcmp(_opType,"CacheWB")==0 )
3536     return 1;
3537   if( strcmp(_opType,"CacheWBPreSync")==0 )
3538     return 1;
3539   if( strcmp(_opType,"CacheWBPostSync")==0 )
3540     return 1;
3541   if( _lChild ) {
3542     const char *opType = _lChild->_opType;
3543     for( int i=0; i<cnt; i++ )
3544       if( strcmp(opType,needs_ideal_memory_list[i]) == 0 )
3545         return 1;
3546     if( _lChild->needs_ideal_memory_edge(globals) )
3547       return 1;
3548   }
3549   if( _rChild ) {
3550     const char *opType = _rChild->_opType;
3551     for( int i=0; i<cnt; i++ )
3552       if( strcmp(opType,needs_ideal_memory_list[i]) == 0 )
3553         return 1;
3554     if( _rChild->needs_ideal_memory_edge(globals) )
3555       return 1;
3556   }
3557 
3558   return 0;
3559 }
3560 
3561 // TRUE if defines a derived oop, and so needs a base oop edge present
3562 // post-matching.
3563 int MatchNode::needs_base_oop_edge() const {
3564   if( !strcmp(_opType,"AddP") ) return 1;
3565   if( strcmp(_opType,"Set") ) return 0;
3566   return !strcmp(_rChild->_opType,"AddP");
3567 }
3568 
3569 int InstructForm::needs_base_oop_edge(FormDict &globals) const {
3570   if( is_simple_chain_rule(globals) ) {
3571     const char *src = _matrule->_rChild->_opType;
3572     OperandForm *src_op = globals[src]->is_operand();
3573     assert( src_op, "Not operand class of chain rule" );
3574     return src_op->_matrule ? src_op->_matrule->needs_base_oop_edge() : 0;
3575   }                             // Else check instruction
3576 
3577   return _matrule ? _matrule->needs_base_oop_edge() : 0;
3578 }
3579 
3580 
3581 //-------------------------cisc spilling methods-------------------------------
3582 // helper routines and methods for detecting cisc-spilling instructions
3583 //-------------------------cisc_spill_merge------------------------------------
3584 int MatchNode::cisc_spill_merge(int left_spillable, int right_spillable) {
3585   int cisc_spillable  = Maybe_cisc_spillable;
3586 
3587   // Combine results of left and right checks
3588   if( (left_spillable == Maybe_cisc_spillable) && (right_spillable == Maybe_cisc_spillable) ) {
3589     // neither side is spillable, nor prevents cisc spilling
3590     cisc_spillable = Maybe_cisc_spillable;
3591   }
3592   else if( (left_spillable == Maybe_cisc_spillable) && (right_spillable > Maybe_cisc_spillable) ) {
3593     // right side is spillable
3594     cisc_spillable = right_spillable;
3595   }
3596   else if( (right_spillable == Maybe_cisc_spillable) && (left_spillable > Maybe_cisc_spillable) ) {
3597     // left side is spillable
3598     cisc_spillable = left_spillable;
3599   }
3600   else if( (left_spillable == Not_cisc_spillable) || (right_spillable == Not_cisc_spillable) ) {
3601     // left or right prevents cisc spilling this instruction
3602     cisc_spillable = Not_cisc_spillable;
3603   }
3604   else {
3605     // Only allow one to spill
3606     cisc_spillable = Not_cisc_spillable;
3607   }
3608 
3609   return cisc_spillable;
3610 }
3611 
3612 //-------------------------root_ops_match--------------------------------------
3613 bool static root_ops_match(FormDict &globals, const char *op1, const char *op2) {
3614   // Base Case: check that the current operands/operations match
3615   assert( op1, "Must have op's name");
3616   assert( op2, "Must have op's name");
3617   const Form *form1 = globals[op1];
3618   const Form *form2 = globals[op2];
3619 
3620   return (form1 == form2);
3621 }
3622 
3623 //-------------------------cisc_spill_match_node-------------------------------
3624 // Recursively check two MatchRules for legal conversion via cisc-spilling
3625 int MatchNode::cisc_spill_match(FormDict& globals, RegisterForm* registers, MatchNode* mRule2, const char* &operand, const char* &reg_type) {
3626   int cisc_spillable  = Maybe_cisc_spillable;
3627   int left_spillable  = Maybe_cisc_spillable;
3628   int right_spillable = Maybe_cisc_spillable;
3629 
3630   // Check that each has same number of operands at this level
3631   if( (_lChild && !(mRule2->_lChild)) || (_rChild && !(mRule2->_rChild)) )
3632     return Not_cisc_spillable;
3633 
3634   // Base Case: check that the current operands/operations match
3635   // or are CISC spillable
3636   assert( _opType, "Must have _opType");
3637   assert( mRule2->_opType, "Must have _opType");
3638   const Form *form  = globals[_opType];
3639   const Form *form2 = globals[mRule2->_opType];
3640   if( form == form2 ) {
3641     cisc_spillable = Maybe_cisc_spillable;
3642   } else {
3643     const InstructForm *form2_inst = form2 ? form2->is_instruction() : NULL;
3644     const char *name_left  = mRule2->_lChild ? mRule2->_lChild->_opType : NULL;
3645     const char *name_right = mRule2->_rChild ? mRule2->_rChild->_opType : NULL;
3646     DataType data_type = Form::none;
3647     if (form->is_operand()) {
3648       // Make sure the loadX matches the type of the reg
3649       data_type = form->ideal_to_Reg_type(form->is_operand()->ideal_type(globals));
3650     }
3651     // Detect reg vs (loadX memory)
3652     if( form->is_cisc_reg(globals)
3653         && form2_inst
3654         && data_type != Form::none
3655         && (is_load_from_memory(mRule2->_opType) == data_type) // reg vs. (load memory)
3656         && (name_left != NULL)       // NOT (load)
3657         && (name_right == NULL) ) {  // NOT (load memory foo)
3658       const Form *form2_left = globals[name_left];
3659       if( form2_left && form2_left->is_cisc_mem(globals) ) {
3660         cisc_spillable = Is_cisc_spillable;
3661         operand        = _name;
3662         reg_type       = _result;
3663         return Is_cisc_spillable;
3664       } else {
3665         cisc_spillable = Not_cisc_spillable;
3666       }
3667     }
3668     // Detect reg vs memory
3669     else if (form->is_cisc_reg(globals) && form2 != NULL && form2->is_cisc_mem(globals)) {
3670       cisc_spillable = Is_cisc_spillable;
3671       operand        = _name;
3672       reg_type       = _result;
3673       return Is_cisc_spillable;
3674     } else {
3675       cisc_spillable = Not_cisc_spillable;
3676     }
3677   }
3678 
3679   // If cisc is still possible, check rest of tree
3680   if( cisc_spillable == Maybe_cisc_spillable ) {
3681     // Check that each has same number of operands at this level
3682     if( (_lChild && !(mRule2->_lChild)) || (_rChild && !(mRule2->_rChild)) ) return Not_cisc_spillable;
3683 
3684     // Check left operands
3685     if( (_lChild == NULL) && (mRule2->_lChild == NULL) ) {
3686       left_spillable = Maybe_cisc_spillable;
3687     } else  if (_lChild != NULL) {
3688       left_spillable = _lChild->cisc_spill_match(globals, registers, mRule2->_lChild, operand, reg_type);
3689     }
3690 
3691     // Check right operands
3692     if( (_rChild == NULL) && (mRule2->_rChild == NULL) ) {
3693       right_spillable =  Maybe_cisc_spillable;
3694     } else if (_rChild != NULL) {
3695       right_spillable = _rChild->cisc_spill_match(globals, registers, mRule2->_rChild, operand, reg_type);
3696     }
3697 
3698     // Combine results of left and right checks
3699     cisc_spillable = cisc_spill_merge(left_spillable, right_spillable);
3700   }
3701 
3702   return cisc_spillable;
3703 }
3704 
3705 //---------------------------cisc_spill_match_rule------------------------------
3706 // Recursively check two MatchRules for legal conversion via cisc-spilling
3707 // This method handles the root of Match tree,
3708 // general recursive checks done in MatchNode
3709 int  MatchRule::matchrule_cisc_spill_match(FormDict& globals, RegisterForm* registers,
3710                                            MatchRule* mRule2, const char* &operand,
3711                                            const char* &reg_type) {
3712   int cisc_spillable  = Maybe_cisc_spillable;
3713   int left_spillable  = Maybe_cisc_spillable;
3714   int right_spillable = Maybe_cisc_spillable;
3715 
3716   // Check that each sets a result
3717   if( !(sets_result() && mRule2->sets_result()) ) return Not_cisc_spillable;
3718   // Check that each has same number of operands at this level
3719   if( (_lChild && !(mRule2->_lChild)) || (_rChild && !(mRule2->_rChild)) ) return Not_cisc_spillable;
3720 
3721   // Check left operands: at root, must be target of 'Set'
3722   if( (_lChild == NULL) || (mRule2->_lChild == NULL) ) {
3723     left_spillable = Not_cisc_spillable;
3724   } else {
3725     // Do not support cisc-spilling instruction's target location
3726     if( root_ops_match(globals, _lChild->_opType, mRule2->_lChild->_opType) ) {
3727       left_spillable = Maybe_cisc_spillable;
3728     } else {
3729       left_spillable = Not_cisc_spillable;
3730     }
3731   }
3732 
3733   // Check right operands: recursive walk to identify reg->mem operand
3734   if (_rChild == NULL) {
3735     if (mRule2->_rChild == NULL) {
3736       right_spillable =  Maybe_cisc_spillable;
3737     } else {
3738       assert(0, "_rChild should not be NULL");
3739     }
3740   } else {
3741     right_spillable = _rChild->cisc_spill_match(globals, registers, mRule2->_rChild, operand, reg_type);
3742   }
3743 
3744   // Combine results of left and right checks
3745   cisc_spillable = cisc_spill_merge(left_spillable, right_spillable);
3746 
3747   return cisc_spillable;
3748 }
3749 
3750 //----------------------------- equivalent ------------------------------------
3751 // Recursively check to see if two match rules are equivalent.
3752 // This rule handles the root.
3753 bool MatchRule::equivalent(FormDict &globals, MatchNode *mRule2) {
3754   // Check that each sets a result
3755   if (sets_result() != mRule2->sets_result()) {
3756     return false;
3757   }
3758 
3759   // Check that the current operands/operations match
3760   assert( _opType, "Must have _opType");
3761   assert( mRule2->_opType, "Must have _opType");
3762   const Form *form  = globals[_opType];
3763   const Form *form2 = globals[mRule2->_opType];
3764   if( form != form2 ) {
3765     return false;
3766   }
3767 
3768   if (_lChild ) {
3769     if( !_lChild->equivalent(globals, mRule2->_lChild) )
3770       return false;
3771   } else if (mRule2->_lChild) {
3772     return false; // I have NULL left child, mRule2 has non-NULL left child.
3773   }
3774 
3775   if (_rChild ) {
3776     if( !_rChild->equivalent(globals, mRule2->_rChild) )
3777       return false;
3778   } else if (mRule2->_rChild) {
3779     return false; // I have NULL right child, mRule2 has non-NULL right child.
3780   }
3781 
3782   // We've made it through the gauntlet.
3783   return true;
3784 }
3785 
3786 //----------------------------- equivalent ------------------------------------
3787 // Recursively check to see if two match rules are equivalent.
3788 // This rule handles the operands.
3789 bool MatchNode::equivalent(FormDict &globals, MatchNode *mNode2) {
3790   if( !mNode2 )
3791     return false;
3792 
3793   // Check that the current operands/operations match
3794   assert( _opType, "Must have _opType");
3795   assert( mNode2->_opType, "Must have _opType");
3796   const Form *form  = globals[_opType];
3797   const Form *form2 = globals[mNode2->_opType];
3798   if( form != form2 ) {
3799     return false;
3800   }
3801 
3802   // Check that their children also match
3803   if (_lChild ) {
3804     if( !_lChild->equivalent(globals, mNode2->_lChild) )
3805       return false;
3806   } else if (mNode2->_lChild) {
3807     return false; // I have NULL left child, mNode2 has non-NULL left child.
3808   }
3809 
3810   if (_rChild ) {
3811     if( !_rChild->equivalent(globals, mNode2->_rChild) )
3812       return false;
3813   } else if (mNode2->_rChild) {
3814     return false; // I have NULL right child, mNode2 has non-NULL right child.
3815   }
3816 
3817   // We've made it through the gauntlet.
3818   return true;
3819 }
3820 
3821 //-------------------------- has_commutative_op -------------------------------
3822 // Recursively check for commutative operations with subtree operands
3823 // which could be swapped.
3824 void MatchNode::count_commutative_op(int& count) {
3825   static const char *commut_op_list[] = {
3826     "AddI","AddL","AddF","AddD",
3827     "AddVB","AddVS","AddVI","AddVL","AddVF","AddVD",
3828     "AndI","AndL",
3829     "AndV",
3830     "MaxI","MinI","MaxF","MinF","MaxD","MinD",
3831     "MaxV", "MinV",
3832     "MulI","MulL","MulF","MulD",
3833     "MulVB","MulVS","MulVI","MulVL","MulVF","MulVD",
3834     "OrI","OrL",
3835     "OrV",
3836     "XorI","XorL",
3837     "XorV"
3838   };
3839   int cnt = sizeof(commut_op_list)/sizeof(char*);
3840 
3841   if( _lChild && _rChild && (_lChild->_lChild || _rChild->_lChild) ) {
3842     // Don't swap if right operand is an immediate constant.
3843     bool is_const = false;
3844     if( _rChild->_lChild == NULL && _rChild->_rChild == NULL ) {
3845       FormDict &globals = _AD.globalNames();
3846       const Form *form = globals[_rChild->_opType];
3847       if ( form ) {
3848         OperandForm  *oper = form->is_operand();
3849         if( oper && oper->interface_type(globals) == Form::constant_interface )
3850           is_const = true;
3851       }
3852     }
3853     if( !is_const ) {
3854       for( int i=0; i<cnt; i++ ) {
3855         if( strcmp(_opType, commut_op_list[i]) == 0 ) {
3856           count++;
3857           _commutative_id = count; // id should be > 0
3858           break;
3859         }
3860       }
3861     }
3862   }
3863   if( _lChild )
3864     _lChild->count_commutative_op(count);
3865   if( _rChild )
3866     _rChild->count_commutative_op(count);
3867 }
3868 
3869 //-------------------------- swap_commutative_op ------------------------------
3870 // Recursively swap specified commutative operation with subtree operands.
3871 void MatchNode::swap_commutative_op(bool atroot, int id) {
3872   if( _commutative_id == id ) { // id should be > 0
3873     assert(_lChild && _rChild && (_lChild->_lChild || _rChild->_lChild ),
3874             "not swappable operation");
3875     MatchNode* tmp = _lChild;
3876     _lChild = _rChild;
3877     _rChild = tmp;
3878     // Don't exit here since we need to build internalop.
3879   }
3880 
3881   bool is_set = ( strcmp(_opType, "Set") == 0 );
3882   if( _lChild )
3883     _lChild->swap_commutative_op(is_set, id);
3884   if( _rChild )
3885     _rChild->swap_commutative_op(is_set, id);
3886 
3887   // If not the root, reduce this subtree to an internal operand
3888   if( !atroot && (_lChild || _rChild) ) {
3889     build_internalop();
3890   }
3891 }
3892 
3893 //-------------------------- swap_commutative_op ------------------------------
3894 // Recursively swap specified commutative operation with subtree operands.
3895 void MatchRule::matchrule_swap_commutative_op(const char* instr_ident, int count, int& match_rules_cnt) {
3896   assert(match_rules_cnt < 100," too many match rule clones");
3897   // Clone
3898   MatchRule* clone = new MatchRule(_AD, this);
3899   // Swap operands of commutative operation
3900   ((MatchNode*)clone)->swap_commutative_op(true, count);
3901   char* buf = (char*) AllocateHeap(strlen(instr_ident) + 4);
3902   sprintf(buf, "%s_%d", instr_ident, match_rules_cnt++);
3903   clone->_result = buf;
3904 
3905   clone->_next = this->_next;
3906   this-> _next = clone;
3907   if( (--count) > 0 ) {
3908     this-> matchrule_swap_commutative_op(instr_ident, count, match_rules_cnt);
3909     clone->matchrule_swap_commutative_op(instr_ident, count, match_rules_cnt);
3910   }
3911 }
3912 
3913 //------------------------------MatchRule--------------------------------------
3914 MatchRule::MatchRule(ArchDesc &ad)
3915   : MatchNode(ad), _depth(0), _construct(NULL), _numchilds(0) {
3916     _next = NULL;
3917 }
3918 
3919 MatchRule::MatchRule(ArchDesc &ad, MatchRule* mRule)
3920   : MatchNode(ad, *mRule, 0), _depth(mRule->_depth),
3921     _construct(mRule->_construct), _numchilds(mRule->_numchilds) {
3922     _next = NULL;
3923 }
3924 
3925 MatchRule::MatchRule(ArchDesc &ad, MatchNode* mroot, int depth, char *cnstr,
3926                      int numleaves)
3927   : MatchNode(ad,*mroot), _depth(depth), _construct(cnstr),
3928     _numchilds(0) {
3929       _next = NULL;
3930       mroot->_lChild = NULL;
3931       mroot->_rChild = NULL;
3932       delete mroot;
3933       _numleaves = numleaves;
3934       _numchilds = (_lChild ? 1 : 0) + (_rChild ? 1 : 0);
3935 }
3936 MatchRule::~MatchRule() {
3937 }
3938 
3939 // Recursive call collecting info on top-level operands, not transitive.
3940 // Implementation does not modify state of internal structures.
3941 void MatchRule::append_components(FormDict& locals, ComponentList& components, bool def_flag) const {
3942   assert (_name != NULL, "MatchNode::build_components encountered empty node\n");
3943 
3944   MatchNode::append_components(locals, components,
3945                                false /* not necessarily a def */);
3946 }
3947 
3948 // Recursive call on all operands' match rules in my match rule.
3949 // Implementation does not modify state of internal structures  since they
3950 // can be shared.
3951 // The MatchNode that is called first treats its
3952 bool MatchRule::base_operand(uint &position0, FormDict &globals,
3953                              const char *&result, const char * &name,
3954                              const char * &opType)const{
3955   uint position = position0;
3956 
3957   return (MatchNode::base_operand( position, globals, result, name, opType));
3958 }
3959 
3960 
3961 bool MatchRule::is_base_register(FormDict &globals) const {
3962   uint   position = 1;
3963   const char  *result   = NULL;
3964   const char  *name     = NULL;
3965   const char  *opType   = NULL;
3966   if (!base_operand(position, globals, result, name, opType)) {
3967     position = 0;
3968     if( base_operand(position, globals, result, name, opType) &&
3969         (strcmp(opType,"RegI")==0 ||
3970          strcmp(opType,"RegP")==0 ||
3971          strcmp(opType,"RegN")==0 ||
3972          strcmp(opType,"RegL")==0 ||
3973          strcmp(opType,"RegF")==0 ||
3974          strcmp(opType,"RegD")==0 ||
3975          strcmp(opType,"RegVectMask")==0 ||
3976          strcmp(opType,"VecA")==0 ||
3977          strcmp(opType,"VecS")==0 ||
3978          strcmp(opType,"VecD")==0 ||
3979          strcmp(opType,"VecX")==0 ||
3980          strcmp(opType,"VecY")==0 ||
3981          strcmp(opType,"VecZ")==0 ||
3982          strcmp(opType,"Reg" )==0) ) {
3983       return 1;
3984     }
3985   }
3986   return 0;
3987 }
3988 
3989 Form::DataType MatchRule::is_base_constant(FormDict &globals) const {
3990   uint         position = 1;
3991   const char  *result   = NULL;
3992   const char  *name     = NULL;
3993   const char  *opType   = NULL;
3994   if (!base_operand(position, globals, result, name, opType)) {
3995     position = 0;
3996     if (base_operand(position, globals, result, name, opType)) {
3997       return ideal_to_const_type(opType);
3998     }
3999   }
4000   return Form::none;
4001 }
4002 
4003 bool MatchRule::is_chain_rule(FormDict &globals) const {
4004 
4005   // Check for chain rule, and do not generate a match list for it
4006   if ((_lChild == NULL) && (_rChild == NULL) ) {
4007     const Form *form = globals[_opType];
4008     // If this is ideal, then it is a base match, not a chain rule.
4009     if ( form && form->is_operand() && (!form->ideal_only())) {
4010       return true;
4011     }
4012   }
4013   // Check for "Set" form of chain rule, and do not generate a match list
4014   if (_rChild) {
4015     const char *rch = _rChild->_opType;
4016     const Form *form = globals[rch];
4017     if ((!strcmp(_opType,"Set") &&
4018          ((form) && form->is_operand()))) {
4019       return true;
4020     }
4021   }
4022   return false;
4023 }
4024 
4025 int MatchRule::is_ideal_copy() const {
4026   if (is_chain_rule(_AD.globalNames()) &&
4027       _lChild && strncmp(_lChild->_opType, "stackSlot", 9) == 0) {
4028     return 1;
4029   }
4030   return 0;
4031 }
4032 
4033 int MatchRule::is_expensive() const {
4034   if( _rChild ) {
4035     const char  *opType = _rChild->_opType;
4036     if( strcmp(opType,"AtanD")==0 ||
4037         strcmp(opType,"DivD")==0 ||
4038         strcmp(opType,"DivF")==0 ||
4039         strcmp(opType,"DivI")==0 ||
4040         strcmp(opType,"Log10D")==0 ||
4041         strcmp(opType,"ModD")==0 ||
4042         strcmp(opType,"ModF")==0 ||
4043         strcmp(opType,"ModI")==0 ||
4044         strcmp(opType,"SqrtD")==0 ||
4045         strcmp(opType,"SqrtF")==0 ||
4046         strcmp(opType,"TanD")==0 ||
4047         strcmp(opType,"ConvD2F")==0 ||
4048         strcmp(opType,"ConvD2I")==0 ||
4049         strcmp(opType,"ConvD2L")==0 ||
4050         strcmp(opType,"ConvF2D")==0 ||
4051         strcmp(opType,"ConvF2I")==0 ||
4052         strcmp(opType,"ConvF2L")==0 ||
4053         strcmp(opType,"ConvI2D")==0 ||
4054         strcmp(opType,"ConvI2F")==0 ||
4055         strcmp(opType,"ConvI2L")==0 ||
4056         strcmp(opType,"ConvL2D")==0 ||
4057         strcmp(opType,"ConvL2F")==0 ||
4058         strcmp(opType,"ConvL2I")==0 ||
4059         strcmp(opType,"DecodeN")==0 ||
4060         strcmp(opType,"EncodeP")==0 ||
4061         strcmp(opType,"EncodePKlass")==0 ||
4062         strcmp(opType,"DecodeNKlass")==0 ||
4063         strcmp(opType,"FmaD") == 0 ||
4064         strcmp(opType,"FmaF") == 0 ||
4065         strcmp(opType,"RoundDouble")==0 ||
4066         strcmp(opType,"RoundDoubleMode")==0 ||
4067         strcmp(opType,"RoundFloat")==0 ||
4068         strcmp(opType,"ReverseBytesI")==0 ||
4069         strcmp(opType,"ReverseBytesL")==0 ||
4070         strcmp(opType,"ReverseBytesUS")==0 ||
4071         strcmp(opType,"ReverseBytesS")==0 ||
4072         strcmp(opType,"ReplicateB")==0 ||
4073         strcmp(opType,"ReplicateS")==0 ||
4074         strcmp(opType,"ReplicateI")==0 ||
4075         strcmp(opType,"ReplicateL")==0 ||
4076         strcmp(opType,"ReplicateF")==0 ||
4077         strcmp(opType,"ReplicateD")==0 ||
4078         strcmp(opType,"AddReductionVI")==0 ||
4079         strcmp(opType,"AddReductionVL")==0 ||
4080         strcmp(opType,"AddReductionVF")==0 ||
4081         strcmp(opType,"AddReductionVD")==0 ||
4082         strcmp(opType,"MulReductionVI")==0 ||
4083         strcmp(opType,"MulReductionVL")==0 ||
4084         strcmp(opType,"MulReductionVF")==0 ||
4085         strcmp(opType,"MulReductionVD")==0 ||
4086         strcmp(opType,"MinReductionV")==0 ||
4087         strcmp(opType,"MaxReductionV")==0 ||
4088         strcmp(opType,"AndReductionV")==0 ||
4089         strcmp(opType,"OrReductionV")==0 ||
4090         strcmp(opType,"XorReductionV")==0 ||
4091         0 /* 0 to line up columns nicely */ )
4092       return 1;
4093   }
4094   return 0;
4095 }
4096 
4097 bool MatchRule::is_ideal_if() const {
4098   if( !_opType ) return false;
4099   return
4100     !strcmp(_opType,"If"            ) ||
4101     !strcmp(_opType,"CountedLoopEnd");
4102 }
4103 
4104 bool MatchRule::is_ideal_fastlock() const {
4105   if ( _opType && (strcmp(_opType,"Set") == 0) && _rChild ) {
4106     return (strcmp(_rChild->_opType,"FastLock") == 0);
4107   }
4108   return false;
4109 }
4110 
4111 bool MatchRule::is_ideal_membar() const {
4112   if( !_opType ) return false;
4113   return
4114     !strcmp(_opType,"MemBarAcquire") ||
4115     !strcmp(_opType,"MemBarRelease") ||
4116     !strcmp(_opType,"MemBarAcquireLock") ||
4117     !strcmp(_opType,"MemBarReleaseLock") ||
4118     !strcmp(_opType,"LoadFence" ) ||
4119     !strcmp(_opType,"StoreFence") ||
4120     !strcmp(_opType,"MemBarVolatile") ||
4121     !strcmp(_opType,"MemBarCPUOrder") ||
4122     !strcmp(_opType,"MemBarStoreStore") ||
4123     !strcmp(_opType,"OnSpinWait");
4124 }
4125 
4126 bool MatchRule::is_ideal_loadPC() const {
4127   if ( _opType && (strcmp(_opType,"Set") == 0) && _rChild ) {
4128     return (strcmp(_rChild->_opType,"LoadPC") == 0);
4129   }
4130   return false;
4131 }
4132 
4133 bool MatchRule::is_ideal_box() const {
4134   if ( _opType && (strcmp(_opType,"Set") == 0) && _rChild ) {
4135     return (strcmp(_rChild->_opType,"Box") == 0);
4136   }
4137   return false;
4138 }
4139 
4140 bool MatchRule::is_ideal_goto() const {
4141   bool   ideal_goto = false;
4142 
4143   if( _opType && (strcmp(_opType,"Goto") == 0) ) {
4144     ideal_goto = true;
4145   }
4146   return ideal_goto;
4147 }
4148 
4149 bool MatchRule::is_ideal_jump() const {
4150   if( _opType ) {
4151     if( !strcmp(_opType,"Jump") )
4152       return true;
4153   }
4154   return false;
4155 }
4156 
4157 bool MatchRule::is_ideal_bool() const {
4158   if( _opType ) {
4159     if( !strcmp(_opType,"Bool") )
4160       return true;
4161   }
4162   return false;
4163 }
4164 
4165 
4166 Form::DataType MatchRule::is_ideal_load() const {
4167   Form::DataType ideal_load = Form::none;
4168 
4169   if ( _opType && (strcmp(_opType,"Set") == 0) && _rChild ) {
4170     const char *opType = _rChild->_opType;
4171     ideal_load = is_load_from_memory(opType);
4172   }
4173 
4174   return ideal_load;
4175 }
4176 
4177 bool MatchRule::is_vector() const {
4178   static const char *vector_list[] = {
4179     "AddVB","AddVS","AddVI","AddVL","AddVF","AddVD",
4180     "SubVB","SubVS","SubVI","SubVL","SubVF","SubVD",
4181     "MulVB","MulVS","MulVI","MulVL","MulVF","MulVD",
4182     "CMoveVD", "CMoveVF",
4183     "DivVF","DivVD",
4184     "AbsVB","AbsVS","AbsVI","AbsVL","AbsVF","AbsVD",
4185     "NegVF","NegVD","NegVI",
4186     "SqrtVD","SqrtVF",
4187     "AndV" ,"XorV" ,"OrV",
4188     "MaxV", "MinV",
4189     "AddReductionVI", "AddReductionVL",
4190     "AddReductionVF", "AddReductionVD",
4191     "MulReductionVI", "MulReductionVL",
4192     "MulReductionVF", "MulReductionVD",
4193     "MaxReductionV", "MinReductionV",
4194     "AndReductionV", "OrReductionV", "XorReductionV",
4195     "MulAddVS2VI", "MacroLogicV",
4196     "LShiftCntV","RShiftCntV",
4197     "LShiftVB","LShiftVS","LShiftVI","LShiftVL",
4198     "RShiftVB","RShiftVS","RShiftVI","RShiftVL",
4199     "URShiftVB","URShiftVS","URShiftVI","URShiftVL",
4200     "ReplicateB","ReplicateS","ReplicateI","ReplicateL","ReplicateF","ReplicateD",
4201     "RoundDoubleModeV","RotateLeftV" , "RotateRightV", "LoadVector","StoreVector",
4202     "LoadVectorGather", "StoreVectorScatter",
4203     "VectorTest", "VectorLoadMask", "VectorStoreMask", "VectorBlend", "VectorInsert",
4204     "VectorRearrange","VectorLoadShuffle", "VectorLoadConst",
4205     "VectorCastB2X", "VectorCastS2X", "VectorCastI2X",
4206     "VectorCastL2X", "VectorCastF2X", "VectorCastD2X",
4207     "VectorMaskWrapper", "VectorMaskCmp", "VectorReinterpret","LoadVectorMasked","StoreVectorMasked",
4208     "FmaVD", "FmaVF","PopCountVI",
4209     // Next are not supported currently.
4210     "PackB","PackS","PackI","PackL","PackF","PackD","Pack2L","Pack2D",
4211     "ExtractB","ExtractUB","ExtractC","ExtractS","ExtractI","ExtractL","ExtractF","ExtractD",
4212     "VectorMaskCast"
4213   };
4214   int cnt = sizeof(vector_list)/sizeof(char*);
4215   if (_rChild) {
4216     const char  *opType = _rChild->_opType;
4217     for (int i=0; i<cnt; i++)
4218       if (strcmp(opType,vector_list[i]) == 0)
4219         return true;
4220   }
4221   return false;
4222 }
4223 
4224 
4225 bool MatchRule::skip_antidep_check() const {
4226   // Some loads operate on what is effectively immutable memory so we
4227   // should skip the anti dep computations.  For some of these nodes
4228   // the rewritable field keeps the anti dep logic from triggering but
4229   // for certain kinds of LoadKlass it does not since they are
4230   // actually reading memory which could be rewritten by the runtime,
4231   // though never by generated code.  This disables it uniformly for
4232   // the nodes that behave like this: LoadKlass, LoadNKlass and
4233   // LoadRange.
4234   if ( _opType && (strcmp(_opType,"Set") == 0) && _rChild ) {
4235     const char *opType = _rChild->_opType;
4236     if (strcmp("LoadKlass", opType) == 0 ||
4237         strcmp("LoadNKlass", opType) == 0 ||
4238         strcmp("LoadRange", opType) == 0) {
4239       return true;
4240     }
4241   }
4242 
4243   return false;
4244 }
4245 
4246 
4247 Form::DataType MatchRule::is_ideal_store() const {
4248   Form::DataType ideal_store = Form::none;
4249 
4250   if ( _opType && (strcmp(_opType,"Set") == 0) && _rChild ) {
4251     const char *opType = _rChild->_opType;
4252     ideal_store = is_store_to_memory(opType);
4253   }
4254 
4255   return ideal_store;
4256 }
4257 
4258 
4259 void MatchRule::dump() {
4260   output(stderr);
4261 }
4262 
4263 // Write just one line.
4264 void MatchRule::output_short(FILE *fp) {
4265   fprintf(fp,"MatchRule: ( %s",_name);
4266   if (_lChild) _lChild->output(fp);
4267   if (_rChild) _rChild->output(fp);
4268   fprintf(fp," )");
4269 }
4270 
4271 void MatchRule::output(FILE *fp) {
4272   output_short(fp);
4273   fprintf(fp,"\n   nesting depth = %d\n", _depth);
4274   if (_result) fprintf(fp,"   Result Type = %s", _result);
4275   fprintf(fp,"\n");
4276 }
4277 
4278 //------------------------------Attribute--------------------------------------
4279 Attribute::Attribute(char *id, char* val, int type)
4280   : _ident(id), _val(val), _atype(type) {
4281 }
4282 Attribute::~Attribute() {
4283 }
4284 
4285 int Attribute::int_val(ArchDesc &ad) {
4286   // Make sure it is an integer constant:
4287   int result = 0;
4288   if (!_val || !ADLParser::is_int_token(_val, result)) {
4289     ad.syntax_err(0, "Attribute %s must have an integer value: %s",
4290                   _ident, _val ? _val : "");
4291   }
4292   return result;
4293 }
4294 
4295 void Attribute::dump() {
4296   output(stderr);
4297 } // Debug printer
4298 
4299 // Write to output files
4300 void Attribute::output(FILE *fp) {
4301   fprintf(fp,"Attribute: %s  %s\n", (_ident?_ident:""), (_val?_val:""));
4302 }
4303 
4304 //------------------------------FormatRule----------------------------------
4305 FormatRule::FormatRule(char *temp)
4306   : _temp(temp) {
4307 }
4308 FormatRule::~FormatRule() {
4309 }
4310 
4311 void FormatRule::dump() {
4312   output(stderr);
4313 }
4314 
4315 // Write to output files
4316 void FormatRule::output(FILE *fp) {
4317   fprintf(fp,"\nFormat Rule: \n%s", (_temp?_temp:""));
4318   fprintf(fp,"\n");
4319 }