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