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