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