diff -r fd16c54261b3 -r 489c9b5090e2 hotspot/src/share/vm/adlc/archDesc.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/hotspot/src/share/vm/adlc/archDesc.hpp Sat Dec 01 00:00:00 2007 +0000 @@ -0,0 +1,389 @@ +/* + * 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. + * + */ + +// Definitions for Error Flags +#define WARN 0 +#define SYNERR 1 +#define SEMERR 2 +#define INTERNAL_ERR 3 + +// Minimal declarations for include files +class OutputMap; +class ProductionState; +class Expr; + +// STRUCTURE FOR HANDLING INPUT AND OUTPUT FILES +typedef BufferedFile ADLFILE; + +//---------------------------ChainList----------------------------------------- +class ChainList { + NameList _name; + NameList _cost; + NameList _rule; + +public: + void insert(const char *name, const char *cost, const char *rule); + bool search(const char *name); + + void reset(); + bool iter(const char * &name, const char * &cost, const char * &rule); + + void dump(); + void output(FILE *fp); + + ChainList(); + ~ChainList(); +}; + +//---------------------------MatchList----------------------------------------- +class MatchList { +private: + MatchList *_next; + Predicate *_pred; // Predicate which applies to this match rule + const char *_cost; + +public: + const char *_opcode; + const char *_resultStr; + const char *_lchild; + const char *_rchild; + + MatchList(MatchList *nxt, Predicate *prd): _next(nxt), _pred(prd), _cost(NULL){ + _resultStr = _lchild = _rchild = _opcode = NULL; } + + MatchList(MatchList *nxt, Predicate *prd, const char *cost, + const char *opcode, const char *resultStr, const char *lchild, + const char *rchild) + : _next(nxt), _pred(prd), _cost(cost), _opcode(opcode), + _resultStr(resultStr), _lchild(lchild), _rchild(rchild) { } + + MatchList *get_next(void) { return _next; } + char *get_pred(void) { return (_pred?_pred->_pred:NULL); } + Predicate *get_pred_obj(void) { return _pred; } + const char *get_cost(void) { return _cost == NULL ? "0" :_cost; } + bool search(const char *opc, const char *res, const char *lch, + const char *rch, Predicate *pr); + + void dump(); + void output(FILE *fp); +}; + +//---------------------------ArchDesc------------------------------------------ +class ArchDesc { +private: + FormDict _globalNames; // Global names + Dict _idealIndex; // Map ideal names to index in enumeration + ExprDict _globalDefs; // Global definitions, #defines + int _internalOpCounter; // Internal Operand Counter + + FormList _header; // List of Source Code Forms for hpp file + FormList _pre_header; // ditto for the very top of the hpp file + FormList _source; // List of Source Code Forms for output + FormList _instructions; // List of Instruction Forms for output + FormList _machnodes; // List of Node Classes (special for pipelining) + FormList _operands; // List of Operand Forms for output + FormList _opclass; // List of Operand Class Forms for output + FormList _attributes; // List of Attribute Forms for parsing + RegisterForm *_register; // Only one Register Form allowed + FrameForm *_frame; // Describe stack-frame layout + EncodeForm *_encode; // Only one Encode Form allowed + PipelineForm *_pipeline; // Pipeline Form for output + + bool _has_match_rule[_last_opcode]; // found AD rule for ideal node in .ad + + MatchList *_mlistab[_last_opcode]; // Array of MatchLists + + // The Architecture Description identifies which user-defined operand can be used + // to access [stack_pointer + offset] + OperandForm *_cisc_spill_operand; + + // Methods for outputting the DFA + void gen_match(FILE *fp, MatchList &mlist, ProductionState &status, Dict &operands_chained_from); + void chain_rule(FILE *fp, const char *indent, const char *ideal, + const Expr *icost, const char *irule, + Dict &operands_chained_from, ProductionState &status); + void chain_rule_c(FILE *fp, char *indent, char *ideal, char *irule); // %%%%% TODO: remove this + void expand_opclass(FILE *fp, const char *indent, const Expr *cost, + const char *result_type, ProductionState &status); + Expr *calc_cost(FILE *fp, const char *spaces, MatchList &mList, ProductionState &status); + void prune_matchlist(Dict &minimize, MatchList &mlist); + + // Helper function that outputs code to generate an instruction in MachNodeGenerator + void buildMachNode(FILE *fp_cpp, InstructForm *inst, const char *indent); + +public: + ArchDesc(); + ~ArchDesc(); + + // Option flags which control miscellaneous behaviors throughout the code + int _TotalLines; // Line Counter + int _no_output; // Flag to disable output of DFA, etc. + int _quiet_mode; // Do not output banner messages, etc. + int _disable_warnings; // Do not output warning messages + int _dfa_debug; // Debug Flag for generated DFA + int _dfa_small; // Debug Flag for generated DFA + int _adl_debug; // Debug Flag for ADLC + int _adlocation_debug; // Debug Flag to use ad file locations + bool _cisc_spill_debug; // Debug Flag to see cisc-spill-instructions + bool _short_branch_debug; // Debug Flag to see short branch instructions + + // Error/Warning Counts + int _syntax_errs; // Count of syntax errors + int _semantic_errs; // Count of semantic errors + int _warnings; // Count warnings + int _internal_errs; // Count of internal errors + + // Accessor for private data. + void has_match_rule(int opc, const bool b) { _has_match_rule[opc] = b; } + + // I/O Files + ADLFILE _ADL_file; // Input Architecture Description File + // Machine dependent files, built from architecture definition + ADLFILE _DFA_file; // File for definition of Matcher::DFA + ADLFILE _HPP_file; // File for ArchNode class declarations + ADLFILE _CPP_file; // File for ArchNode class defintions + ADLFILE _CPP_CLONE_file; // File for MachNode/Oper clone defintions + ADLFILE _CPP_EXPAND_file; // File for MachNode expand methods + ADLFILE _CPP_FORMAT_file; // File for MachNode/Oper format defintions + ADLFILE _CPP_GEN_file; // File for MachNode/Oper generator methods + ADLFILE _CPP_MISC_file; // File for miscellaneous MachNode/Oper tables & methods + ADLFILE _CPP_PEEPHOLE_file; // File for MachNode peephole methods + ADLFILE _CPP_PIPELINE_file; // File for MachNode pipeline defintions + ADLFILE _VM_file; // File for constants needed in VM code + ADLFILE _bug_file; // DFA debugging file + + // I/O helper methods + int open_file(bool required, ADLFILE & adf, const char *action); + void close_file(int delete_out, ADLFILE & adf); + int open_files(void); + void close_files(int delete_out); + + Dict _chainRules; // Maps user operand names to ChainRules + Dict _internalOps; // Maps match strings to internal operand names + NameList _internalOpNames; // List internal operand names + Dict _internalMatch; // Map internal name to its MatchNode + + NameList _preproc_list; // Preprocessor flag names + FormDict _preproc_table;// Preprocessor flag bindings + char* get_preproc_def(const char* flag); + void set_preproc_def(const char* flag, const char* def); + + FormDict& globalNames() {return _globalNames;} // map global names to forms + void initKeywords(FormDict& globals); // Add keywords to global name table + + ExprDict& globalDefs() {return _globalDefs;} // map global names to expressions + + OperandForm *constructOperand(const char *ident, bool ideal_only); + void initBaseOpTypes(); // Import predefined base types. + + void addForm(PreHeaderForm *ptr); // Add objects to pre-header list + void addForm(HeaderForm *ptr); // Add objects to header list + void addForm(SourceForm *ptr); // Add objects to source list + void addForm(EncodeForm *ptr); // Add objects to encode list + void addForm(InstructForm *ptr); // Add objects to the instruct list + void addForm(OperandForm *ptr); // Add objects to the operand list + void addForm(OpClassForm *ptr); // Add objects to the opclasss list + void addForm(AttributeForm *ptr); // Add objects to the attributes list + void addForm(RegisterForm *ptr); // Add objects to the register list + void addForm(FrameForm *ptr); // Add objects to the frame list + void addForm(PipelineForm *ptr); // Add objects to the pipeline list + void addForm(MachNodeForm *ptr); // Add objects to the machnode list + + int operandFormCount(); // Count number of OperandForms defined + int opclassFormCount(); // Count number of OpClassForms defined + int instructFormCount(); // Count number of InstructForms defined + + inline void getForm(EncodeForm **ptr) { *ptr = _encode; } + + bool verify(); + void dump(); + + // Helper utility that gets MatchList components from inside MatchRule + void check_optype(MatchRule *mrule); + void build_chain_rule(OperandForm *oper); + void add_chain_rule_entry(const char *src, const char *cost, + const char *result); + const char *getMatchListIndex(MatchRule &mrule); + void generateMatchLists(); // Build MatchList array and populate it + void inspectOperands(); // Build MatchLists for all operands + void inspectOpClasses(); // Build MatchLists for all operands + void inspectInstructions(); // Build MatchLists for all operands + void buildDFA(FILE *fp); // Driver for constructing the DFA + void gen_dfa_state_body(FILE *fp, Dict &minmize, ProductionState &status, Dict &chained, int i); // Driver for constructing the DFA state bodies + + // Helper utilities to generate reduction maps for internal operands + const char *reduceLeft (char *internalName); + const char *reduceRight(char *internalName); + + // Build enumerations, (1) dense operand index, (2) operands and opcodes + const char *machOperEnum(const char *opName); // create dense index names using static function + static const char *getMachOperEnum(const char *opName);// create dense index name + void buildMachOperEnum(FILE *fp_hpp);// dense enumeration for operands + void buildMachOpcodesEnum(FILE *fp_hpp);// enumeration for MachOpers & MachNodes + + // Helper utilities to generate Register Masks + RegisterForm *get_registers() { return _register; } + const char *reg_mask(OperandForm &opForm); + const char *reg_mask(InstructForm &instForm); + const char *reg_class_to_reg_mask(const char *reg_class); + char *stack_or_reg_mask(OperandForm &opForm); // name of cisc_spillable version + // This register class should also generate a stack_or_reg_mask + void set_stack_or_reg(const char *reg_class_name); // for cisc-spillable reg classes + // Generate an enumeration of register mask names and the RegMask objects. + void declare_register_masks(FILE *fp_cpp); + void build_register_masks(FILE *fp_cpp); + // Generate enumeration of machine register numbers + void buildMachRegisterNumbers(FILE *fp_hpp); + // Generate enumeration of machine register encodings + void buildMachRegisterEncodes(FILE *fp_hpp); + // Generate Regsiter Size Array + void declareRegSizes(FILE *fp_hpp); + // Generate Pipeline Class information + void declare_pipe_classes(FILE *fp_hpp); + // Generate Pipeline definitions + void build_pipeline_enums(FILE *fp_cpp); + // Generate Pipeline Class information + void build_pipe_classes(FILE *fp_cpp); + + // Declare and define mappings from rules to result and input types + void build_map(OutputMap &map); + void buildReduceMaps(FILE *fp_hpp, FILE *fp_cpp); + // build flags for signaling that our machine needs this instruction cloned + void buildMustCloneMap(FILE *fp_hpp, FILE *fp_cpp); + + // output SUN copyright info + void addSunCopyright(char* legal, int size, FILE *fp); + // output #include declarations for machine specific files + void machineDependentIncludes(ADLFILE &adlfile); + // Output C preprocessor code to verify the backend compilation environment. + void addPreprocessorChecks(FILE *fp); + // Output C source and header (source_hpp) blocks. + void addPreHeaderBlocks(FILE *fp_hpp); + void addHeaderBlocks(FILE *fp_hpp); + void addSourceBlocks(FILE *fp_cpp); + void generate_adlc_verification(FILE *fp_cpp); + + // output declaration of class State + void defineStateClass(FILE *fp); + + // Generator for MachOper objects given integer type + void buildMachOperGenerator(FILE *fp_cpp); + // Generator for MachNode objects given integer type + void buildMachNodeGenerator(FILE *fp_cpp); + + // Generator for Expand methods for instructions with expand rules + void defineExpand(FILE *fp, InstructForm *node); + // Generator for Peephole methods for instructions with peephole rules + void definePeephole(FILE *fp, InstructForm *node); + // Generator for Size methods for instructions + void defineSize(FILE *fp, InstructForm &node); + // Generator for Emit methods for instructions + void defineEmit(FILE *fp, InstructForm &node); + // Define a MachOper encode method + void define_oper_interface(FILE *fp, OperandForm &oper, FormDict &globals, + const char *name, const char *encoding); + + // Methods to construct the MachNode class hierarchy + // Return the type signature for the ideal operation + const char *getIdealType(const char *idealOp); + // Declare and define the classes derived from MachOper and MachNode + void declareClasses(FILE *fp_hpp); + void defineClasses(FILE *fp_cpp); + + // Emit an ADLC message + void internal_err( const char *fmt, ...); + void syntax_err ( int lineno, const char *fmt, ...); + int emit_msg(int quiet, int flag, int linenum, const char *fmt, + va_list args); + + // Generator for has_match_rule methods + void buildInstructMatchCheck(FILE *fp_cpp) const; + + // Generator for Frame Methods + void buildFrameMethods(FILE *fp_cpp); + + // Generate CISC_spilling oracle and MachNode::cisc_spill() methods + void build_cisc_spill_instructions(FILE *fp_hpp, FILE *fp_cpp); + void identify_cisc_spill_instructions(); + void identify_short_branches(); + void identify_unique_operands(); + void set_cisc_spill_operand(OperandForm *opForm) { _cisc_spill_operand = opForm; } + OperandForm *cisc_spill_operand() { return _cisc_spill_operand; } + bool can_cisc_spill() { return _cisc_spill_operand != NULL; } + + +protected: + // build MatchList from MatchRule + void buildMatchList(MatchRule *mrule, const char *resultStr, + const char *rootOp, Predicate *pred, const char *cost); + + void buildMList(MatchNode *node, const char *rootOp, const char *resultOp, + Predicate *pred, const char *cost); + + friend class ADLParser; + +}; + + +// -------------------------------- maps ------------------------------------ + +// Base class for generating a mapping from rule number to value. +// Used with ArchDesc::build_map() for all maps except "enum MachOperands" +// A derived class defines the appropriate output for a specific mapping. +class OutputMap { +protected: + FILE *_hpp; + FILE *_cpp; + FormDict &_globals; + ArchDesc &_AD; +public: + OutputMap (FILE *decl_file, FILE *def_file, FormDict &globals, ArchDesc &AD) + : _hpp(decl_file), _cpp(def_file), _globals(globals), _AD(AD) {}; + // Access files used by this routine + FILE *decl_file() { return _hpp; } + FILE *def_file() { return _cpp; } + // Positions in iteration that derived class will be told about + enum position { BEGIN_OPERANDS, + BEGIN_OPCLASSES, + BEGIN_INTERNALS, + BEGIN_INSTRUCTIONS, + BEGIN_INST_CHAIN_RULES, + END_INST_CHAIN_RULES, + BEGIN_REMATERIALIZE, + END_REMATERIALIZE, + END_INSTRUCTIONS + }; + // Output routines specific to the derived class + virtual void declaration() {} + virtual void definition() {} + virtual void closing() { fprintf(_cpp, "};\n"); } + virtual void map(OperandForm &oper) { } + virtual void map(OpClassForm &opc) { } + virtual void map(char *internal_name) { } + // Allow enum-MachOperands to turn-off instructions + virtual bool do_instructions() { return true; } + virtual void map(InstructForm &inst) { } + // Allow derived class to output name and position specific info + virtual void record_position(OutputMap::position place, int index) {} +};