1 #ifdef USE_PRAGMA_IDENT_HDR 2 #pragma ident "@(#)formssel.hpp 1.77 07/07/19 19:08:28 JVM" 3 #endif 4 /* 5 * Copyright 1998-2007 Sun Microsystems, Inc. All Rights Reserved. 6 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 7 * 8 * This code is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License version 2 only, as 10 * published by the Free Software Foundation. 11 * 12 * This code is distributed in the hope that it will be useful, but WITHOUT 13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 * version 2 for more details (a copy is included in the LICENSE file that 16 * accompanied this code). 17 * 18 * You should have received a copy of the GNU General Public License version 19 * 2 along with this work; if not, write to the Free Software Foundation, 20 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 21 * 22 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 23 * CA 95054 USA or visit www.sun.com if you need additional information or 24 * have any questions. 25 * 26 */ 27 28 // FORMSSEL.HPP - ADL Parser Instruction Selection Forms Classes 29 30 // Class List 31 class Form; 32 class InstructForm; 33 class MachNodeForm; 34 class OperandForm; 35 class OpClassForm; 36 class AttributeForm; 37 class RegisterForm; 38 class PipelineForm; 39 class SourceForm; 40 class EncodeForm; 41 class Component; 42 class Constraint; 43 class Predicate; 44 class MatchRule; 45 class Attribute; 46 class Effect; 47 class ExpandRule; 48 class RewriteRule; 49 class ConstructRule; 50 class FormatRule; 51 class Peephole; 52 class EncClass; 53 class Interface; 54 class RegInterface; 55 class ConstInterface; 56 class MemInterface; 57 class CondInterface; 58 class Opcode; 59 class InsEncode; 60 class RegDef; 61 class RegClass; 62 class AllocClass; 63 class ResourceForm; 64 class PipeDesc; 65 class PipeClass; 66 class PeepMatch; 67 class PeepConstraint; 68 class PeepReplace; 69 class MatchList; 70 71 class ArchDesc; 72 73 //==============================Instructions=================================== 74 //------------------------------InstructForm----------------------------------- 75 class InstructForm : public Form { 76 private: 77 bool _ideal_only; // Not a user-defined instruction 78 // Members used for tracking CISC-spilling 79 uint _cisc_spill_operand;// Which operand may cisc-spill 80 void set_cisc_spill_operand(uint op_index) { _cisc_spill_operand = op_index; } 81 bool _is_cisc_alternate; 82 InstructForm *_cisc_spill_alternate;// cisc possible replacement 83 const char *_cisc_reg_mask_name; 84 InstructForm *_short_branch_form; 85 bool _is_short_branch; 86 uint _alignment; 87 88 public: 89 // Public Data 90 const char *_ident; // Name of this instruction 91 NameList _parameters; // Locally defined names 92 FormDict _localNames; // Table of operands & their types 93 MatchRule *_matrule; // Matching rule for this instruction 94 Opcode *_opcode; // Encoding of the opcode for instruction 95 char *_size; // Size of instruction 96 InsEncode *_insencode; // Encoding class instruction belongs to 97 Attribute *_attribs; // List of Attribute rules 98 Predicate *_predicate; // Predicate test for this instruction 99 FormDict _effects; // Dictionary of effect rules 100 ExpandRule *_exprule; // Expand rule for this instruction 101 RewriteRule *_rewrule; // Rewrite rule for this instruction 102 FormatRule *_format; // Format for assembly generation 103 Peephole *_peephole; // List of peephole rules for instruction 104 const char *_ins_pipe; // Instruction Scheduline description class 105 106 uint *_uniq_idx; // Indexes of unique operands 107 uint _num_uniq; // Number of unique operands 108 ComponentList _components; // List of Components matches MachNode's 109 // operand structure 110 111 // Public Methods 112 InstructForm(const char *id, bool ideal_only = false); 113 InstructForm(const char *id, InstructForm *instr, MatchRule *rule); 114 ~InstructForm(); 115 116 // Dynamic type check 117 virtual InstructForm *is_instruction() const; 118 119 virtual bool ideal_only() const; 120 121 // This instruction sets a result 122 virtual bool sets_result() const; 123 // This instruction needs projections for additional DEFs or KILLs 124 virtual bool needs_projections(); 125 // This instruction needs extra nodes for temporary inputs 126 virtual bool has_temps(); 127 // This instruction defines or kills more than one object 128 virtual uint num_defs_or_kills(); 129 // This instruction has an expand rule? 130 virtual bool expands() const ; 131 // Return this instruction's first peephole rule, or NULL 132 virtual Peephole *peepholes() const; 133 // Add a peephole rule to this instruction 134 virtual void append_peephole(Peephole *peep); 135 136 virtual bool is_pinned(FormDict &globals); // should be pinned inside block 137 virtual bool is_projection(FormDict &globals); // node requires projection 138 virtual bool is_parm(FormDict &globals); // node matches ideal 'Parm' 139 // ideal opcode enumeration 140 virtual const char *ideal_Opcode(FormDict &globals) const; 141 virtual int is_expensive() const; // node matches ideal 'CosD' 142 virtual int is_empty_encoding() const; // _size=0 and/or _insencode empty 143 virtual int is_tls_instruction() const; // tlsLoadP rule or ideal ThreadLocal 144 virtual int is_ideal_copy() const; // node matches ideal 'Copy*' 145 virtual bool is_ideal_unlock() const; // node matches ideal 'Unlock' 146 virtual bool is_ideal_call_leaf() const; // node matches ideal 'CallLeaf' 147 virtual bool is_ideal_if() const; // node matches ideal 'If' 148 virtual bool is_ideal_fastlock() const; // node matches 'FastLock' 149 virtual bool is_ideal_membar() const; // node matches ideal 'MemBarXXX' 150 virtual bool is_ideal_loadPC() const; // node matches ideal 'LoadPC' 151 virtual bool is_ideal_box() const; // node matches ideal 'Box' 152 virtual bool is_ideal_goto() const; // node matches ideal 'Goto' 153 virtual bool is_ideal_branch() const; // "" 'If' | 'Goto' | 'LoopEnd' | 'Jump' 154 virtual bool is_ideal_jump() const; // node matches ideal 'Jump' 155 virtual bool is_ideal_return() const; // node matches ideal 'Return' 156 virtual bool is_ideal_halt() const; // node matches ideal 'Halt' 157 virtual bool is_ideal_safepoint() const; // node matches 'SafePoint' 158 virtual bool is_ideal_nop() const; // node matches 'Nop' 159 virtual bool is_ideal_control() const; // control node 160 161 virtual Form::CallType is_ideal_call() const; // matches ideal 'Call' 162 virtual Form::DataType is_ideal_load() const; // node matches ideal 'LoadXNode' 163 virtual Form::DataType is_ideal_store() const;// node matches ideal 'StoreXNode' 164 bool is_ideal_mem() const { return is_ideal_load() != Form::none || is_ideal_store() != Form::none; } 165 virtual uint two_address(FormDict &globals); // output reg must match input reg 166 // when chaining a constant to an instruction, return 'true' and set opType 167 virtual Form::DataType is_chain_of_constant(FormDict &globals); 168 virtual Form::DataType is_chain_of_constant(FormDict &globals, const char * &opType); 169 virtual Form::DataType is_chain_of_constant(FormDict &globals, const char * &opType, const char * &result_type); 170 171 // Check if a simple chain rule 172 virtual bool is_simple_chain_rule(FormDict &globals) const; 173 174 // check for structural rematerialization 175 virtual bool rematerialize(FormDict &globals, RegisterForm *registers); 176 177 // loads from memory, so must check for anti-dependence 178 virtual bool needs_anti_dependence_check(FormDict &globals) const; 179 virtual int memory_operand(FormDict &globals) const; 180 bool is_wide_memory_kill(FormDict &globals) const; 181 182 enum memory_operand_type { 183 NO_MEMORY_OPERAND = -1, 184 MANY_MEMORY_OPERANDS = 999999 185 }; 186 187 188 // This instruction captures the machine-independent bottom_type 189 // Expected use is for pointer vs oop determination for LoadP 190 virtual bool captures_bottom_type() const; 191 192 virtual const char *cost(); // Access ins_cost attribute 193 virtual uint num_opnds(); // Count of num_opnds for MachNode class 194 virtual uint num_post_match_opnds(); 195 virtual uint num_consts(FormDict &globals) const;// Constants in match rule 196 // Constants in match rule with specified type 197 virtual uint num_consts(FormDict &globals, Form::DataType type) const; 198 199 // Return the register class associated with 'leaf'. 200 virtual const char *out_reg_class(FormDict &globals); 201 202 // number of ideal node inputs to skip 203 virtual uint oper_input_base(FormDict &globals); 204 205 // Does this instruction need a base-oop edge? 206 int needs_base_oop_edge(FormDict &globals) const; 207 208 // Build instruction predicates. If the user uses the same operand name 209 // twice, we need to check that the operands are pointer-eequivalent in 210 // the DFA during the labeling process. 211 Predicate *build_predicate(); 212 213 virtual void build_components(); // top-level operands 214 // Return zero-based position in component list; -1 if not in list. 215 virtual int operand_position(const char *name, int usedef); 216 virtual int operand_position_format(const char *name); 217 218 // Return zero-based position in component list; -1 if not in list. 219 virtual int label_position(); 220 virtual int method_position(); 221 // Return number of relocation entries needed for this instruction. 222 virtual uint reloc(FormDict &globals); 223 224 const char *reduce_result(); 225 // Return the name of the operand on the right hand side of the binary match 226 // Return NULL if there is no right hand side 227 const char *reduce_right(FormDict &globals) const; 228 const char *reduce_left(FormDict &globals) const; 229 230 // Base class for this instruction, MachNode except for calls 231 virtual const char *mach_base_class() const; 232 233 // Check if this instruction can cisc-spill to 'alternate' 234 bool cisc_spills_to(ArchDesc &AD, InstructForm *alternate); 235 InstructForm *cisc_spill_alternate() { return _cisc_spill_alternate; } 236 uint cisc_spill_operand() const { return _cisc_spill_operand; } 237 bool is_cisc_alternate() const { return _is_cisc_alternate; } 238 void set_cisc_alternate(bool val) { _is_cisc_alternate = val; } 239 const char *cisc_reg_mask_name() const { return _cisc_reg_mask_name; } 240 void set_cisc_reg_mask_name(const char *rm_name) { _cisc_reg_mask_name = rm_name; } 241 // Output cisc-method prototypes and method bodies 242 void declare_cisc_version(ArchDesc &AD, FILE *fp_cpp); 243 bool define_cisc_version (ArchDesc &AD, FILE *fp_cpp); 244 245 bool check_branch_variant(ArchDesc &AD, InstructForm *short_branch); 246 247 bool is_short_branch() { return _is_short_branch; } 248 void set_short_branch(bool val) { _is_short_branch = val; } 249 250 InstructForm *short_branch_form() { return _short_branch_form; } 251 bool has_short_branch_form() { return _short_branch_form != NULL; } 252 // Output short branch prototypes and method bodies 253 void declare_short_branch_methods(FILE *fp_cpp); 254 bool define_short_branch_methods(FILE *fp_cpp); 255 256 uint alignment() { return _alignment; } 257 void set_alignment(uint val) { _alignment = val; } 258 259 // Seach through operands to determine operands unique positions. 260 void set_unique_opnds(); 261 uint num_unique_opnds() { return _num_uniq; } 262 uint unique_opnds_idx(int idx) { 263 if( _uniq_idx != NULL && idx > 0 ) 264 return _uniq_idx[idx]; 265 else 266 return idx; 267 } 268 269 // Operands which are only KILLs aren't part of the input array and 270 // require special handling in some cases. Their position in this 271 // operand list is higher than the number of unique operands. 272 bool is_noninput_operand(uint idx) { 273 return (idx >= num_unique_opnds()); 274 } 275 276 // --------------------------- FILE *output_routines 277 // 278 // Generate the format call for the replacement variable 279 void rep_var_format(FILE *fp, const char *rep_var); 280 // Generate index values needed for determing the operand position 281 void index_temps (FILE *fp, FormDict &globals, const char *prefix = "", const char *receiver = ""); 282 // --------------------------- 283 284 virtual bool verify(); // Check consistency after parsing 285 286 virtual void dump(); // Debug printer 287 virtual void output(FILE *fp); // Write to output files 288 }; 289 290 //------------------------------EncodeForm------------------------------------- 291 class EncodeForm : public Form { 292 private: 293 294 public: 295 // Public Data 296 NameList _eclasses; // List of encode class names 297 Dict _encClass; // Map encode class names to EncClass objects 298 299 // Public Methods 300 EncodeForm(); 301 ~EncodeForm(); 302 303 EncClass *add_EncClass(const char *className); 304 EncClass *encClass(const char *className); 305 306 const char *encClassPrototype(const char *className); 307 const char *encClassBody(const char *className); 308 309 void dump(); // Debug printer 310 void output(FILE *fp); // Write info to output files 311 }; 312 313 //------------------------------EncClass--------------------------------------- 314 class EncClass : public Form { 315 public: 316 // NameList for parameter type and name 317 NameList _parameter_type; 318 NameList _parameter_name; 319 320 // Breakdown the encoding into strings separated by $replacement_variables 321 // There is an entry in _strings, perhaps NULL, that precedes each _rep_vars 322 NameList _code; // Strings passed through to tty->print 323 NameList _rep_vars; // replacement variables 324 325 NameList _parameters; // Locally defined names 326 FormDict _localNames; // Table of components & their types 327 328 public: 329 // Public Data 330 const char *_name; // encoding class name 331 332 // Public Methods 333 EncClass(const char *name); 334 ~EncClass(); 335 336 // --------------------------- Parameters 337 // Add a parameter <type,name> pair 338 void add_parameter(const char *parameter_type, const char *parameter_name); 339 // Verify operand types in parameter list 340 bool check_parameter_types(FormDict &globals); 341 // Obtain the zero-based index corresponding to a replacement variable 342 int rep_var_index(const char *rep_var); 343 int num_args() { return _parameter_name.count(); } 344 345 // --------------------------- Code Block 346 // Add code 347 void add_code(const char *string_preceeding_replacement_var); 348 // Add a replacement variable or one of its subfields 349 // Subfields are stored with a leading '$' 350 void add_rep_var(char *replacement_var); 351 352 bool verify(); 353 void dump(); 354 void output(FILE *fp); 355 }; 356 357 //------------------------------MachNode--------------------------------------- 358 class MachNodeForm: public Form { 359 private: 360 361 public: 362 char *_ident; // Name of this instruction 363 const char *_machnode_pipe; // Instruction Scheduline description class 364 365 // Public Methods 366 MachNodeForm(char *id); 367 ~MachNodeForm(); 368 369 virtual MachNodeForm *is_machnode() const; 370 371 void dump(); // Debug printer 372 void output(FILE *fp); // Write info to output files 373 }; 374 375 //------------------------------Opcode----------------------------------------- 376 class Opcode : public Form { 377 private: 378 379 public: 380 // Public Data 381 // Strings representing instruction opcodes, user defines placement in emit 382 char *_primary; 383 char *_secondary; 384 char *_tertiary; 385 386 enum opcode_type { 387 NOT_AN_OPCODE = -1, 388 PRIMARY = 1, 389 SECONDARY = 2, 390 TERTIARY = 3 391 }; 392 393 // Public Methods 394 Opcode(char *primary, char *secondary, char *tertiary); 395 ~Opcode(); 396 397 static Opcode::opcode_type as_opcode_type(const char *designator); 398 399 void dump(); 400 void output(FILE *fp); 401 402 // --------------------------- FILE *output_routines 403 void print_opcode(FILE *fp, Opcode::opcode_type desired_opcode); 404 }; 405 406 //------------------------------InsEncode-------------------------------------- 407 class InsEncode : public Form { 408 private: 409 // Public Data (access directly only for reads) 410 // The encodings can only have the values predefined by the ADLC: 411 // blank, RegReg, RegMem, MemReg, ... 412 NameList _encoding; 413 // NameList _parameter; 414 // The parameters for each encoding are preceeded by a NameList::_signal 415 // and follow the parameters for the previous encoding. 416 417 // char *_encode; // Type of instruction encoding 418 419 public: 420 // Public Methods 421 InsEncode(); 422 ~InsEncode(); 423 424 // Add "encode class name" and its parameters 425 NameAndList *add_encode(char *encode_method_name); 426 // Parameters are added to the returned "NameAndList" by the parser 427 428 // Access the list of encodings 429 void reset(); 430 const char *encode_class_iter(); 431 432 // Returns the number of arguments to the current encoding in the iteration 433 int current_encoding_num_args() { 434 return ((NameAndList*)_encoding.current())->count(); 435 } 436 437 // --------------------------- Parameters 438 // The following call depends upon position within encode_class_iteration 439 // 440 // Obtain parameter name from zero based index 441 const char *rep_var_name(InstructForm &inst, uint param_no); 442 // --------------------------- 443 444 void dump(); 445 void output(FILE *fp); 446 }; 447 448 //------------------------------Effect----------------------------------------- 449 class Effect : public Form { 450 private: 451 452 public: 453 // Public Data 454 const char *_name; // Pre-defined name for effect 455 int _use_def; // Enumeration value of effect 456 457 // Public Methods 458 Effect(const char *name); // Constructor 459 ~Effect(); // Destructor 460 461 // Dynamic type check 462 virtual Effect *is_effect() const; 463 464 // Return 'true' if this use def info equals the parameter 465 bool is(int use_def_kill_enum) const; 466 // Return 'true' if this use def info is a superset of parameter 467 bool isa(int use_def_kill_enum) const; 468 469 void dump(); // Debug printer 470 void output(FILE *fp); // Write info to output files 471 }; 472 473 //------------------------------ExpandRule------------------------------------- 474 class ExpandRule : public Form { 475 private: 476 NameList _expand_instrs; // ordered list of instructions and operands 477 478 public: 479 // Public Data 480 NameList _newopers; // List of newly created operands 481 Dict _newopconst; // Map new operands to their constructors 482 483 void add_instruction(NameAndList *instruction_name_and_operand_list); 484 void reset_instructions(); 485 NameAndList *iter_instructions(); 486 487 // Public Methods 488 ExpandRule(); // Constructor 489 ~ExpandRule(); // Destructor 490 491 void dump(); // Debug printer 492 void output(FILE *fp); // Write info to output files 493 }; 494 495 //------------------------------RewriteRule------------------------------------ 496 class RewriteRule : public Form { 497 private: 498 499 public: 500 // Public Data 501 SourceForm *_condition; // Rewrite condition code 502 InstructForm *_instrs; // List of instructions to expand to 503 OperandForm *_opers; // List of operands generated by expand 504 char *_tempParams; // Hold string until parser is finished. 505 char *_tempBlock; // Hold string until parser is finished. 506 507 // Public Methods 508 RewriteRule(char* params, char* block) ; 509 ~RewriteRule(); // Destructor 510 void dump(); // Debug printer 511 void output(FILE *fp); // Write info to output files 512 }; 513 514 515 //==============================Operands======================================= 516 //------------------------------OpClassForm------------------------------------ 517 class OpClassForm : public Form { 518 public: 519 // Public Data 520 const char *_ident; // Name of this operand 521 NameList _oplst; // List of operand forms included in class 522 523 // Public Methods 524 OpClassForm(const char *id); 525 ~OpClassForm(); 526 527 // dynamic type check 528 virtual OpClassForm *is_opclass() const; 529 virtual Form::InterfaceType interface_type(FormDict &globals) const; 530 virtual bool stack_slots_only(FormDict &globals) const; 531 532 virtual bool is_cisc_mem(FormDict &globals) const; 533 534 535 // Min and Max opcodes of operands in this operand class 536 int _minCode; 537 int _maxCode; 538 539 virtual bool ideal_only() const; 540 virtual void dump(); // Debug printer 541 virtual void output(FILE *fp); // Write to output files 542 }; 543 544 //------------------------------OperandForm------------------------------------ 545 class OperandForm : public OpClassForm { 546 private: 547 bool _ideal_only; // Not a user-defined instruction 548 549 public: 550 // Public Data 551 NameList _parameters; // Locally defined names 552 FormDict _localNames; // Table of components & their types 553 MatchRule *_matrule; // Matching rule for this operand 554 Interface *_interface; // Encoding interface for this operand 555 Attribute *_attribs; // List of Attribute rules 556 Predicate *_predicate; // Predicate test for this operand 557 Constraint *_constraint; // Constraint Rule for this operand 558 ConstructRule *_construct; // Construction of operand data after matching 559 FormatRule *_format; // Format for assembly generation 560 NameList _classes; // List of opclasses which contain this oper 561 562 ComponentList _components; // 563 564 // Public Methods 565 OperandForm(const char *id); 566 OperandForm(const char *id, bool ideal_only); 567 ~OperandForm(); 568 569 // Dynamic type check 570 virtual OperandForm *is_operand() const; 571 572 virtual bool ideal_only() const; 573 virtual Form::InterfaceType interface_type(FormDict &globals) const; 574 virtual bool stack_slots_only(FormDict &globals) const; 575 576 virtual const char *cost(); // Access ins_cost attribute 577 virtual uint num_leaves() const;// Leaves in complex operand 578 // Constants in operands' match rules 579 virtual uint num_consts(FormDict &globals) const; 580 // Constants in operand's match rule with specified type 581 virtual uint num_consts(FormDict &globals, Form::DataType type) const; 582 // Pointer Constants in operands' match rules 583 virtual uint num_const_ptrs(FormDict &globals) const; 584 // The number of input edges in the machine world == num_leaves - num_consts 585 virtual uint num_edges(FormDict &globals) const; 586 587 // Check if this operand is usable for cisc-spilling 588 virtual bool is_cisc_reg(FormDict &globals) const; 589 590 // node matches ideal 'Bool', grab condition codes from the ideal world 591 virtual bool is_ideal_bool() const; 592 593 // Has an integer constant suitable for spill offsets 594 bool has_conI(FormDict &globals) const { 595 return (num_consts(globals,idealI) == 1) && !is_ideal_bool(); } 596 bool has_conL(FormDict &globals) const { 597 return (num_consts(globals,idealL) == 1) && !is_ideal_bool(); } 598 599 // Node is user-defined operand for an sRegX 600 virtual Form::DataType is_user_name_for_sReg() const; 601 602 // Return ideal type, if there is a single ideal type for this operand 603 virtual const char *ideal_type(FormDict &globals, RegisterForm *registers = NULL) const; 604 // If there is a single ideal type for this interface field, return it. 605 virtual const char *interface_ideal_type(FormDict &globals, 606 const char *field_name) const; 607 608 // Return true if this operand represents a bound register class 609 bool is_bound_register() const; 610 611 // Return the Register class for this operand. Returns NULL if 612 // operand isn't a register form. 613 RegClass* get_RegClass() const; 614 615 virtual bool is_interface_field(const char *field_name, 616 const char * &value) const; 617 618 // If this operand has a single ideal type, return its type 619 virtual Form::DataType simple_type(FormDict &globals) const; 620 // If this operand is an ideal constant, return its type 621 virtual Form::DataType is_base_constant(FormDict &globals) const; 622 623 // "true" if this operand is a simple type that is swallowed 624 virtual bool swallowed(FormDict &globals) const; 625 626 // Return register class name if a constraint specifies the register class. 627 virtual const char *constrained_reg_class() const; 628 // Return the register class associated with 'leaf'. 629 virtual const char *in_reg_class(uint leaf, FormDict &globals); 630 631 // Build component list from MatchRule and operand's parameter list 632 virtual void build_components(); // top-level operands 633 634 // Return zero-based position in component list; -1 if not in list. 635 virtual int operand_position(const char *name, int usedef); 636 637 // Return zero-based position in component list; -1 if not in list. 638 virtual int constant_position(FormDict &globals, const Component *comp); 639 virtual int constant_position(FormDict &globals, const char *local_name); 640 // Return the operand form corresponding to the given index, else NULL. 641 virtual OperandForm *constant_operand(FormDict &globals, uint const_index); 642 643 // Return zero-based position in component list; -1 if not in list. 644 virtual int register_position(FormDict &globals, const char *regname); 645 646 const char *reduce_result() const; 647 // Return the name of the operand on the right hand side of the binary match 648 // Return NULL if there is no right hand side 649 const char *reduce_right(FormDict &globals) const; 650 const char *reduce_left(FormDict &globals) const; 651 652 653 // --------------------------- FILE *output_routines 654 // 655 // Output code for disp_is_oop, if true. 656 void disp_is_oop(FILE *fp, FormDict &globals); 657 // Generate code for internal and external format methods 658 void int_format(FILE *fp, FormDict &globals, uint index); 659 void ext_format(FILE *fp, FormDict &globals, uint index); 660 void format_constant(FILE *fp, uint con_index, uint con_type); 661 // Output code to access the value of the index'th constant 662 void access_constant(FILE *fp, FormDict &globals, 663 uint con_index); 664 // --------------------------- 665 666 667 virtual void dump(); // Debug printer 668 virtual void output(FILE *fp); // Write to output files 669 }; 670 671 //------------------------------Constraint------------------------------------- 672 class Constraint : public Form { 673 private: 674 675 public: 676 const char *_func; // Constraint function 677 const char *_arg; // function's argument 678 679 // Public Methods 680 Constraint(const char *func, const char *arg); // Constructor 681 ~Constraint(); 682 683 bool stack_slots_only() const; 684 685 void dump(); // Debug printer 686 void output(FILE *fp); // Write info to output files 687 }; 688 689 //------------------------------Predicate-------------------------------------- 690 class Predicate : public Form { 691 private: 692 693 public: 694 // Public Data 695 char *_pred; // C++ source string for predicate 696 697 // Public Methods 698 Predicate(char *pr); 699 ~Predicate(); 700 701 void dump(); 702 void output(FILE *fp); 703 }; 704 705 //------------------------------Interface-------------------------------------- 706 class Interface : public Form { 707 private: 708 709 public: 710 // Public Data 711 const char *_name; // String representing the interface name 712 713 // Public Methods 714 Interface(const char *name); 715 ~Interface(); 716 717 virtual Form::InterfaceType interface_type(FormDict &globals) const; 718 719 RegInterface *is_RegInterface(); 720 MemInterface *is_MemInterface(); 721 ConstInterface *is_ConstInterface(); 722 CondInterface *is_CondInterface(); 723 724 725 void dump(); 726 void output(FILE *fp); 727 }; 728 729 //------------------------------RegInterface----------------------------------- 730 class RegInterface : public Interface { 731 private: 732 733 public: 734 // Public Methods 735 RegInterface(); 736 ~RegInterface(); 737 738 void dump(); 739 void output(FILE *fp); 740 }; 741 742 //------------------------------ConstInterface--------------------------------- 743 class ConstInterface : public Interface { 744 private: 745 746 public: 747 // Public Methods 748 ConstInterface(); 749 ~ConstInterface(); 750 751 void dump(); 752 void output(FILE *fp); 753 }; 754 755 //------------------------------MemInterface----------------------------------- 756 class MemInterface : public Interface { 757 private: 758 759 public: 760 // Public Data 761 char *_base; // Base address 762 char *_index; // index 763 char *_scale; // scaling factor 764 char *_disp; // displacement 765 766 // Public Methods 767 MemInterface(char *base, char *index, char *scale, char *disp); 768 ~MemInterface(); 769 770 void dump(); 771 void output(FILE *fp); 772 }; 773 774 //------------------------------CondInterface---------------------------------- 775 class CondInterface : public Interface { 776 private: 777 778 public: 779 const char *_equal; 780 const char *_not_equal; 781 const char *_less; 782 const char *_greater_equal; 783 const char *_less_equal; 784 const char *_greater; 785 786 // Public Methods 787 CondInterface(char *equal, char *not_equal, char *less, char *greater_equal, 788 char *less_equal, char *greater); 789 ~CondInterface(); 790 791 void dump(); 792 void output(FILE *fp); 793 }; 794 795 //------------------------------ConstructRule---------------------------------- 796 class ConstructRule : public Form { 797 private: 798 799 public: 800 // Public Data 801 char *_expr; // String representing the match expression 802 char *_construct; // String representing C++ constructor code 803 804 // Public Methods 805 ConstructRule(char *cnstr); 806 ~ConstructRule(); 807 808 void dump(); 809 void output(FILE *fp); 810 }; 811 812 813 //==============================Shared========================================= 814 //------------------------------AttributeForm---------------------------------- 815 class AttributeForm : public Form { 816 private: 817 // counters for unique instruction or operand ID 818 static int _insId; // user-defined machine instruction types 819 static int _opId; // user-defined operand types 820 821 int id; // hold type for this object 822 823 public: 824 // Public Data 825 char *_attrname; // Name of attribute 826 int _atype; // Either INS_ATTR or OP_ATTR 827 char *_attrdef; // C++ source which evaluates to constant 828 829 // Public Methods 830 AttributeForm(char *attr, int type, char *attrdef); 831 ~AttributeForm(); 832 833 // Dynamic type check 834 virtual AttributeForm *is_attribute() const; 835 836 int type() { return id;} // return this object's "id" 837 838 static const char* _ins_cost; // "ins_cost" 839 static const char* _ins_pc_relative; // "ins_pc_relative" 840 static const char* _op_cost; // "op_cost" 841 842 void dump(); // Debug printer 843 void output(FILE *fp); // Write output files 844 }; 845 846 //------------------------------Component-------------------------------------- 847 class Component : public Form { 848 private: 849 850 public: 851 // Public Data 852 const char *_name; // Name of this component 853 const char *_type; // Type of this component 854 int _usedef; // Value of component 855 856 // Public Methods 857 Component(const char *name, const char *type, int usedef); 858 ~Component(); 859 860 861 // Return 'true' if this use def info equals the parameter 862 bool is(int use_def_kill_enum) const; 863 // Return 'true' if this use def info is a superset of parameter 864 bool isa(int use_def_kill_enum) const; 865 int promote_use_def_info(int new_use_def); 866 const char *base_type(FormDict &globals); 867 // Form::DataType is_base_constant(FormDict &globals); 868 869 void dump(); // Debug printer 870 void output(FILE *fp); // Write to output files 871 872 public: 873 // Implementation depends upon working bit intersection and union. 874 enum use_def_enum { 875 INVALID = 0x0, 876 USE = 0x1, 877 DEF = 0x2, USE_DEF = 0x3, 878 KILL = 0x4, USE_KILL = 0x5, 879 SYNTHETIC = 0x8, 880 TEMP = USE | SYNTHETIC 881 }; 882 }; 883 884 885 //------------------------------MatchNode-------------------------------------- 886 class MatchNode : public Form { 887 private: 888 889 public: 890 // Public Data 891 const char *_result; // The name of the output of this node 892 const char *_name; // The name that appeared in the match rule 893 const char *_opType; // The Operation/Type matched 894 MatchNode *_lChild; // Left child in expression tree 895 MatchNode *_rChild; // Right child in expression tree 896 int _numleaves; // Sum of numleaves for all direct children 897 ArchDesc &_AD; // Reference to ArchDesc object 898 char *_internalop; // String representing internal operand 899 int _commutative_id; // id of commutative operation 900 901 // Public Methods 902 MatchNode(ArchDesc &ad, const char *result = 0, const char *expr = 0, 903 const char *opType=0, MatchNode *lChild=NULL, 904 MatchNode *rChild=NULL); 905 MatchNode(ArchDesc &ad, MatchNode& mNode); // Shallow copy constructor; 906 MatchNode(ArchDesc &ad, MatchNode& mNode, int clone); // Construct clone 907 ~MatchNode(); 908 909 // return 0 if not found: 910 // return 1 if found and position is incremented by operand offset in rule 911 bool find_name(const char *str, int &position) const; 912 bool find_type(const char *str, int &position) const; 913 void append_components(FormDict &locals, ComponentList &components, 914 bool def_flag) const; 915 bool base_operand(uint &position, FormDict &globals, 916 const char * &result, const char * &name, 917 const char * &opType) const; 918 // recursive count on operands 919 uint num_consts(FormDict &globals) const; 920 uint num_const_ptrs(FormDict &globals) const; 921 // recursive count of constants with specified type 922 uint num_consts(FormDict &globals, Form::DataType type) const; 923 // uint num_consts() const; // Local inspection only 924 int needs_ideal_memory_edge(FormDict &globals) const; 925 int needs_base_oop_edge() const; 926 927 // Help build instruction predicates. Search for operand names. 928 void count_instr_names( Dict &names ); 929 int build_instr_pred( char *buf, const char *name, int cnt ); 930 void build_internalop( ); 931 932 // Return the name of the operands associated with reducing to this operand: 933 // The result type, plus the left and right sides of the binary match 934 // Return NULL if there is no left or right hand side 935 bool sets_result() const; // rule "Set"s result of match 936 const char *reduce_right(FormDict &globals) const; 937 const char *reduce_left (FormDict &globals) const; 938 939 // Recursive version of check in MatchRule 940 int cisc_spill_match(FormDict &globals, RegisterForm *registers, 941 MatchNode *mRule2, const char * &operand, 942 const char * ®_type); 943 int cisc_spill_merge(int left_result, int right_result); 944 945 bool equivalent(FormDict &globals, MatchNode *mNode2); 946 947 void count_commutative_op(int& count); 948 void swap_commutative_op(bool atroot, int count); 949 950 void dump(); 951 void output(FILE *fp); 952 }; 953 954 //------------------------------MatchRule-------------------------------------- 955 class MatchRule : public MatchNode { 956 private: 957 958 public: 959 // Public Data 960 const char *_machType; // Machine type index 961 int _depth; // Expression tree depth 962 char *_construct; // String representing C++ constructor code 963 int _numchilds; // Number of direct children 964 MatchRule *_next; // Pointer to next match rule 965 966 // Public Methods 967 MatchRule(ArchDesc &ad); 968 MatchRule(ArchDesc &ad, MatchRule* mRule); // Shallow copy constructor; 969 MatchRule(ArchDesc &ad, MatchNode* mroot, int depth, char* construct, int numleaves); 970 ~MatchRule(); 971 972 void append_components(FormDict &locals, ComponentList &components) const; 973 // Recursive call on all operands' match rules in my match rule. 974 bool base_operand(uint &position, FormDict &globals, 975 const char * &result, const char * &name, 976 const char * &opType) const; 977 978 979 bool is_base_register(FormDict &globals) const; 980 Form::DataType is_base_constant(FormDict &globals) const; 981 bool is_chain_rule(FormDict &globals) const; 982 int is_ideal_copy() const; 983 int is_expensive() const; // node matches ideal 'CosD' 984 bool is_ideal_unlock() const; 985 bool is_ideal_call_leaf() const; 986 bool is_ideal_if() const; // node matches ideal 'If' 987 bool is_ideal_fastlock() const; // node matches ideal 'FastLock' 988 bool is_ideal_jump() const; // node matches ideal 'Jump' 989 bool is_ideal_membar() const; // node matches ideal 'MemBarXXX' 990 bool is_ideal_loadPC() const; // node matches ideal 'LoadPC' 991 bool is_ideal_box() const; // node matches ideal 'Box' 992 bool is_ideal_goto() const; // node matches ideal 'Goto' 993 bool is_ideal_loopEnd() const; // node matches ideal 'LoopEnd' 994 bool is_ideal_bool() const; // node matches ideal 'Bool' 995 Form::DataType is_ideal_load() const;// node matches ideal 'LoadXNode' 996 Form::DataType is_ideal_store() const;// node matches ideal 'StoreXNode' 997 998 // Check if 'mRule2' is a cisc-spill variant of this MatchRule 999 int cisc_spill_match(FormDict &globals, RegisterForm *registers, 1000 MatchRule *mRule2, const char * &operand, 1001 const char * ®_type); 1002 1003 // Check if 'mRule2' is equivalent to this MatchRule 1004 bool equivalent(FormDict &globals, MatchRule *mRule2); 1005 1006 void swap_commutative_op(const char* instr_ident, int count, int& match_rules_cnt); 1007 1008 void dump(); 1009 void output(FILE *fp); 1010 }; 1011 1012 //------------------------------Attribute-------------------------------------- 1013 class Attribute : public Form { 1014 private: 1015 1016 public: 1017 // Public Data 1018 char *_ident; // Name of predefined attribute 1019 char *_val; // C++ source which evaluates to constant 1020 int _atype; // Either INS_ATTR or OP_ATTR 1021 int int_val(ArchDesc &ad); // Return atoi(_val), ensuring syntax. 1022 1023 // Public Methods 1024 Attribute(char *id, char* val, int type); 1025 ~Attribute(); 1026 1027 void dump(); 1028 void output(FILE *fp); 1029 }; 1030 1031 //------------------------------FormatRule------------------------------------- 1032 class FormatRule : public Form { 1033 private: 1034 1035 public: 1036 // Public Data 1037 // There is an entry in _strings, perhaps NULL, that precedes each _rep_vars 1038 NameList _strings; // Strings passed through to tty->print 1039 NameList _rep_vars; // replacement variables 1040 char *_temp; // String representing the assembly code 1041 1042 // Public Methods 1043 FormatRule(char *temp); 1044 ~FormatRule(); 1045 1046 void dump(); 1047 void output(FILE *fp); 1048 };