hotspot/src/share/vm/adlc/forms.hpp
author never
Tue, 28 Oct 2008 09:31:30 -0700
changeset 1495 128fe18951ed
parent 670 ddf3e9583f2f
child 2129 e810a33b5c67
permissions -rw-r--r--
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it Reviewed-by: kvn, rasbold
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
670
ddf3e9583f2f 6719955: Update copyright year
xdono
parents: 360
diff changeset
     2
 * Copyright 1997-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
// FORMS.HPP - ADL Parser Generic and Utility Forms Classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
#define TRUE 1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
#define FALSE 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
// DEFINITIONS OF LEGAL ATTRIBUTE TYPES
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
#define INS_ATTR 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
#define OP_ATTR  1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
// DEFINITIONS OF LEGAL CONSTRAINT TYPES
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// Class List
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
class Form;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
class InstructForm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
class MachNodeForm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
class OperandForm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
class OpClassForm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
class AttributeForm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
class RegisterForm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
class PipelineForm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
class SourceForm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
class EncodeForm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
class Component;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
class Constraint;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
class Predicate;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
class MatchRule;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
class Attribute;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
class Effect;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
class ExpandRule;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
class RewriteRule;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
class ConstructRule;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
class FormatRule;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
class Peephole;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
class EncClass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
class Interface;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
class RegInterface;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
class ConstInterface;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
class MemInterface;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
class CondInterface;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
class Opcode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
class InsEncode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
class RegDef;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
class RegClass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
class AllocClass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
class ResourceForm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
class PipeClassForm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
class PeepMatch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
class PeepConstraint;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
class PeepReplace;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
class MatchList;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
class ArchDesc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
//------------------------------FormDict---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
// Dictionary containing Forms, and objects derived from forms
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
class FormDict {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  Dict         _form;              // map names, char*, to their Form* or NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  // Disable public use of constructor, copy-ctor, operator =, operator ==
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  FormDict( );
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  FormDict &operator =( const FormDict & );
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  // == compares two dictionaries; they must have the same keys (their keys
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  // must match using CmpKey) and they must have the same values (pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  // comparison).  If so 1 is returned, if not 0 is returned.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  bool operator ==(const FormDict &d) const; // Compare dictionaries for equal
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  // cmp is a key comparision routine.  hash is a routine to hash a key.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  // FormDict( CmpKey cmp, Hash hash );
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  FormDict( CmpKey cmp, Hash hash, Arena *arena );
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  FormDict( const FormDict & fd );    // Deep-copy guts
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  ~FormDict();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  // Return # of key-value pairs in dict
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  int Size(void) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  // Insert inserts the given key-value pair into the dictionary.  The prior
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  // value of the key is returned; NULL if the key was not previously defined.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  const Form  *Insert(const char *name, Form *form); // A new key-value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  // Find finds the value of a given key; or NULL if not found.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  // The dictionary is NOT changed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  const Form  *operator [](const char *name) const;  // Do a lookup
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  void dump();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
// ***** Master Class for ADL Parser Forms *****
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
//------------------------------Form-------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
class Form {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  static Arena  *arena;            // arena used by forms
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  static Arena  *generate_arena(); // allocate arena used by forms
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  int   _ftype;                    // Indicator for derived class type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  // Public Data
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  Form *_next;                     // Next pointer for form lists
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  long  _linenum;                  // Line number for debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  // Dynamic type check for common forms.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  virtual OpClassForm   *is_opclass()     const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  virtual OperandForm   *is_operand()     const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  virtual InstructForm  *is_instruction() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  virtual MachNodeForm  *is_machnode()    const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  virtual AttributeForm *is_attribute()   const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  virtual Effect        *is_effect()      const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  virtual ResourceForm  *is_resource()    const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  virtual PipeClassForm *is_pipeclass()   const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  // Check if this form is an operand usable for cisc-spilling
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  virtual bool           is_cisc_reg(FormDict &globals) const { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  virtual bool           is_cisc_mem(FormDict &globals) const { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  // Public Methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  Form(int formType=0, int line=0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
    : _next(NULL), _linenum(line), _ftype(formType) { };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  ~Form() {};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  virtual bool ideal_only() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
    assert(0,"Check of ideal status on non-instruction/operand form.\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
    return FALSE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // Check constraints after parsing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  virtual bool verify()    { return true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  virtual void dump()      { output(stderr); }    // Debug printer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  // Write info to output files
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  virtual void output(FILE *fp)    { fprintf(fp,"Form Output"); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  // ADLC types, match the last character on ideal operands and instructions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  enum DataType {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
    none        =  0,  // Not a simple type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
    idealI      =  1,  // Integer type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
    idealP      =  2,  // Pointer types, oop(s)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
    idealL      =  3,  // Long    type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
    idealF      =  4,  // Float   type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
    idealD      =  5,  // Double  type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
    idealB      =  6,  // Byte    type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
    idealC      =  7,  // Char    type
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   171
    idealS      =  8,  // String  type
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   172
    idealN      =  9   // Narrow oop types
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  // Convert ideal name to a DataType, return DataType::none if not a 'ConX'
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  Form::DataType  ideal_to_const_type(const char *ideal_type_name) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  // Convert ideal name to a DataType, return DataType::none if not a 'sRegX
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  Form::DataType  ideal_to_sReg_type(const char *name) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  // Convert ideal name to a DataType, return DataType::none if not a 'RegX
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  Form::DataType  ideal_to_Reg_type(const char *name) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  // Convert ideal name to a DataType, return DataType::none if not a 'LoadX
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  Form::DataType is_load_from_memory(const char *opType) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  // Convert ideal name to a DataType, return DataType::none if not a 'StoreX
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  Form::DataType is_store_to_memory(const char *opType)  const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  // ADLC call types, matched with ideal world
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  enum CallType {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
    invalid_type  =  0,  // invalid call type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
    JAVA_STATIC   =  1,  // monomorphic entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
    JAVA_DYNAMIC  =  2,  // possibly megamorphic, inline cache call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
    JAVA_COMPILED =  3,  // callee will be compiled java
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
    JAVA_INTERP   =  4,  // callee will be executed by interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
    JAVA_NATIVE   =  5,  // native entrypoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
    JAVA_RUNTIME  =  6,  // runtime entrypoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
    JAVA_LEAF     =  7   // calling leaf
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  // Interface types for operands and operand classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  enum InterfaceType {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
    no_interface          =  0,  // unknown or inconsistent interface type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    constant_interface    =  1,  // interface to constants
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
    register_interface    =  2,  // interface to registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
    memory_interface      =  3,  // interface to memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
    conditional_interface =  4   // interface for condition codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  virtual Form::InterfaceType interface_type(FormDict &globals) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  enum CiscSpillInfo {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
    Not_cisc_spillable   =  AdlcVMDeps::Not_cisc_spillable,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
    Maybe_cisc_spillable =   0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
    Is_cisc_spillable    =   1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
    // ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  // LEGAL FORM TYPES
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    INS,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    OPER,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
    OPCLASS,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    SRC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
    ADEF,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    REG,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
    PIPE,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
    CNST,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
    PRED,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
    ATTR,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    MAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
    ENC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
    FOR,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
    EXP,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
    REW,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
    EFF,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
    RDEF,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    RCL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
    ACL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
    RES,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
    PCL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
    PDEF,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
    REGL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
    RESL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
    STAL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    COMP,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
    PEEP,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    RESO
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
//------------------------------FormList---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
class FormList {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  Form *_root;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  Form *_tail;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  Form *_cur;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  int   _justReset;                // Set immediately after reset
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  Form *_cur2;                     // Nested iterator
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  int   _justReset2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  void addForm(Form * entry) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
    if (_tail==NULL) { _root = _tail = _cur = entry;}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
    else { _tail->_next = entry; _tail = entry;}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  Form * current() { return _cur; };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  Form * iter()    { if (_justReset) _justReset = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
                     else if (_cur)  _cur = _cur->_next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
                     return _cur;};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  void   reset()   { if (_root) {_cur = _root; _justReset = 1;} };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  // Second iterator, state is internal
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  Form * current2(){ return _cur2; };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  Form * iter2()   { if (_justReset2) _justReset2 = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
                    else if (_cur2)  _cur2 = _cur2->_next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
                    return _cur2;};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  void   reset2()  { if (_root) {_cur2 = _root; _justReset2 = 1;} };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  int  count() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
    int  count = 0; reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
    for( Form *cur; (cur =  iter()) != NULL; ) { ++count; };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    return count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  void dump() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
    Form *cur;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    for(; (cur =  iter()) != NULL; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
      cur->dump();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
    };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  bool verify() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
    bool verified = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
    reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
    Form *cur;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
    for(; (cur =  iter()) != NULL; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
      if ( ! cur->verify() ) verified = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
    };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
    return verified;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  void output(FILE* fp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
    reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
    Form *cur;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
    for( ; (cur =  iter()) != NULL; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
      cur->output(fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
    };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  FormList() { _justReset = 1; _justReset2 = 1; _root = NULL; _tail = NULL; _cur = NULL; _cur2 = NULL;};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  ~FormList();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
//------------------------------NameList---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
// Extendable list of pointers, <char *>
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
class NameList {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  friend class PreserveIter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  int                _cur;         // Insert next entry here; count of entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  int                _max;         // Number of spaces allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  const char       **_names;       // Array of names
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  int                _iter;        // position during iteration
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  bool               _justReset;   // Set immediately after reset
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  static const char *_signal;      // reserved user-defined string
1495
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 670
diff changeset
   332
  static const char *_signal2;      // reserved user-defined string
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 670
diff changeset
   333
  static const char *_signal3;      // reserved user-defined string
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  enum               { Not_in_list = -1 };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  void  addName(const char *name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  void  add_signal();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  void  clear();                   // Remove all entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  int   count() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  void  reset();                   // Reset iteration
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  const char *iter();              // after reset(), first element : else next
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  const char *current();           // return current element in iteration.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  bool  current_is_signal();       // Return 'true' if current entry is signal
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  bool  is_signal(const char *entry); // Return true if entry is a signal
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  bool  search(const char *);      // Search for a name in the list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  int   index(const char *);       // Return index of name in list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  const char *name (intptr_t index);// Return name at index in list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  void  dump();                    // output to stderr
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  void  output(FILE *fp);          // Output list of names to 'fp'
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  NameList();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  ~NameList();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
// Convenience class to preserve iteration state since iterators are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
// internal instead of being external.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
class PreserveIter {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  NameList* _list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  int _iter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  bool _justReset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  PreserveIter(NameList* nl) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
    _list = nl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
    _iter = _list->_iter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
    _justReset = _list->_justReset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  ~PreserveIter() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
    _list->_iter = _iter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
    _list->_justReset = _justReset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
//------------------------------NameAndList------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
// Storage for a name and an associated list of names
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
class NameAndList {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  const char *_name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  NameList    _list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  NameAndList(char *name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  ~NameAndList();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  // Add to entries in list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  void        add_entry(const char *entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  // Access the name and its associated list.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  const char *name() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  void        reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  const char *iter();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  int count() { return _list.count(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  // Return the "index" entry in the list, zero-based
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  const char *operator[](int index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  void  dump();                    // output to stderr
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  void  output(FILE *fp);          // Output list of names to 'fp'
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
//------------------------------ComponentList---------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
// Component lists always have match rule operands first, followed by parameter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
// operands which do not appear in the match list (in order of declaration).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
class ComponentList : private NameList {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  int   _matchcnt;                 // Count of match rule operands
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
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  // This is a batch program.  (And I have a destructor bug!)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  void operator delete( void *ptr ) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  void insert(Component *component, bool mflag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  void insert(const char *name, const char *opType, int usedef, bool mflag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  int  count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  int  match_count() { return _matchcnt; } // Get count of match rule opers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  Component *iter();               // after reset(), first element : else next
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  Component *match_iter();         // after reset(), first element : else next
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  Component *post_match_iter();    // after reset(), first element : else next
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  void       reset();              // Reset iteration
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  Component *current();            // return current element in iteration.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  // Return element at "position", else NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  Component *operator[](int position);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  Component *at(int position) { return (*this)[position]; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  // Return first component having this name.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  const Component *search(const char *name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  // Return number of USEs + number of DEFs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  int        num_operands();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  // Return zero-based position in list;  -1 if not in list.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  int        operand_position(const char *name, int usedef);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  // Find position for this name, regardless of use/def information
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  int        operand_position(const char *name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  // Find position for this name when looked up for output via "format"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  int        operand_position_format(const char *name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  // Find position for the Label when looked up for output via "format"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  int        label_position();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  // Find position for the Method when looked up for output via "format"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  int        method_position();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  void       dump();               // output to stderr
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  void       output(FILE *fp);     // Output list of names to 'fp'
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  ComponentList();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  ~ComponentList();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
//------------------------------SourceForm-------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
class SourceForm : public Form {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  // Public Data
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  char *_code;                     // Buffer for storing code text
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  // Public Methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  SourceForm(char* code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  ~SourceForm();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  virtual const char* classname() { return "SourceForm"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  void dump();                    // Debug printer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  void output(FILE *fp);          // Write output files
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
class HeaderForm : public SourceForm {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  HeaderForm(char* code) : SourceForm(code) { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  virtual const char* classname() { return "HeaderForm"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
class PreHeaderForm : public SourceForm {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  PreHeaderForm(char* code) : SourceForm(code) { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  virtual const char* classname() { return "PreHeaderForm"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
//------------------------------Expr------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
#define STRING_BUFFER_LENGTH  2048
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
// class Expr represents integer expressions containing constants and addition
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
// Value must be in range zero through maximum positive integer. 32bits.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
// Expected use: instruction and operand costs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
class Expr {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
    Zero     = 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
    Max      = 0x7fffffff
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  const char *_external_name;  // if !NULL, then print this instead of _expr
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  const char *_expr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  int         _min_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  int         _max_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  Expr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  Expr(const char *cost);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  Expr(const char *name, const char *expression, int min_value, int max_value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  Expr *clone() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  bool  is_unknown() const { return (this == Expr::get_unknown()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  bool  is_zero()    const { return (_min_value == Expr::Zero && _max_value == Expr::Zero); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  bool  less_than_or_equal(const Expr *c) const { return (_max_value <= c->_min_value); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  void  add(const Expr *c);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  void  add(const char *c);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  void  add(const char *c, ArchDesc &AD);   // check if 'c' is defined in <arch>.ad
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  void  set_external_name(const char *name) { _external_name = name; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  const char *as_string()  const { return (_external_name != NULL ? _external_name : _expr); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  void  print()            const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  void  print_define(FILE *fp) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  void  print_assert(FILE *fp) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  static Expr *get_unknown();   // Returns pointer to shared unknown cost instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  static char *buffer()         { return &external_buffer[0]; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
  static bool  init_buffers();  // Fill buffers with 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  static bool  check_buffers(); // if buffer use may have overflowed, assert
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  static Expr *_unknown_expr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  static char string_buffer[STRING_BUFFER_LENGTH];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  static char external_buffer[STRING_BUFFER_LENGTH];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  static bool _init_buffers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  const char *compute_expr(const Expr *c1, const Expr *c2);  // cost as string after adding 'c1' and 'c2'
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  int         compute_min (const Expr *c1, const Expr *c2);  // minimum after adding 'c1' and 'c2'
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
  int         compute_max (const Expr *c1, const Expr *c2);  // maximum after adding 'c1' and 'c2'
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
  const char *compute_external(const Expr *c1, const Expr *c2);  // external name after adding 'c1' and 'c2'
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
//------------------------------ExprDict---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
// Dictionary containing Exprs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
class ExprDict {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  Dict         _expr;              // map names, char*, to their Expr* or NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  NameList     _defines;           // record the order of definitions entered with define call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  // Disable public use of constructor, copy-ctor, operator =, operator ==
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  ExprDict( );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  ExprDict( const ExprDict & );    // Deep-copy guts
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
  ExprDict &operator =( const ExprDict & );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  // == compares two dictionaries; they must have the same keys (their keys
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  // must match using CmpKey) and they must have the same values (pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  // comparison).  If so 1 is returned, if not 0 is returned.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  bool operator ==(const ExprDict &d) const; // Compare dictionaries for equal
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  // cmp is a key comparision routine.  hash is a routine to hash a key.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  ExprDict( CmpKey cmp, Hash hash, Arena *arena );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
  ~ExprDict();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
  // Return # of key-value pairs in dict
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  int Size(void) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  // define inserts the given key-value pair into the dictionary,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  // and records the name in order for later output, ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  const Expr  *define(const char *name, Expr *expr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  // Insert inserts the given key-value pair into the dictionary.  The prior
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
  // value of the key is returned; NULL if the key was not previously defined.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  const Expr  *Insert(const char *name, Expr *expr); // A new key-value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  // Find finds the value of a given key; or NULL if not found.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  // The dictionary is NOT changed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
  const Expr  *operator [](const char *name) const;  // Do a lookup
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  void print_defines(FILE *fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
  void print_asserts(FILE *fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
  void dump();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
};