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