1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 1.2 +++ b/src/share/vm/adlc/forms.hpp Sat Dec 01 00:00:00 2007 +0000 1.3 @@ -0,0 +1,586 @@ 1.4 +/* 1.5 + * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved. 1.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 1.7 + * 1.8 + * This code is free software; you can redistribute it and/or modify it 1.9 + * under the terms of the GNU General Public License version 2 only, as 1.10 + * published by the Free Software Foundation. 1.11 + * 1.12 + * This code is distributed in the hope that it will be useful, but WITHOUT 1.13 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 1.14 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1.15 + * version 2 for more details (a copy is included in the LICENSE file that 1.16 + * accompanied this code). 1.17 + * 1.18 + * You should have received a copy of the GNU General Public License version 1.19 + * 2 along with this work; if not, write to the Free Software Foundation, 1.20 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 1.21 + * 1.22 + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 1.23 + * CA 95054 USA or visit www.sun.com if you need additional information or 1.24 + * have any questions. 1.25 + * 1.26 + */ 1.27 + 1.28 +// FORMS.HPP - ADL Parser Generic and Utility Forms Classes 1.29 + 1.30 +#define TRUE 1 1.31 +#define FALSE 0 1.32 + 1.33 +// DEFINITIONS OF LEGAL ATTRIBUTE TYPES 1.34 +#define INS_ATTR 0 1.35 +#define OP_ATTR 1 1.36 + 1.37 +// DEFINITIONS OF LEGAL CONSTRAINT TYPES 1.38 + 1.39 +// Class List 1.40 +class Form; 1.41 +class InstructForm; 1.42 +class MachNodeForm; 1.43 +class OperandForm; 1.44 +class OpClassForm; 1.45 +class AttributeForm; 1.46 +class RegisterForm; 1.47 +class PipelineForm; 1.48 +class SourceForm; 1.49 +class EncodeForm; 1.50 +class Component; 1.51 +class Constraint; 1.52 +class Predicate; 1.53 +class MatchRule; 1.54 +class Attribute; 1.55 +class Effect; 1.56 +class ExpandRule; 1.57 +class RewriteRule; 1.58 +class ConstructRule; 1.59 +class FormatRule; 1.60 +class Peephole; 1.61 +class EncClass; 1.62 +class Interface; 1.63 +class RegInterface; 1.64 +class ConstInterface; 1.65 +class MemInterface; 1.66 +class CondInterface; 1.67 +class Opcode; 1.68 +class InsEncode; 1.69 +class RegDef; 1.70 +class RegClass; 1.71 +class AllocClass; 1.72 +class ResourceForm; 1.73 +class PipeClassForm; 1.74 +class PeepMatch; 1.75 +class PeepConstraint; 1.76 +class PeepReplace; 1.77 +class MatchList; 1.78 + 1.79 +class ArchDesc; 1.80 + 1.81 +//------------------------------FormDict--------------------------------------- 1.82 +// Dictionary containing Forms, and objects derived from forms 1.83 +class FormDict { 1.84 +private: 1.85 + Dict _form; // map names, char*, to their Form* or NULL 1.86 + 1.87 + // Disable public use of constructor, copy-ctor, operator =, operator == 1.88 + FormDict( ); 1.89 + FormDict &operator =( const FormDict & ); 1.90 + // == compares two dictionaries; they must have the same keys (their keys 1.91 + // must match using CmpKey) and they must have the same values (pointer 1.92 + // comparison). If so 1 is returned, if not 0 is returned. 1.93 + bool operator ==(const FormDict &d) const; // Compare dictionaries for equal 1.94 + 1.95 +public: 1.96 + // cmp is a key comparision routine. hash is a routine to hash a key. 1.97 + // FormDict( CmpKey cmp, Hash hash ); 1.98 + FormDict( CmpKey cmp, Hash hash, Arena *arena ); 1.99 + FormDict( const FormDict & fd ); // Deep-copy guts 1.100 + ~FormDict(); 1.101 + 1.102 + // Return # of key-value pairs in dict 1.103 + int Size(void) const; 1.104 + 1.105 + // Insert inserts the given key-value pair into the dictionary. The prior 1.106 + // value of the key is returned; NULL if the key was not previously defined. 1.107 + const Form *Insert(const char *name, Form *form); // A new key-value 1.108 + 1.109 + // Find finds the value of a given key; or NULL if not found. 1.110 + // The dictionary is NOT changed. 1.111 + const Form *operator [](const char *name) const; // Do a lookup 1.112 + 1.113 + void dump(); 1.114 +}; 1.115 + 1.116 +// ***** Master Class for ADL Parser Forms ***** 1.117 +//------------------------------Form------------------------------------------- 1.118 +class Form { 1.119 +public: 1.120 + static Arena *arena; // arena used by forms 1.121 +private: 1.122 + static Arena *generate_arena(); // allocate arena used by forms 1.123 + 1.124 +protected: 1.125 + int _ftype; // Indicator for derived class type 1.126 + 1.127 +public: 1.128 + // Public Data 1.129 + Form *_next; // Next pointer for form lists 1.130 + long _linenum; // Line number for debugging 1.131 + 1.132 + // Dynamic type check for common forms. 1.133 + virtual OpClassForm *is_opclass() const; 1.134 + virtual OperandForm *is_operand() const; 1.135 + virtual InstructForm *is_instruction() const; 1.136 + virtual MachNodeForm *is_machnode() const; 1.137 + virtual AttributeForm *is_attribute() const; 1.138 + virtual Effect *is_effect() const; 1.139 + virtual ResourceForm *is_resource() const; 1.140 + virtual PipeClassForm *is_pipeclass() const; 1.141 + 1.142 + // Check if this form is an operand usable for cisc-spilling 1.143 + virtual bool is_cisc_reg(FormDict &globals) const { return false; } 1.144 + virtual bool is_cisc_mem(FormDict &globals) const { return false; } 1.145 + 1.146 + // Public Methods 1.147 + Form(int formType=0, int line=0) 1.148 + : _next(NULL), _linenum(line), _ftype(formType) { }; 1.149 + ~Form() {}; 1.150 + 1.151 + virtual bool ideal_only() const { 1.152 + assert(0,"Check of ideal status on non-instruction/operand form.\n"); 1.153 + return FALSE; 1.154 + } 1.155 + 1.156 + // Check constraints after parsing 1.157 + virtual bool verify() { return true; } 1.158 + 1.159 + virtual void dump() { output(stderr); } // Debug printer 1.160 + // Write info to output files 1.161 + virtual void output(FILE *fp) { fprintf(fp,"Form Output"); } 1.162 + 1.163 +public: 1.164 + // ADLC types, match the last character on ideal operands and instructions 1.165 + enum DataType { 1.166 + none = 0, // Not a simple type 1.167 + idealI = 1, // Integer type 1.168 + idealP = 2, // Pointer types, oop(s) 1.169 + idealL = 3, // Long type 1.170 + idealF = 4, // Float type 1.171 + idealD = 5, // Double type 1.172 + idealB = 6, // Byte type 1.173 + idealC = 7, // Char type 1.174 + idealS = 8 // String type 1.175 + }; 1.176 + // Convert ideal name to a DataType, return DataType::none if not a 'ConX' 1.177 + Form::DataType ideal_to_const_type(const char *ideal_type_name) const; 1.178 + // Convert ideal name to a DataType, return DataType::none if not a 'sRegX 1.179 + Form::DataType ideal_to_sReg_type(const char *name) const; 1.180 + // Convert ideal name to a DataType, return DataType::none if not a 'RegX 1.181 + Form::DataType ideal_to_Reg_type(const char *name) const; 1.182 + 1.183 + // Convert ideal name to a DataType, return DataType::none if not a 'LoadX 1.184 + Form::DataType is_load_from_memory(const char *opType) const; 1.185 + // Convert ideal name to a DataType, return DataType::none if not a 'StoreX 1.186 + Form::DataType is_store_to_memory(const char *opType) const; 1.187 + 1.188 + // ADLC call types, matched with ideal world 1.189 + enum CallType { 1.190 + invalid_type = 0, // invalid call type 1.191 + JAVA_STATIC = 1, // monomorphic entry 1.192 + JAVA_DYNAMIC = 2, // possibly megamorphic, inline cache call 1.193 + JAVA_COMPILED = 3, // callee will be compiled java 1.194 + JAVA_INTERP = 4, // callee will be executed by interpreter 1.195 + JAVA_NATIVE = 5, // native entrypoint 1.196 + JAVA_RUNTIME = 6, // runtime entrypoint 1.197 + JAVA_LEAF = 7 // calling leaf 1.198 + }; 1.199 + 1.200 + // Interface types for operands and operand classes 1.201 + enum InterfaceType { 1.202 + no_interface = 0, // unknown or inconsistent interface type 1.203 + constant_interface = 1, // interface to constants 1.204 + register_interface = 2, // interface to registers 1.205 + memory_interface = 3, // interface to memory 1.206 + conditional_interface = 4 // interface for condition codes 1.207 + }; 1.208 + virtual Form::InterfaceType interface_type(FormDict &globals) const; 1.209 + 1.210 + enum CiscSpillInfo { 1.211 + Not_cisc_spillable = AdlcVMDeps::Not_cisc_spillable, 1.212 + Maybe_cisc_spillable = 0, 1.213 + Is_cisc_spillable = 1 1.214 + // ... 1.215 + }; 1.216 + 1.217 + // LEGAL FORM TYPES 1.218 + enum { 1.219 + INS, 1.220 + OPER, 1.221 + OPCLASS, 1.222 + SRC, 1.223 + ADEF, 1.224 + REG, 1.225 + PIPE, 1.226 + CNST, 1.227 + PRED, 1.228 + ATTR, 1.229 + MAT, 1.230 + ENC, 1.231 + FOR, 1.232 + EXP, 1.233 + REW, 1.234 + EFF, 1.235 + RDEF, 1.236 + RCL, 1.237 + ACL, 1.238 + RES, 1.239 + PCL, 1.240 + PDEF, 1.241 + REGL, 1.242 + RESL, 1.243 + STAL, 1.244 + COMP, 1.245 + PEEP, 1.246 + RESO 1.247 + }; 1.248 + 1.249 +}; 1.250 + 1.251 +//------------------------------FormList--------------------------------------- 1.252 +class FormList { 1.253 +private: 1.254 + Form *_root; 1.255 + Form *_tail; 1.256 + Form *_cur; 1.257 + int _justReset; // Set immediately after reset 1.258 + Form *_cur2; // Nested iterator 1.259 + int _justReset2; 1.260 + 1.261 +public: 1.262 + void addForm(Form * entry) { 1.263 + if (_tail==NULL) { _root = _tail = _cur = entry;} 1.264 + else { _tail->_next = entry; _tail = entry;} 1.265 + }; 1.266 + Form * current() { return _cur; }; 1.267 + Form * iter() { if (_justReset) _justReset = 0; 1.268 + else if (_cur) _cur = _cur->_next; 1.269 + return _cur;}; 1.270 + void reset() { if (_root) {_cur = _root; _justReset = 1;} }; 1.271 + 1.272 + // Second iterator, state is internal 1.273 + Form * current2(){ return _cur2; }; 1.274 + Form * iter2() { if (_justReset2) _justReset2 = 0; 1.275 + else if (_cur2) _cur2 = _cur2->_next; 1.276 + return _cur2;}; 1.277 + void reset2() { if (_root) {_cur2 = _root; _justReset2 = 1;} }; 1.278 + 1.279 + int count() { 1.280 + int count = 0; reset(); 1.281 + for( Form *cur; (cur = iter()) != NULL; ) { ++count; }; 1.282 + return count; 1.283 + } 1.284 + 1.285 + void dump() { 1.286 + reset(); 1.287 + Form *cur; 1.288 + for(; (cur = iter()) != NULL; ) { 1.289 + cur->dump(); 1.290 + }; 1.291 + } 1.292 + 1.293 + bool verify() { 1.294 + bool verified = true; 1.295 + 1.296 + reset(); 1.297 + Form *cur; 1.298 + for(; (cur = iter()) != NULL; ) { 1.299 + if ( ! cur->verify() ) verified = false; 1.300 + }; 1.301 + 1.302 + return verified; 1.303 + } 1.304 + 1.305 + void output(FILE* fp) { 1.306 + reset(); 1.307 + Form *cur; 1.308 + for( ; (cur = iter()) != NULL; ) { 1.309 + cur->output(fp); 1.310 + }; 1.311 + } 1.312 + 1.313 + FormList() { _justReset = 1; _justReset2 = 1; _root = NULL; _tail = NULL; _cur = NULL; _cur2 = NULL;}; 1.314 + ~FormList(); 1.315 +}; 1.316 + 1.317 +//------------------------------NameList--------------------------------------- 1.318 +// Extendable list of pointers, <char *> 1.319 +class NameList { 1.320 + friend class PreserveIter; 1.321 + 1.322 +private: 1.323 + int _cur; // Insert next entry here; count of entries 1.324 + int _max; // Number of spaces allocated 1.325 + const char **_names; // Array of names 1.326 + 1.327 +protected: 1.328 + int _iter; // position during iteration 1.329 + bool _justReset; // Set immediately after reset 1.330 + 1.331 + 1.332 +public: 1.333 + static const char *_signal; // reserved user-defined string 1.334 + enum { Not_in_list = -1 }; 1.335 + 1.336 + void addName(const char *name); 1.337 + void add_signal(); 1.338 + void clear(); // Remove all entries 1.339 + 1.340 + int count() const; 1.341 + 1.342 + void reset(); // Reset iteration 1.343 + const char *iter(); // after reset(), first element : else next 1.344 + const char *current(); // return current element in iteration. 1.345 + 1.346 + bool current_is_signal(); // Return 'true' if current entry is signal 1.347 + bool is_signal(const char *entry); // Return true if entry is a signal 1.348 + 1.349 + bool search(const char *); // Search for a name in the list 1.350 + int index(const char *); // Return index of name in list 1.351 + const char *name (intptr_t index);// Return name at index in list 1.352 + 1.353 + void dump(); // output to stderr 1.354 + void output(FILE *fp); // Output list of names to 'fp' 1.355 + 1.356 + NameList(); 1.357 + ~NameList(); 1.358 +}; 1.359 + 1.360 + 1.361 +// Convenience class to preserve iteration state since iterators are 1.362 +// internal instead of being external. 1.363 +class PreserveIter { 1.364 + private: 1.365 + NameList* _list; 1.366 + int _iter; 1.367 + bool _justReset; 1.368 + 1.369 + public: 1.370 + PreserveIter(NameList* nl) { 1.371 + _list = nl; 1.372 + _iter = _list->_iter; 1.373 + _justReset = _list->_justReset; 1.374 + } 1.375 + ~PreserveIter() { 1.376 + _list->_iter = _iter; 1.377 + _list->_justReset = _justReset; 1.378 + } 1.379 + 1.380 +}; 1.381 + 1.382 + 1.383 +//------------------------------NameAndList------------------------------------ 1.384 +// Storage for a name and an associated list of names 1.385 +class NameAndList { 1.386 +private: 1.387 + const char *_name; 1.388 + NameList _list; 1.389 + 1.390 +public: 1.391 + NameAndList(char *name); 1.392 + ~NameAndList(); 1.393 + 1.394 + // Add to entries in list 1.395 + void add_entry(const char *entry); 1.396 + 1.397 + // Access the name and its associated list. 1.398 + const char *name() const; 1.399 + void reset(); 1.400 + const char *iter(); 1.401 + 1.402 + int count() { return _list.count(); } 1.403 + 1.404 + // Return the "index" entry in the list, zero-based 1.405 + const char *operator[](int index); 1.406 + 1.407 + 1.408 + void dump(); // output to stderr 1.409 + void output(FILE *fp); // Output list of names to 'fp' 1.410 +}; 1.411 + 1.412 +//------------------------------ComponentList--------------------------------- 1.413 +// Component lists always have match rule operands first, followed by parameter 1.414 +// operands which do not appear in the match list (in order of declaration). 1.415 +class ComponentList : private NameList { 1.416 +private: 1.417 + int _matchcnt; // Count of match rule operands 1.418 + 1.419 +public: 1.420 + 1.421 + // This is a batch program. (And I have a destructor bug!) 1.422 + void operator delete( void *ptr ) {} 1.423 + 1.424 + void insert(Component *component, bool mflag); 1.425 + void insert(const char *name, const char *opType, int usedef, bool mflag); 1.426 + 1.427 + int count(); 1.428 + int match_count() { return _matchcnt; } // Get count of match rule opers 1.429 + 1.430 + Component *iter(); // after reset(), first element : else next 1.431 + Component *match_iter(); // after reset(), first element : else next 1.432 + Component *post_match_iter(); // after reset(), first element : else next 1.433 + void reset(); // Reset iteration 1.434 + Component *current(); // return current element in iteration. 1.435 + 1.436 + // Return element at "position", else NULL 1.437 + Component *operator[](int position); 1.438 + Component *at(int position) { return (*this)[position]; } 1.439 + 1.440 + // Return first component having this name. 1.441 + const Component *search(const char *name); 1.442 + 1.443 + // Return number of USEs + number of DEFs 1.444 + int num_operands(); 1.445 + // Return zero-based position in list; -1 if not in list. 1.446 + int operand_position(const char *name, int usedef); 1.447 + // Find position for this name, regardless of use/def information 1.448 + int operand_position(const char *name); 1.449 + // Find position for this name when looked up for output via "format" 1.450 + int operand_position_format(const char *name); 1.451 + // Find position for the Label when looked up for output via "format" 1.452 + int label_position(); 1.453 + // Find position for the Method when looked up for output via "format" 1.454 + int method_position(); 1.455 + 1.456 + void dump(); // output to stderr 1.457 + void output(FILE *fp); // Output list of names to 'fp' 1.458 + 1.459 + ComponentList(); 1.460 + ~ComponentList(); 1.461 +}; 1.462 + 1.463 +//------------------------------SourceForm------------------------------------- 1.464 +class SourceForm : public Form { 1.465 +private: 1.466 + 1.467 +public: 1.468 + // Public Data 1.469 + char *_code; // Buffer for storing code text 1.470 + 1.471 + // Public Methods 1.472 + SourceForm(char* code); 1.473 + ~SourceForm(); 1.474 + 1.475 + virtual const char* classname() { return "SourceForm"; } 1.476 + 1.477 + void dump(); // Debug printer 1.478 + void output(FILE *fp); // Write output files 1.479 +}; 1.480 + 1.481 +class HeaderForm : public SourceForm { 1.482 +public: 1.483 + HeaderForm(char* code) : SourceForm(code) { } 1.484 + 1.485 + virtual const char* classname() { return "HeaderForm"; } 1.486 +}; 1.487 + 1.488 +class PreHeaderForm : public SourceForm { 1.489 +public: 1.490 + PreHeaderForm(char* code) : SourceForm(code) { } 1.491 + 1.492 + virtual const char* classname() { return "PreHeaderForm"; } 1.493 +}; 1.494 + 1.495 + 1.496 + 1.497 + 1.498 +//------------------------------Expr------------------------------------------ 1.499 +#define STRING_BUFFER_LENGTH 2048 1.500 +// class Expr represents integer expressions containing constants and addition 1.501 +// Value must be in range zero through maximum positive integer. 32bits. 1.502 +// Expected use: instruction and operand costs 1.503 +class Expr { 1.504 +public: 1.505 + enum { 1.506 + Zero = 0, 1.507 + Max = 0x7fffffff 1.508 + }; 1.509 + const char *_external_name; // if !NULL, then print this instead of _expr 1.510 + const char *_expr; 1.511 + int _min_value; 1.512 + int _max_value; 1.513 + 1.514 + Expr(); 1.515 + Expr(const char *cost); 1.516 + Expr(const char *name, const char *expression, int min_value, int max_value); 1.517 + Expr *clone() const; 1.518 + 1.519 + bool is_unknown() const { return (this == Expr::get_unknown()); } 1.520 + bool is_zero() const { return (_min_value == Expr::Zero && _max_value == Expr::Zero); } 1.521 + bool less_than_or_equal(const Expr *c) const { return (_max_value <= c->_min_value); } 1.522 + 1.523 + void add(const Expr *c); 1.524 + void add(const char *c); 1.525 + void add(const char *c, ArchDesc &AD); // check if 'c' is defined in <arch>.ad 1.526 + void set_external_name(const char *name) { _external_name = name; } 1.527 + 1.528 + const char *as_string() const { return (_external_name != NULL ? _external_name : _expr); } 1.529 + void print() const; 1.530 + void print_define(FILE *fp) const; 1.531 + void print_assert(FILE *fp) const; 1.532 + 1.533 + static Expr *get_unknown(); // Returns pointer to shared unknown cost instance 1.534 + 1.535 + static char *buffer() { return &external_buffer[0]; } 1.536 + static bool init_buffers(); // Fill buffers with 0 1.537 + static bool check_buffers(); // if buffer use may have overflowed, assert 1.538 + 1.539 +private: 1.540 + static Expr *_unknown_expr; 1.541 + static char string_buffer[STRING_BUFFER_LENGTH]; 1.542 + static char external_buffer[STRING_BUFFER_LENGTH]; 1.543 + static bool _init_buffers; 1.544 + const char *compute_expr(const Expr *c1, const Expr *c2); // cost as string after adding 'c1' and 'c2' 1.545 + int compute_min (const Expr *c1, const Expr *c2); // minimum after adding 'c1' and 'c2' 1.546 + int compute_max (const Expr *c1, const Expr *c2); // maximum after adding 'c1' and 'c2' 1.547 + const char *compute_external(const Expr *c1, const Expr *c2); // external name after adding 'c1' and 'c2' 1.548 +}; 1.549 + 1.550 +//------------------------------ExprDict--------------------------------------- 1.551 +// Dictionary containing Exprs 1.552 +class ExprDict { 1.553 +private: 1.554 + Dict _expr; // map names, char*, to their Expr* or NULL 1.555 + NameList _defines; // record the order of definitions entered with define call 1.556 + 1.557 + // Disable public use of constructor, copy-ctor, operator =, operator == 1.558 + ExprDict( ); 1.559 + ExprDict( const ExprDict & ); // Deep-copy guts 1.560 + ExprDict &operator =( const ExprDict & ); 1.561 + // == compares two dictionaries; they must have the same keys (their keys 1.562 + // must match using CmpKey) and they must have the same values (pointer 1.563 + // comparison). If so 1 is returned, if not 0 is returned. 1.564 + bool operator ==(const ExprDict &d) const; // Compare dictionaries for equal 1.565 + 1.566 +public: 1.567 + // cmp is a key comparision routine. hash is a routine to hash a key. 1.568 + ExprDict( CmpKey cmp, Hash hash, Arena *arena ); 1.569 + ~ExprDict(); 1.570 + 1.571 + // Return # of key-value pairs in dict 1.572 + int Size(void) const; 1.573 + 1.574 + // define inserts the given key-value pair into the dictionary, 1.575 + // and records the name in order for later output, ... 1.576 + const Expr *define(const char *name, Expr *expr); 1.577 + 1.578 + // Insert inserts the given key-value pair into the dictionary. The prior 1.579 + // value of the key is returned; NULL if the key was not previously defined. 1.580 + const Expr *Insert(const char *name, Expr *expr); // A new key-value 1.581 + 1.582 + // Find finds the value of a given key; or NULL if not found. 1.583 + // The dictionary is NOT changed. 1.584 + const Expr *operator [](const char *name) const; // Do a lookup 1.585 + 1.586 + void print_defines(FILE *fp); 1.587 + void print_asserts(FILE *fp); 1.588 + void dump(); 1.589 +};