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