/*

 * 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;