1 /*
   2  * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_ADLC_ARCHDESC_HPP
  26 #define SHARE_VM_ADLC_ARCHDESC_HPP
  27 
  28 // Definitions for Error Flags
  29 #define  WARN   0
  30 #define  SYNERR 1
  31 #define  SEMERR 2
  32 #define  INTERNAL_ERR 3
  33 
  34 // Minimal declarations for include files
  35 class  OutputMap;
  36 class  ProductionState;
  37 class  Expr;
  38 
  39 // STRUCTURE FOR HANDLING INPUT AND OUTPUT FILES
  40 typedef BufferedFile ADLFILE;
  41 
  42 //---------------------------ChainList-----------------------------------------
  43 class ChainList {
  44   NameList _name;
  45   NameList _cost;
  46   NameList _rule;
  47 
  48 public:
  49   void insert(const char *name, const char *cost, const char *rule);
  50   bool search(const char *name);
  51 
  52   void reset();
  53   bool iter(const char * &name, const char * &cost, const char * &rule);
  54 
  55   void dump();
  56   void output(FILE *fp);
  57 
  58   ChainList();
  59   ~ChainList();
  60 };
  61 
  62 //---------------------------MatchList-----------------------------------------
  63 class MatchList {
  64 private:
  65   MatchList  *_next;
  66   Predicate  *_pred;          // Predicate which applies to this match rule
  67   const char *_cost;
  68 
  69 public:
  70   const char *_opcode;
  71   const char *_resultStr;
  72   const char *_lchild;
  73   const char *_rchild;
  74 
  75   MatchList(MatchList *nxt, Predicate *prd): _next(nxt), _pred(prd), _cost(NULL){
  76     _resultStr = _lchild = _rchild = _opcode = NULL; }
  77 
  78   MatchList(MatchList *nxt, Predicate *prd, const char *cost,
  79             const char *opcode, const char *resultStr, const char *lchild,
  80             const char *rchild)
  81     : _next(nxt), _pred(prd), _cost(cost), _opcode(opcode),
  82       _resultStr(resultStr), _lchild(lchild), _rchild(rchild) { }
  83 
  84   MatchList  *get_next(void)  { return _next; }
  85   char       *get_pred(void)  { return (_pred?_pred->_pred:NULL); }
  86   Predicate  *get_pred_obj(void)  { return _pred; }
  87   const char *get_cost(void) { return _cost == NULL ? "0" :_cost; }
  88   bool        search(const char *opc, const char *res, const char *lch,
  89                     const char *rch, Predicate *pr);
  90 
  91   void        dump();
  92   void        output(FILE *fp);
  93 };
  94 
  95 //---------------------------ArchDesc------------------------------------------
  96 class ArchDesc {
  97 private:
  98   FormDict      _globalNames;        // Global names
  99   Dict          _idealIndex;         // Map ideal names to index in enumeration
 100   ExprDict      _globalDefs;         // Global definitions, #defines
 101   int           _internalOpCounter;  // Internal Operand Counter
 102 
 103   FormList      _header;             // List of Source Code Forms for hpp file
 104   FormList      _pre_header;         // ditto for the very top of the hpp file
 105   FormList      _source;             // List of Source Code Forms for output
 106   FormList      _instructions;       // List of Instruction Forms for output
 107   FormList      _machnodes;          // List of Node Classes (special for pipelining)
 108   FormList      _operands;           // List of Operand Forms for output
 109   FormList      _opclass;            // List of Operand Class Forms for output
 110   FormList      _attributes;         // List of Attribute Forms for parsing
 111   RegisterForm *_register;           // Only one Register Form allowed
 112   FrameForm    *_frame;              // Describe stack-frame layout
 113   EncodeForm   *_encode;             // Only one Encode Form allowed
 114   PipelineForm *_pipeline;           // Pipeline Form for output
 115 
 116   bool _has_match_rule[static_cast<uint>(Opcodes::_last_opcode)];  // found AD rule for ideal node in <arch>.ad
 117 
 118   MatchList    *_mlistab[static_cast<uint>(Opcodes::_last_opcode)]; // Array of MatchLists
 119 
 120   // The Architecture Description identifies which user-defined operand can be used
 121   // to access [stack_pointer + offset]
 122   OperandForm  *_cisc_spill_operand;
 123 
 124   // If a Call node uses $constanttablebase, it gets MachConstantBaseNode
 125   // by the matcher and the matcher will modify the jvms. If so, jvm states
 126   // always have to be cloned when a node is cloned.  Adlc generates
 127   // Compile::needs_clone_jvms() accordingly.
 128   bool _needs_clone_jvms;
 129 
 130   // Methods for outputting the DFA
 131   void gen_match(FILE *fp, MatchList &mlist, ProductionState &status, Dict &operands_chained_from);
 132   void chain_rule(FILE *fp, const char *indent, const char *ideal,
 133                   const Expr *icost, const char *irule,
 134                   Dict &operands_chained_from, ProductionState &status);
 135   void expand_opclass(FILE *fp, const char *indent, const Expr *cost,
 136                       const char *result_type, ProductionState &status);
 137   Expr *calc_cost(FILE *fp, const char *spaces, MatchList &mList, ProductionState &status);
 138   void prune_matchlist(Dict &minimize, MatchList &mlist);
 139 
 140   // Helper function that outputs code to generate an instruction in MachNodeGenerator
 141   void buildMachNode(FILE *fp_cpp, InstructForm *inst, const char *indent);
 142 
 143 public:
 144   ArchDesc();
 145   ~ArchDesc();
 146 
 147   // Option flags which control miscellaneous behaviors throughout the code
 148   int   _TotalLines;                    // Line Counter
 149   int   _no_output;                     // Flag to disable output of DFA, etc.
 150   int   _quiet_mode;                    // Do not output banner messages, etc.
 151   int   _disable_warnings;              // Do not output warning messages
 152   int   _dfa_debug;                     // Debug Flag for generated DFA
 153   int   _dfa_small;                     // Debug Flag for generated DFA
 154   int   _adl_debug;                     // Debug Flag for ADLC
 155   int   _adlocation_debug;              // Debug Flag to use ad file locations
 156   bool  _cisc_spill_debug;              // Debug Flag to see cisc-spill-instructions
 157   bool  _short_branch_debug;            // Debug Flag to see short branch instructions
 158 
 159   // Error/Warning Counts
 160   int _syntax_errs;                  // Count of syntax errors
 161   int _semantic_errs;                // Count of semantic errors
 162   int _warnings;                     // Count warnings
 163   int _internal_errs;                // Count of internal errors
 164 
 165   // Accessor for private data.
 166   void has_match_rule(int opc, const bool b) { _has_match_rule[opc] = b; }
 167 
 168   // I/O Files
 169   ADLFILE  _ADL_file;          // Input Architecture Description File
 170   // Machine dependent files, built from architecture definition
 171   ADLFILE  _DFA_file;          // File for definition of Matcher::DFA
 172   ADLFILE  _HPP_file;          // File for ArchNode class declarations
 173   ADLFILE  _CPP_file;          // File for ArchNode class defintions
 174   ADLFILE  _CPP_CLONE_file;    // File for MachNode/Oper clone defintions
 175   ADLFILE  _CPP_EXPAND_file;   // File for MachNode expand methods
 176   ADLFILE  _CPP_FORMAT_file;   // File for MachNode/Oper format defintions
 177   ADLFILE  _CPP_GEN_file;      // File for MachNode/Oper generator methods
 178   ADLFILE  _CPP_MISC_file;     // File for miscellaneous MachNode/Oper tables & methods
 179   ADLFILE  _CPP_PEEPHOLE_file; // File for MachNode peephole methods
 180   ADLFILE  _CPP_PIPELINE_file; // File for MachNode pipeline defintions
 181   ADLFILE  _VM_file;           // File for constants needed in VM code
 182   ADLFILE  _bug_file;          // DFA debugging file
 183 
 184   // I/O helper methods
 185   int  open_file(bool required, ADLFILE & adf, const char *action);
 186   void close_file(int delete_out, ADLFILE & adf);
 187   int  open_files(void);
 188   void close_files(int delete_out);
 189 
 190   Dict _chainRules;            // Maps user operand names to ChainRules
 191   Dict _internalOps;           // Maps match strings to internal operand names
 192   NameList _internalOpNames;   // List internal operand names
 193   Dict _internalMatch;         // Map internal name to its MatchNode
 194 
 195   NameList      _preproc_list; // Preprocessor flag names
 196   FormDict      _preproc_table;// Preprocessor flag bindings
 197   char* get_preproc_def(const char* flag);
 198   void  set_preproc_def(const char* flag, const char* def);
 199 
 200   FormDict& globalNames() {return _globalNames;} // map global names to forms
 201   void initKeywords(FormDict& globals);  // Add keywords to global name table
 202 
 203   ExprDict& globalDefs()  {return _globalDefs;}  // map global names to expressions
 204 
 205   OperandForm *constructOperand(const char *ident, bool ideal_only);
 206   void initBaseOpTypes();            // Import predefined base types.
 207 
 208   void addForm(PreHeaderForm *ptr);  // Add objects to pre-header list
 209   void addForm(HeaderForm *ptr);     // Add objects to header list
 210   void addForm(SourceForm *ptr);     // Add objects to source list
 211   void addForm(EncodeForm *ptr);     // Add objects to encode list
 212   void addForm(InstructForm *ptr);   // Add objects to the instruct list
 213   void addForm(OperandForm *ptr);    // Add objects to the operand list
 214   void addForm(OpClassForm *ptr);    // Add objects to the opclasss list
 215   void addForm(AttributeForm *ptr);  // Add objects to the attributes list
 216   void addForm(RegisterForm *ptr);   // Add objects to the register list
 217   void addForm(FrameForm    *ptr);   // Add objects to the frame list
 218   void addForm(PipelineForm *ptr);   // Add objects to the pipeline list
 219   void addForm(MachNodeForm *ptr);   // Add objects to the machnode list
 220 
 221   int  operandFormCount();           // Count number of OperandForms defined
 222   int  opclassFormCount();           // Count number of OpClassForms defined
 223   int  instructFormCount();          // Count number of InstructForms defined
 224 
 225   inline void getForm(EncodeForm **ptr)     { *ptr = _encode; }
 226 
 227   bool verify();
 228   void dump();
 229 
 230   // Helper utility that gets MatchList components from inside MatchRule
 231   void check_optype(MatchRule *mrule);
 232   void build_chain_rule(OperandForm *oper);
 233   void add_chain_rule_entry(const char *src, const char *cost,
 234                             const char *result);
 235   const char *getMatchListIndex(MatchRule &mrule);
 236   void generateMatchLists();         // Build MatchList array and populate it
 237   void inspectOperands();            // Build MatchLists for all operands
 238   void inspectOpClasses();           // Build MatchLists for all operands
 239   void inspectInstructions();        // Build MatchLists for all operands
 240   void buildDFA(FILE *fp);           // Driver for constructing the DFA
 241   void gen_dfa_state_body(FILE *fp, Dict &minmize, ProductionState &status, Dict &chained, int i);    // Driver for constructing the DFA state bodies
 242 
 243   // Helper utilities to generate reduction maps for internal operands
 244   const char *reduceLeft (char *internalName);
 245   const char *reduceRight(char *internalName);
 246 
 247   // Build enumerations, (1) dense operand index, (2) operands and opcodes
 248   const char *machOperEnum(const char *opName);       // create dense index names using static function
 249   static const char *getMachOperEnum(const char *opName);// create dense index name
 250   void buildMachOperEnum(FILE *fp_hpp);// dense enumeration for operands
 251   void buildMachOpcodesEnum(FILE *fp_hpp);// enumeration for MachOpers & MachNodes
 252 
 253   // Helper utilities to generate Register Masks
 254   RegisterForm *get_registers() { return _register; }
 255   const char *reg_mask(OperandForm  &opForm);
 256   const char *reg_mask(InstructForm &instForm);
 257   const char *reg_class_to_reg_mask(const char *reg_class);
 258   char *stack_or_reg_mask(OperandForm  &opForm);  // name of cisc_spillable version
 259   // This register class should also generate a stack_or_reg_mask
 260   void  set_stack_or_reg(const char *reg_class_name); // for cisc-spillable reg classes
 261   // Generate an enumeration of register mask names and the RegMask objects.
 262   void  declare_register_masks(FILE *fp_cpp);
 263   void  build_register_masks(FILE *fp_cpp);
 264   // Generate enumeration of machine register numbers
 265   void  buildMachRegisterNumbers(FILE *fp_hpp);
 266   // Generate enumeration of machine register encodings
 267   void  buildMachRegisterEncodes(FILE *fp_hpp);
 268   // Generate Regsiter Size Array
 269   void  declareRegSizes(FILE *fp_hpp);
 270   // Generate Pipeline Class information
 271   void declare_pipe_classes(FILE *fp_hpp);
 272   // Generate Pipeline definitions
 273   void build_pipeline_enums(FILE *fp_cpp);
 274   // Generate Pipeline Class information
 275   void build_pipe_classes(FILE *fp_cpp);
 276 
 277   // Declare and define mappings from rules to result and input types
 278   void build_map(OutputMap &map);
 279   void buildReduceMaps(FILE *fp_hpp, FILE *fp_cpp);
 280   // build flags for signaling that our machine needs this instruction cloned
 281   void buildMustCloneMap(FILE *fp_hpp, FILE *fp_cpp);
 282 
 283   // output SUN copyright info
 284   void addSunCopyright(char* legal, int size, FILE *fp);
 285   // output the start of an include guard.
 286   void addIncludeGuardStart(ADLFILE &adlfile, const char* guardString);
 287   // output the end of an include guard.
 288   void addIncludeGuardEnd(ADLFILE &adlfile, const char* guardString);
 289   // output the #include line for this file.
 290   void addInclude(ADLFILE &adlfile, const char* fileName);
 291   void addInclude(ADLFILE &adlfile, const char* includeDir, const char* fileName);
 292   // Output C preprocessor code to verify the backend compilation environment.
 293   void addPreprocessorChecks(FILE *fp);
 294   // Output C source and header (source_hpp) blocks.
 295   void addPreHeaderBlocks(FILE *fp_hpp);
 296   void addHeaderBlocks(FILE *fp_hpp);
 297   void addSourceBlocks(FILE *fp_cpp);
 298   void generate_needs_clone_jvms(FILE *fp_cpp);
 299   void generate_adlc_verification(FILE *fp_cpp);
 300 
 301   // output declaration of class State
 302   void defineStateClass(FILE *fp);
 303 
 304   // Generator for MachOper objects given integer type
 305   void buildMachOperGenerator(FILE *fp_cpp);
 306   // Generator for MachNode objects given integer type
 307   void buildMachNodeGenerator(FILE *fp_cpp);
 308 
 309   // Generator for Expand methods for instructions with expand rules
 310   void defineExpand      (FILE *fp, InstructForm *node);
 311   // Generator for Peephole methods for instructions with peephole rules
 312   void definePeephole    (FILE *fp, InstructForm *node);
 313   // Generator for Size methods for instructions
 314   void defineSize        (FILE *fp, InstructForm &node);
 315 
 316 public:
 317   // Generator for EvalConstantValue methods for instructions
 318   void defineEvalConstant(FILE *fp, InstructForm &node);
 319   // Generator for Emit methods for instructions
 320   void defineEmit        (FILE *fp, InstructForm &node);
 321   // Generator for postalloc_expand methods for instructions.
 322   void define_postalloc_expand(FILE *fp, InstructForm &node);
 323 
 324   // Define a MachOper encode method
 325   void define_oper_interface(FILE *fp, OperandForm &oper, FormDict &globals,
 326                              const char *name, const char *encoding);
 327 
 328   // Methods to construct the MachNode class hierarchy
 329   // Return the type signature for the ideal operation
 330   const char *getIdealType(const char *idealOp);
 331   // Declare and define the classes derived from MachOper and MachNode
 332   void declareClasses(FILE *fp_hpp);
 333   void defineClasses(FILE *fp_cpp);
 334 
 335   // Emit an ADLC message
 336   void internal_err( const char *fmt, ...);
 337   void syntax_err  ( int lineno, const char *fmt, ...);
 338   int  emit_msg(int quiet, int flag, int linenum, const char *fmt,
 339        va_list args);
 340 
 341   // Generator for has_match_rule methods
 342   void buildInstructMatchCheck(FILE *fp_cpp) const;
 343 
 344   // Generator for Frame Methods
 345   void buildFrameMethods(FILE *fp_cpp);
 346 
 347   // Generate CISC_spilling oracle and MachNode::cisc_spill() methods
 348   void          build_cisc_spill_instructions(FILE *fp_hpp, FILE *fp_cpp);
 349   void          identify_cisc_spill_instructions();
 350   void          identify_short_branches();
 351   void          identify_unique_operands();
 352   void          set_cisc_spill_operand(OperandForm *opForm) { _cisc_spill_operand = opForm; }
 353   OperandForm  *cisc_spill_operand() { return _cisc_spill_operand; }
 354   bool          can_cisc_spill() { return _cisc_spill_operand != NULL; }
 355 
 356 
 357 protected:
 358   // build MatchList from MatchRule
 359   void buildMatchList(MatchRule *mrule, const char *resultStr,
 360                       const char *rootOp, Predicate *pred, const char *cost);
 361 
 362   void buildMList(MatchNode *node, const char *rootOp, const char *resultOp,
 363                   Predicate *pred, const char *cost);
 364 
 365   friend class ADLParser;
 366 
 367 };
 368 
 369 
 370 // -------------------------------- maps ------------------------------------
 371 
 372 // Base class for generating a mapping from rule number to value.
 373 // Used with ArchDesc::build_map() for all maps except "enum MachOperands"
 374 // A derived class defines the appropriate output for a specific mapping.
 375 class OutputMap {
 376 protected:
 377   FILE       *_hpp;
 378   FILE       *_cpp;
 379   FormDict   &_globals;
 380   ArchDesc   &_AD;
 381   const char *_name;
 382 public:
 383   OutputMap (FILE *decl_file, FILE *def_file, FormDict &globals, ArchDesc &AD, const char *name)
 384     : _hpp(decl_file), _cpp(def_file), _globals(globals), _AD(AD), _name(name) {};
 385   // Access files used by this routine
 386   FILE        *decl_file() { return _hpp; }
 387   FILE        *def_file()  { return _cpp; }
 388   // Positions in iteration that derived class will be told about
 389   enum position { BEGIN_OPERANDS,
 390                   BEGIN_OPCLASSES,
 391                   BEGIN_INTERNALS,
 392                   BEGIN_INSTRUCTIONS,
 393                   BEGIN_INST_CHAIN_RULES,
 394                   END_INST_CHAIN_RULES,
 395                   BEGIN_REMATERIALIZE,
 396                   END_REMATERIALIZE,
 397                   END_INSTRUCTIONS
 398   };
 399   // Output routines specific to the derived class
 400   virtual void declaration() {}
 401   virtual void definition()  {}
 402   virtual void closing()     {  fprintf(_cpp, "};\n"); }
 403   virtual void map(OperandForm  &oper) { }
 404   virtual void map(OpClassForm  &opc)  { }
 405   virtual void map(char         *internal_name) { }
 406   // Allow enum-MachOperands to turn-off instructions
 407   virtual bool do_instructions()       { return true; }
 408   virtual void map(InstructForm &inst) { }
 409   // Allow derived class to output name and position specific info
 410   virtual void record_position(OutputMap::position place, int index) {}
 411 };
 412 
 413 #endif // SHARE_VM_ADLC_ARCHDESC_HPP