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