--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/share/vm/adlc/forms.hpp	Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,586 @@
+/*
+ * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// FORMS.HPP - ADL Parser Generic and Utility Forms Classes
+
+#define TRUE 1
+#define FALSE 0
+
+// DEFINITIONS OF LEGAL ATTRIBUTE TYPES
+#define INS_ATTR 0
+#define OP_ATTR  1
+
+// DEFINITIONS OF LEGAL CONSTRAINT TYPES
+
+// Class List
+class Form;
+class InstructForm;
+class MachNodeForm;
+class OperandForm;
+class OpClassForm;
+class AttributeForm;
+class RegisterForm;
+class PipelineForm;
+class SourceForm;
+class EncodeForm;
+class Component;
+class Constraint;
+class Predicate;
+class MatchRule;
+class Attribute;
+class Effect;
+class ExpandRule;
+class RewriteRule;
+class ConstructRule;
+class FormatRule;
+class Peephole;
+class EncClass;
+class Interface;
+class RegInterface;
+class ConstInterface;
+class MemInterface;
+class CondInterface;
+class Opcode;
+class InsEncode;
+class RegDef;
+class RegClass;
+class AllocClass;
+class ResourceForm;
+class PipeClassForm;
+class PeepMatch;
+class PeepConstraint;
+class PeepReplace;
+class MatchList;
+
+class ArchDesc;
+
+//------------------------------FormDict---------------------------------------
+// Dictionary containing Forms, and objects derived from forms
+class FormDict {
+private:
+  Dict         _form;              // map names, char*, to their Form* or NULL
+
+  // Disable public use of constructor, copy-ctor, operator =, operator ==
+  FormDict( );
+  FormDict &operator =( const FormDict & );
+  // == compares two dictionaries; they must have the same keys (their keys
+  // must match using CmpKey) and they must have the same values (pointer
+  // comparison).  If so 1 is returned, if not 0 is returned.
+  bool operator ==(const FormDict &d) const; // Compare dictionaries for equal
+
+public:
+  // cmp is a key comparision routine.  hash is a routine to hash a key.
+  // FormDict( CmpKey cmp, Hash hash );
+  FormDict( CmpKey cmp, Hash hash, Arena *arena );
+  FormDict( const FormDict & fd );    // Deep-copy guts
+  ~FormDict();
+
+  // Return # of key-value pairs in dict
+  int Size(void) const;
+
+  // Insert inserts the given key-value pair into the dictionary.  The prior
+  // value of the key is returned; NULL if the key was not previously defined.
+  const Form  *Insert(const char *name, Form *form); // A new key-value
+
+  // Find finds the value of a given key; or NULL if not found.
+  // The dictionary is NOT changed.
+  const Form  *operator [](const char *name) const;  // Do a lookup
+
+  void dump();
+};
+
+// ***** Master Class for ADL Parser Forms *****
+//------------------------------Form-------------------------------------------
+class Form {
+public:
+  static Arena  *arena;            // arena used by forms
+private:
+  static Arena  *generate_arena(); // allocate arena used by forms
+
+protected:
+  int   _ftype;                    // Indicator for derived class type
+
+public:
+  // Public Data
+  Form *_next;                     // Next pointer for form lists
+  long  _linenum;                  // Line number for debugging
+
+  // Dynamic type check for common forms.
+  virtual OpClassForm   *is_opclass()     const;
+  virtual OperandForm   *is_operand()     const;
+  virtual InstructForm  *is_instruction() const;
+  virtual MachNodeForm  *is_machnode()    const;
+  virtual AttributeForm *is_attribute()   const;
+  virtual Effect        *is_effect()      const;
+  virtual ResourceForm  *is_resource()    const;
+  virtual PipeClassForm *is_pipeclass()   const;
+
+  // Check if this form is an operand usable for cisc-spilling
+  virtual bool           is_cisc_reg(FormDict &globals) const { return false; }
+  virtual bool           is_cisc_mem(FormDict &globals) const { return false; }
+
+  // Public Methods
+  Form(int formType=0, int line=0)
+    : _next(NULL), _linenum(line), _ftype(formType) { };
+  ~Form() {};
+
+  virtual bool ideal_only() const {
+    assert(0,"Check of ideal status on non-instruction/operand form.\n");
+    return FALSE;
+  }
+
+  // Check constraints after parsing
+  virtual bool verify()    { return true; }
+
+  virtual void dump()      { output(stderr); }    // Debug printer
+  // Write info to output files
+  virtual void output(FILE *fp)    { fprintf(fp,"Form Output"); }
+
+public:
+  // ADLC types, match the last character on ideal operands and instructions
+  enum DataType {
+    none        =  0,  // Not a simple type
+    idealI      =  1,  // Integer type
+    idealP      =  2,  // Pointer types, oop(s)
+    idealL      =  3,  // Long    type
+    idealF      =  4,  // Float   type
+    idealD      =  5,  // Double  type
+    idealB      =  6,  // Byte    type
+    idealC      =  7,  // Char    type
+    idealS      =  8   // String  type
+  };
+  // Convert ideal name to a DataType, return DataType::none if not a 'ConX'
+  Form::DataType  ideal_to_const_type(const char *ideal_type_name) const;
+  // Convert ideal name to a DataType, return DataType::none if not a 'sRegX
+  Form::DataType  ideal_to_sReg_type(const char *name) const;
+  // Convert ideal name to a DataType, return DataType::none if not a 'RegX
+  Form::DataType  ideal_to_Reg_type(const char *name) const;
+
+  // Convert ideal name to a DataType, return DataType::none if not a 'LoadX
+  Form::DataType is_load_from_memory(const char *opType) const;
+  // Convert ideal name to a DataType, return DataType::none if not a 'StoreX
+  Form::DataType is_store_to_memory(const char *opType)  const;
+
+  // ADLC call types, matched with ideal world
+  enum CallType {
+    invalid_type  =  0,  // invalid call type
+    JAVA_STATIC   =  1,  // monomorphic entry
+    JAVA_DYNAMIC  =  2,  // possibly megamorphic, inline cache call
+    JAVA_COMPILED =  3,  // callee will be compiled java
+    JAVA_INTERP   =  4,  // callee will be executed by interpreter
+    JAVA_NATIVE   =  5,  // native entrypoint
+    JAVA_RUNTIME  =  6,  // runtime entrypoint
+    JAVA_LEAF     =  7   // calling leaf
+  };
+
+  // Interface types for operands and operand classes
+  enum InterfaceType {
+    no_interface          =  0,  // unknown or inconsistent interface type
+    constant_interface    =  1,  // interface to constants
+    register_interface    =  2,  // interface to registers
+    memory_interface      =  3,  // interface to memory
+    conditional_interface =  4   // interface for condition codes
+  };
+  virtual Form::InterfaceType interface_type(FormDict &globals) const;
+
+  enum CiscSpillInfo {
+    Not_cisc_spillable   =  AdlcVMDeps::Not_cisc_spillable,
+    Maybe_cisc_spillable =   0,
+    Is_cisc_spillable    =   1
+    // ...
+  };
+
+  // LEGAL FORM TYPES
+  enum {
+    INS,
+    OPER,
+    OPCLASS,
+    SRC,
+    ADEF,
+    REG,
+    PIPE,
+    CNST,
+    PRED,
+    ATTR,
+    MAT,
+    ENC,
+    FOR,
+    EXP,
+    REW,
+    EFF,
+    RDEF,
+    RCL,
+    ACL,
+    RES,
+    PCL,
+    PDEF,
+    REGL,
+    RESL,
+    STAL,
+    COMP,
+    PEEP,
+    RESO
+  };
+
+};
+
+//------------------------------FormList---------------------------------------
+class FormList {
+private:
+  Form *_root;
+  Form *_tail;
+  Form *_cur;
+  int   _justReset;                // Set immediately after reset
+  Form *_cur2;                     // Nested iterator
+  int   _justReset2;
+
+public:
+  void addForm(Form * entry) {
+    if (_tail==NULL) { _root = _tail = _cur = entry;}
+    else { _tail->_next = entry; _tail = entry;}
+  };
+  Form * current() { return _cur; };
+  Form * iter()    { if (_justReset) _justReset = 0;
+                     else if (_cur)  _cur = _cur->_next;
+                     return _cur;};
+  void   reset()   { if (_root) {_cur = _root; _justReset = 1;} };
+
+  // Second iterator, state is internal
+  Form * current2(){ return _cur2; };
+  Form * iter2()   { if (_justReset2) _justReset2 = 0;
+                    else if (_cur2)  _cur2 = _cur2->_next;
+                    return _cur2;};
+  void   reset2()  { if (_root) {_cur2 = _root; _justReset2 = 1;} };
+
+  int  count() {
+    int  count = 0; reset();
+    for( Form *cur; (cur =  iter()) != NULL; ) { ++count; };
+    return count;
+  }
+
+  void dump() {
+    reset();
+    Form *cur;
+    for(; (cur =  iter()) != NULL; ) {
+      cur->dump();
+    };
+  }
+
+  bool verify() {
+    bool verified = true;
+
+    reset();
+    Form *cur;
+    for(; (cur =  iter()) != NULL; ) {
+      if ( ! cur->verify() ) verified = false;
+    };
+
+    return verified;
+  }
+
+  void output(FILE* fp) {
+    reset();
+    Form *cur;
+    for( ; (cur =  iter()) != NULL; ) {
+      cur->output(fp);
+    };
+  }
+
+  FormList() { _justReset = 1; _justReset2 = 1; _root = NULL; _tail = NULL; _cur = NULL; _cur2 = NULL;};
+  ~FormList();
+};
+
+//------------------------------NameList---------------------------------------
+// Extendable list of pointers, <char *>
+class NameList {
+  friend class PreserveIter;
+
+private:
+  int                _cur;         // Insert next entry here; count of entries
+  int                _max;         // Number of spaces allocated
+  const char       **_names;       // Array of names
+
+protected:
+  int                _iter;        // position during iteration
+  bool               _justReset;   // Set immediately after reset
+
+
+public:
+  static const char *_signal;      // reserved user-defined string
+  enum               { Not_in_list = -1 };
+
+  void  addName(const char *name);
+  void  add_signal();
+  void  clear();                   // Remove all entries
+
+  int   count() const;
+
+  void  reset();                   // Reset iteration
+  const char *iter();              // after reset(), first element : else next
+  const char *current();           // return current element in iteration.
+
+  bool  current_is_signal();       // Return 'true' if current entry is signal
+  bool  is_signal(const char *entry); // Return true if entry is a signal
+
+  bool  search(const char *);      // Search for a name in the list
+  int   index(const char *);       // Return index of name in list
+  const char *name (intptr_t index);// Return name at index in list
+
+  void  dump();                    // output to stderr
+  void  output(FILE *fp);          // Output list of names to 'fp'
+
+  NameList();
+  ~NameList();
+};
+
+
+// Convenience class to preserve iteration state since iterators are
+// internal instead of being external.
+class PreserveIter {
+ private:
+  NameList* _list;
+  int _iter;
+  bool _justReset;
+
+ public:
+  PreserveIter(NameList* nl) {
+    _list = nl;
+    _iter = _list->_iter;
+    _justReset = _list->_justReset;
+  }
+  ~PreserveIter() {
+    _list->_iter = _iter;
+    _list->_justReset = _justReset;
+  }
+
+};
+
+
+//------------------------------NameAndList------------------------------------
+// Storage for a name and an associated list of names
+class NameAndList {
+private:
+  const char *_name;
+  NameList    _list;
+
+public:
+  NameAndList(char *name);
+  ~NameAndList();
+
+  // Add to entries in list
+  void        add_entry(const char *entry);
+
+  // Access the name and its associated list.
+  const char *name() const;
+  void        reset();
+  const char *iter();
+
+  int count() { return _list.count(); }
+
+  // Return the "index" entry in the list, zero-based
+  const char *operator[](int index);
+
+
+  void  dump();                    // output to stderr
+  void  output(FILE *fp);          // Output list of names to 'fp'
+};
+
+//------------------------------ComponentList---------------------------------
+// Component lists always have match rule operands first, followed by parameter
+// operands which do not appear in the match list (in order of declaration).
+class ComponentList : private NameList {
+private:
+  int   _matchcnt;                 // Count of match rule operands
+
+public:
+
+  // This is a batch program.  (And I have a destructor bug!)
+  void operator delete( void *ptr ) {}
+
+  void insert(Component *component, bool mflag);
+  void insert(const char *name, const char *opType, int usedef, bool mflag);
+
+  int  count();
+  int  match_count() { return _matchcnt; } // Get count of match rule opers
+
+  Component *iter();               // after reset(), first element : else next
+  Component *match_iter();         // after reset(), first element : else next
+  Component *post_match_iter();    // after reset(), first element : else next
+  void       reset();              // Reset iteration
+  Component *current();            // return current element in iteration.
+
+  // Return element at "position", else NULL
+  Component *operator[](int position);
+  Component *at(int position) { return (*this)[position]; }
+
+  // Return first component having this name.
+  const Component *search(const char *name);
+
+  // Return number of USEs + number of DEFs
+  int        num_operands();
+  // Return zero-based position in list;  -1 if not in list.
+  int        operand_position(const char *name, int usedef);
+  // Find position for this name, regardless of use/def information
+  int        operand_position(const char *name);
+  // Find position for this name when looked up for output via "format"
+  int        operand_position_format(const char *name);
+  // Find position for the Label when looked up for output via "format"
+  int        label_position();
+  // Find position for the Method when looked up for output via "format"
+  int        method_position();
+
+  void       dump();               // output to stderr
+  void       output(FILE *fp);     // Output list of names to 'fp'
+
+  ComponentList();
+  ~ComponentList();
+};
+
+//------------------------------SourceForm-------------------------------------
+class SourceForm : public Form {
+private:
+
+public:
+  // Public Data
+  char *_code;                     // Buffer for storing code text
+
+  // Public Methods
+  SourceForm(char* code);
+  ~SourceForm();
+
+  virtual const char* classname() { return "SourceForm"; }
+
+  void dump();                    // Debug printer
+  void output(FILE *fp);          // Write output files
+};
+
+class HeaderForm : public SourceForm {
+public:
+  HeaderForm(char* code) : SourceForm(code) { }
+
+  virtual const char* classname() { return "HeaderForm"; }
+};
+
+class PreHeaderForm : public SourceForm {
+public:
+  PreHeaderForm(char* code) : SourceForm(code) { }
+
+  virtual const char* classname() { return "PreHeaderForm"; }
+};
+
+
+
+
+//------------------------------Expr------------------------------------------
+#define STRING_BUFFER_LENGTH  2048
+// class Expr represents integer expressions containing constants and addition
+// Value must be in range zero through maximum positive integer. 32bits.
+// Expected use: instruction and operand costs
+class Expr {
+public:
+  enum {
+    Zero     = 0,
+    Max      = 0x7fffffff
+  };
+  const char *_external_name;  // if !NULL, then print this instead of _expr
+  const char *_expr;
+  int         _min_value;
+  int         _max_value;
+
+  Expr();
+  Expr(const char *cost);
+  Expr(const char *name, const char *expression, int min_value, int max_value);
+  Expr *clone() const;
+
+  bool  is_unknown() const { return (this == Expr::get_unknown()); }
+  bool  is_zero()    const { return (_min_value == Expr::Zero && _max_value == Expr::Zero); }
+  bool  less_than_or_equal(const Expr *c) const { return (_max_value <= c->_min_value); }
+
+  void  add(const Expr *c);
+  void  add(const char *c);
+  void  add(const char *c, ArchDesc &AD);   // check if 'c' is defined in <arch>.ad
+  void  set_external_name(const char *name) { _external_name = name; }
+
+  const char *as_string()  const { return (_external_name != NULL ? _external_name : _expr); }
+  void  print()            const;
+  void  print_define(FILE *fp) const;
+  void  print_assert(FILE *fp) const;
+
+  static Expr *get_unknown();   // Returns pointer to shared unknown cost instance
+
+  static char *buffer()         { return &external_buffer[0]; }
+  static bool  init_buffers();  // Fill buffers with 0
+  static bool  check_buffers(); // if buffer use may have overflowed, assert
+
+private:
+  static Expr *_unknown_expr;
+  static char string_buffer[STRING_BUFFER_LENGTH];
+  static char external_buffer[STRING_BUFFER_LENGTH];
+  static bool _init_buffers;
+  const char *compute_expr(const Expr *c1, const Expr *c2);  // cost as string after adding 'c1' and 'c2'
+  int         compute_min (const Expr *c1, const Expr *c2);  // minimum after adding 'c1' and 'c2'
+  int         compute_max (const Expr *c1, const Expr *c2);  // maximum after adding 'c1' and 'c2'
+  const char *compute_external(const Expr *c1, const Expr *c2);  // external name after adding 'c1' and 'c2'
+};
+
+//------------------------------ExprDict---------------------------------------
+// Dictionary containing Exprs
+class ExprDict {
+private:
+  Dict         _expr;              // map names, char*, to their Expr* or NULL
+  NameList     _defines;           // record the order of definitions entered with define call
+
+  // Disable public use of constructor, copy-ctor, operator =, operator ==
+  ExprDict( );
+  ExprDict( const ExprDict & );    // Deep-copy guts
+  ExprDict &operator =( const ExprDict & );
+  // == compares two dictionaries; they must have the same keys (their keys
+  // must match using CmpKey) and they must have the same values (pointer
+  // comparison).  If so 1 is returned, if not 0 is returned.
+  bool operator ==(const ExprDict &d) const; // Compare dictionaries for equal
+
+public:
+  // cmp is a key comparision routine.  hash is a routine to hash a key.
+  ExprDict( CmpKey cmp, Hash hash, Arena *arena );
+  ~ExprDict();
+
+  // Return # of key-value pairs in dict
+  int Size(void) const;
+
+  // define inserts the given key-value pair into the dictionary,
+  // and records the name in order for later output, ...
+  const Expr  *define(const char *name, Expr *expr);
+
+  // Insert inserts the given key-value pair into the dictionary.  The prior
+  // value of the key is returned; NULL if the key was not previously defined.
+  const Expr  *Insert(const char *name, Expr *expr); // A new key-value
+
+  // Find finds the value of a given key; or NULL if not found.
+  // The dictionary is NOT changed.
+  const Expr  *operator [](const char *name) const;  // Do a lookup
+
+  void print_defines(FILE *fp);
+  void print_asserts(FILE *fp);
+  void dump();
+};