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