1 /*
   2  * Copyright (c) 1997, 2013, 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_ADLPARSE_HPP
  26 #define SHARE_VM_ADLC_ADLPARSE_HPP
  27 
  28 // ADLPARSE.HPP - Definitions for Architecture Description Language Parser
  29 // Authors: Chris Vick and Mike Paleczny
  30 
  31 // Class List
  32 class Form;
  33 // ***** Top Level, 1, classes  *****
  34 class InstructForm;
  35 class OperandForm;
  36 class OpClassForm;
  37 class AttributeForm;
  38 class RegisterForm;
  39 class PipelineForm;
  40 class SourceForm;
  41 class Peephole;
  42 // ***** Level 2 classes *****
  43 class Component;
  44 class Predicate;
  45 class MatchRule;
  46 class Encode;
  47 class Attribute;
  48 class Effect;
  49 class ExpandRule;
  50 class RewriteRule;
  51 class Constraint;
  52 class ConstructRule;
  53 // ***** Register Section *****
  54 class RegDef;
  55 class RegClass;
  56 class CodeSnippetRegClass;
  57 class ConditionalRegClass;
  58 class AllocClass;
  59 class ResourceForm;
  60 // ***** Pipeline Section *****
  61 class PipeDesc;
  62 class PipeClass;
  63 class RegList;
  64 // ***** Peephole Section *****
  65 class PeepMatch;
  66 class PeepConstraint;
  67 class PeepReplace;
  68 
  69 // class ostream; // ostream is a typedef in some systems
  70 
  71 extern char *toUpper(const char *str);
  72 
  73 //---------------------------ADLParser-----------------------------------------
  74 class ADLParser {
  75 protected:
  76   char     *_curline;           // Start of current line
  77   char     *_ptr;               // Pointer into current location in File Buffer
  78   char      _curchar;           // Current character from buffer
  79   FormDict &_globalNames;       // Global names
  80 
  81   enum { _preproc_limit = 20 };
  82   int       _preproc_depth;                 // How deep are we into ifdefs?
  83   int       _preproc_not_taken;             // How deep in not-taken ifdefs?
  84   bool      _preproc_taken[_preproc_limit]; // Are we taking this ifdef level?
  85   bool      _preproc_else[_preproc_limit];  // Did this level have an else yet?
  86 
  87   // ***** Level 1 Parse functions *****
  88   void instr_parse(void);       // Parse instruction definitions
  89   void oper_parse(void);        // Parse operand definitions
  90   void opclass_parse(void);     // Parse operand class definitions
  91   void ins_attr_parse(void);    // Parse instruction attrubute definitions
  92   void op_attr_parse(void);     // Parse operand attrubute definitions
  93   void source_parse(void);      // Parse source section
  94   void source_hpp_parse(void);  // Parse source_hpp section
  95   void reg_parse(void);         // Parse register section
  96   void encode_parse(void);      // Parse encoding section
  97   void frame_parse(void);       // Parse frame section
  98   void pipe_parse(void);        // Parse pipeline section
  99   void definitions_parse(void); // Parse definitions section
 100   void peep_parse(void);        // Parse peephole rule definitions
 101   void preproc_line(void);      // Parse a #line statement
 102   void preproc_define(void);    // Parse a #define statement
 103   void preproc_undef(void);     // Parse an #undef statement
 104 
 105   // Helper functions for instr_parse().
 106   void adjust_set_rule(InstructForm *instr);
 107   void matchrule_clone_and_swap(MatchRule *rule, const char* instr_ident, int& match_rules_cnt);
 108 
 109   // ***** Level 2 Parse functions *****
 110   // Parse the components of the encode section
 111   void enc_class_parse(void);   // Parse encoding class definition
 112   void enc_class_parse_block(EncClass* encoding, char* ec_name);
 113 
 114   // Parse the components of the frame section
 115   void stack_dir_parse(FrameForm *frame);   // Parse the stack direction entry
 116   void sync_stack_slots_parse(FrameForm *frame);
 117   void frame_pointer_parse(FrameForm *frame, bool native);
 118   void interpreter_frame_pointer_parse(FrameForm *frame, bool native);
 119   void inline_cache_parse(FrameForm *frame, bool native);
 120   void interpreter_arg_ptr_parse(FrameForm *frame, bool native);
 121   void interpreter_method_oop_parse(FrameForm *frame, bool native);
 122   void cisc_spilling_operand_name_parse(FrameForm *frame, bool native);
 123   void stack_alignment_parse(FrameForm *frame);
 124   void return_addr_parse(FrameForm *frame, bool native);
 125   void preserve_stack_parse(FrameForm *frame);
 126   char *calling_convention_parse();
 127   char *return_value_parse();
 128 
 129   // Parse components of the register section
 130   void reg_def_parse(void);              // Parse register definition
 131   void reg_class_parse(void);            // Parse register class definition
 132   void reg_class_dynamic_parse(void);    // Parse dynamic register class definition
 133   void alloc_class_parse(void);          // Parse allocation class definition
 134 
 135   // Parse components of the definition section
 136   void int_def_parse(void);              // Parse an integer definition
 137 
 138   // Parse components of a pipeline rule
 139   void resource_parse(PipelineForm &pipe);   // Parse resource definition
 140   void pipe_desc_parse(PipelineForm &pipe);  // Parse pipeline description definition
 141   void pipe_class_parse(PipelineForm &pipe); // Parse pipeline class definition
 142 
 143   // Parse components of a peephole rule
 144   void peep_match_parse(Peephole &peep);     // Parse the peephole match rule
 145   void peep_constraint_parse(Peephole &peep);// Parse the peephole constraints
 146   void peep_replace_parse(Peephole &peep);   // Parse peephole replacement rule
 147 
 148   // Parse the peep match rule tree
 149   InstructForm *peep_match_child_parse(PeepMatch &match, int parent, int &position, int input);
 150 
 151   // Parse components of an operand and/or instruction form
 152   Predicate     *pred_parse(void);       // Parse predicate rule
 153   // Parse match rule, and internal nodes
 154   MatchRule     *match_parse(FormDict &operands);
 155   MatchNode     *matchNode_parse(FormDict &operands, int &depth,
 156                                  int &numleaves, bool atroot);
 157   MatchNode     *matchChild_parse(FormDict &operands, int &depth,
 158                                   int &numleaves, bool atroot);
 159 
 160   Attribute     *attr_parse(char *ident);// Parse instr/operand attribute rule
 161   // Parse instruction encode rule
 162   void           ins_encode_parse(InstructForm &inst);
 163   void           ins_encode_parse_block(InstructForm &inst);
 164   void           ins_encode_parse_block_impl(InstructForm& inst, EncClass* encoding, char* ec_name);
 165   // Parse instruction postalloc expand rule.
 166   void           postalloc_expand_parse(InstructForm &inst);
 167 
 168   void           constant_parse(InstructForm& inst);
 169   void           constant_parse_expression(EncClass* encoding, char* ec_name);
 170 
 171   Opcode        *opcode_parse(InstructForm *insr); // Parse instruction opcode
 172   char          *size_parse(InstructForm *insr); // Parse instruction size
 173   Interface     *interface_parse();      // Parse operand interface rule
 174   Interface     *mem_interface_parse();  // Parse memory interface rule
 175   Interface     *cond_interface_parse(); // Parse conditional interface rule
 176   char          *interface_field_parse(const char** format = NULL);// Parse field contents
 177 
 178   FormatRule    *format_parse(void);     // Parse format rule
 179   FormatRule    *template_parse(void);     // Parse format rule
 180   void           effect_parse(InstructForm *instr); // Parse effect rule
 181   ExpandRule    *expand_parse(InstructForm *instr); // Parse expand rule
 182   RewriteRule   *rewrite_parse(void);    // Parse rewrite rule
 183   Constraint    *constraint_parse(void); // Parse constraint rule
 184   ConstructRule *construct_parse(void);  // Parse construct rule
 185   void           ins_pipe_parse(InstructForm &instr); // Parse ins_pipe rule
 186 
 187   // ***** Preprocessor functions *****
 188   void begin_if_def(bool taken) {
 189     assert(_preproc_depth < _preproc_limit, "#ifdef nesting limit");
 190     int ppn = _preproc_depth++;
 191     _preproc_taken[ppn] = taken;
 192     // Invariant:  _preproc_not_taken = SUM !_preproc_taken[0.._preproc_depth)
 193     if (!_preproc_taken[ppn])  _preproc_not_taken += 1;
 194     _preproc_else[ppn] = false;
 195   }
 196   void invert_if_def() {
 197     assert(_preproc_depth > 0, "#ifdef matching");
 198     int ppn = _preproc_depth - 1;
 199     assert(!_preproc_else[ppn], "multiple #else lines");
 200     _preproc_else[ppn] = true;
 201     if (!_preproc_taken[ppn])  _preproc_not_taken -= 1;
 202     _preproc_taken[ppn] = !_preproc_taken[ppn];
 203     if (!_preproc_taken[ppn])  _preproc_not_taken += 1;
 204   }
 205   void end_if_def() {
 206     assert(_preproc_depth > 0, "#ifdef matching");
 207     int ppn = --_preproc_depth;
 208     if (!_preproc_taken[ppn])  _preproc_not_taken -= 1;
 209   }
 210   bool preproc_taken() {
 211     // Return true only if there is no directive hiding this text position.
 212     return _preproc_not_taken == 0;
 213   }
 214   // Handle a '#' token.  Return true if it disappeared.
 215   bool handle_preproc_token();
 216 
 217   // ***** Utility Functions for ADL Parser ******
 218 
 219   // Parse one string argument inside parens:  '(' string ')' ';'
 220   char *parse_one_arg(const char *description);
 221 
 222   // Return the next identifier given a pointer into a line of the buffer.
 223   char *get_ident()            { return get_ident_common(true); }
 224   char *get_ident_no_preproc() { return get_ident_common(false); }
 225   char *get_ident_common(bool do_preproc);      // Grab it from the file buffer
 226   char *get_ident_dup(void);    // Grab a duplicate of the identifier
 227   char *get_ident_or_literal_constant(const char* description);
 228   // Grab unique identifier from file buffer
 229   char *get_unique_ident(FormDict &dict, const char *nameDescription);
 230   // Return the next replacement variable identifier
 231   char *get_rep_var_ident(void);
 232   // Skip first '$' and make a duplicate of the string
 233   char *get_rep_var_ident_dup(void);
 234   // Return the next token given as a signed integer.
 235   int   get_int(void);
 236   // Return the next token, a relational operator { ==, !=, <=, >= }
 237   char *get_relation_dup(void);
 238 
 239   void  get_oplist(NameList &parameters, FormDict &operands);// Parse type-operand pairs
 240   void  get_effectlist(FormDict &effects, FormDict &operands, bool& has_call); // Parse effect-operand pairs
 241   // Return the contents of a parenthesized expression.
 242   // Requires initial '(' and consumes final ')', which is replaced by '\0'.
 243   char *get_paren_expr(const char *description, bool include_location = false);
 244   // Return expression up to next stop-char, which terminator replaces.
 245   // Does not require initial '('.  Does not consume final stop-char.
 246   // Final stop-char is left in _curchar, but is also is replaced by '\0'.
 247   char *get_expr(const char *description, const char *stop_chars);
 248   char *find_cpp_block(const char *description); // Parse a C++ code block
 249   // Issue parser error message & go to EOL
 250   void parse_err(int flag, const char *fmt, ...);
 251   // Create a location marker for this file and line.
 252   char *get_line_string(int linenum = 0);
 253   // Return a location marker which tells the C preprocessor to
 254   // forget the previous location marker.  (Requires awk postprocessing.)
 255   char *end_line_marker() { return (char*)"\n#line 999999\n"; }
 256 
 257   // Return pointer to current character
 258   inline char  cur_char(void);
 259   // Advance to next character, assign this to _curchar
 260   inline void  next_char(void);
 261   inline void  next_char_or_line(void);
 262   // Advance File Buffer to next line, updating _curline
 263   inline void  next_line(void);
 264   // Issue an error if we are not at the beginning of a line (exc. whitespace).
 265   void ensure_start_of_line(void);
 266   // Issue an error if we are not at the end of a line (exc. whitespace).
 267   void ensure_end_of_line(void);
 268   // Skip whitespace, leaving ptr pointing to first non-whitespace character
 269   // Also handle preprocessor constructs like "#ifdef".
 270   void skipws()                { skipws_common(true); }
 271   // Skip comments and spaces but not newlines or preprocessor constructs.
 272   void skipws_no_preproc()     { skipws_common(false); }
 273   void skipws_common(bool do_preproc);
 274 
 275   FileBuff &_buf;               // File buffer to be parsed
 276   ArchDesc &_AD;                // Architecture Description being built
 277 
 278 public:
 279 
 280   ADLParser(FileBuff &buf, ArchDesc &archDesc); // Create new ADLParser object
 281   ~ADLParser();                 // Destroy ADLParser object
 282 
 283   void parse(void);             // Do the parsing & build forms lists
 284 
 285   int linenum() { return _buf.linenum(); }
 286 
 287   static bool is_literal_constant(const char *hex_string);
 288   static bool is_hex_digit(char digit);
 289   static bool is_int_token(const char* token, int& intval);
 290   static bool equivalent_expressions(const char* str1, const char* str2);
 291   static void trim(char* &token);  // trim leading & trailing spaces
 292 };
 293 
 294 #endif // SHARE_VM_ADLC_ADLPARSE_HPP