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