Mercurial > hg > graal-compiler
annotate src/share/vm/adlc/adlparse.hpp @ 1972:f95d63e2154a
6989984: Use standard include model for Hospot
Summary: Replaced MakeDeps and the includeDB files with more standardized solutions.
Reviewed-by: coleenp, kvn, kamg
| author | stefank |
|---|---|
| date | Tue, 23 Nov 2010 13:22:55 -0800 |
| parents | c18cbe5936b8 |
| children | 2f644f85485d |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
579
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
579
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
579
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_ADLC_ADLPARSE_HPP |
| 26 #define SHARE_VM_ADLC_ADLPARSE_HPP | |
| 27 | |
| 0 | 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 AllocClass; | |
| 57 class ResourceForm; | |
| 58 // ***** Pipeline Section ***** | |
| 59 class PipeDesc; | |
| 60 class PipeClass; | |
| 61 class RegList; | |
| 62 // ***** Peephole Section ***** | |
| 63 class PeepMatch; | |
| 64 class PeepConstraint; | |
| 65 class PeepReplace; | |
| 66 | |
| 67 // class ostream; // ostream is a typedef in some systems | |
| 68 | |
| 69 extern char *toUpper(const char *str); | |
| 70 | |
| 71 //---------------------------ADLParser----------------------------------------- | |
| 72 class ADLParser { | |
| 73 protected: | |
| 74 char *_curline; // Start of current line | |
| 75 char *_ptr; // Pointer into current location in File Buffer | |
| 76 char _curchar; // Current character from buffer | |
| 77 FormDict &_globalNames; // Global names | |
| 78 | |
| 79 enum { _preproc_limit = 20 }; | |
| 80 int _preproc_depth; // How deep are we into ifdefs? | |
| 81 int _preproc_not_taken; // How deep in not-taken ifdefs? | |
| 82 bool _preproc_taken[_preproc_limit]; // Are we taking this ifdef level? | |
| 83 bool _preproc_else[_preproc_limit]; // Did this level have an else yet? | |
| 84 | |
| 85 // ***** Level 1 Parse functions ***** | |
| 86 void instr_parse(void); // Parse instruction definitions | |
| 87 void oper_parse(void); // Parse operand definitions | |
| 88 void opclass_parse(void); // Parse operand class definitions | |
| 89 void ins_attr_parse(void); // Parse instruction attrubute definitions | |
| 90 void op_attr_parse(void); // Parse operand attrubute definitions | |
| 91 void source_parse(void); // Parse source section | |
| 92 void source_hpp_parse(void); // Parse source_hpp section | |
| 93 void reg_parse(void); // Parse register section | |
| 94 void encode_parse(void); // Parse encoding section | |
| 95 void frame_parse(void); // Parse frame section | |
| 96 void pipe_parse(void); // Parse pipeline section | |
| 97 void definitions_parse(void); // Parse definitions section | |
| 98 void peep_parse(void); // Parse peephole rule definitions | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
99 void preproc_line(void); // Parse a #line statement |
| 0 | 100 void preproc_define(void); // Parse a #define statement |
| 101 void preproc_undef(void); // Parse an #undef statement | |
| 102 | |
| 103 // Helper functions for instr_parse(). | |
| 104 void adjust_set_rule(InstructForm *instr); | |
| 105 void matchrule_clone_and_swap(MatchRule *rule, const char* instr_ident, int& match_rules_cnt); | |
| 106 | |
| 107 // ***** Level 2 Parse functions ***** | |
| 108 // Parse the components of the encode section | |
| 109 void enc_class_parse(void); // Parse encoding class definition | |
| 110 void enc_class_parse_block(EncClass* encoding, char* ec_name); | |
| 111 | |
| 112 // Parse the components of the frame section | |
| 113 void stack_dir_parse(FrameForm *frame); // Parse the stack direction entry | |
| 114 void sync_stack_slots_parse(FrameForm *frame); | |
| 115 void frame_pointer_parse(FrameForm *frame, bool native); | |
| 116 void interpreter_frame_pointer_parse(FrameForm *frame, bool native); | |
| 117 void inline_cache_parse(FrameForm *frame, bool native); | |
| 118 void interpreter_arg_ptr_parse(FrameForm *frame, bool native); | |
| 119 void interpreter_method_oop_parse(FrameForm *frame, bool native); | |
| 120 void cisc_spilling_operand_name_parse(FrameForm *frame, bool native); | |
| 121 void stack_alignment_parse(FrameForm *frame); | |
| 122 void return_addr_parse(FrameForm *frame, bool native); | |
| 123 void preserve_stack_parse(FrameForm *frame); | |
| 124 char *calling_convention_parse(); | |
| 125 char *return_value_parse(); | |
| 126 | |
| 127 // Parse components of the register section | |
| 128 void reg_def_parse(void); // Parse register definition | |
| 129 void reg_class_parse(void); // Parse register class definition | |
| 130 void alloc_class_parse(void); // Parse allocation class definition | |
| 131 | |
| 132 // Parse components of the definition section | |
| 133 void int_def_parse(void); // Parse an integer definition | |
| 134 | |
| 135 // Parse components of a pipeline rule | |
| 136 void resource_parse(PipelineForm &pipe); // Parse resource definition | |
| 137 void pipe_desc_parse(PipelineForm &pipe); // Parse pipeline description definition | |
| 138 void pipe_class_parse(PipelineForm &pipe); // Parse pipeline class definition | |
| 139 | |
| 140 // Parse components of a peephole rule | |
| 141 void peep_match_parse(Peephole &peep); // Parse the peephole match rule | |
| 142 void peep_constraint_parse(Peephole &peep);// Parse the peephole constraints | |
| 143 void peep_replace_parse(Peephole &peep); // Parse peephole replacement rule | |
| 144 | |
| 145 // Parse the peep match rule tree | |
| 146 InstructForm *peep_match_child_parse(PeepMatch &match, int parent, int &position, int input); | |
| 147 | |
| 148 // Parse components of an operand and/or instruction form | |
| 149 Predicate *pred_parse(void); // Parse predicate rule | |
| 150 // Parse match rule, and internal nodes | |
| 151 MatchRule *match_parse(FormDict &operands); | |
| 152 MatchNode *matchNode_parse(FormDict &operands, int &depth, | |
| 153 int &numleaves, bool atroot); | |
| 154 MatchNode *matchChild_parse(FormDict &operands, int &depth, | |
| 155 int &numleaves, bool atroot); | |
| 156 | |
| 157 Attribute *attr_parse(char *ident);// Parse instr/operand attribute rule | |
| 158 // Parse instruction encode rule | |
| 159 InsEncode *ins_encode_parse(InstructForm &inst); | |
| 160 InsEncode *ins_encode_parse_block(InstructForm &inst); | |
| 161 Opcode *opcode_parse(InstructForm *insr); // Parse instruction opcode | |
| 162 char *size_parse(InstructForm *insr); // Parse instruction size | |
| 163 Interface *interface_parse(); // Parse operand interface rule | |
| 164 Interface *mem_interface_parse(); // Parse memory interface rule | |
| 165 Interface *cond_interface_parse(); // Parse conditional interface rule | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
166 char *interface_field_parse(const char** format = NULL);// Parse field contents |
| 0 | 167 |
| 168 FormatRule *format_parse(void); // Parse format rule | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
169 FormatRule *template_parse(void); // Parse format rule |
| 0 | 170 void effect_parse(InstructForm *instr); // Parse effect rule |
| 171 ExpandRule *expand_parse(InstructForm *instr); // Parse expand rule | |
| 172 RewriteRule *rewrite_parse(void); // Parse rewrite rule | |
| 173 Constraint *constraint_parse(void); // Parse constraint rule | |
| 174 ConstructRule *construct_parse(void); // Parse construct rule | |
| 175 void ins_pipe_parse(InstructForm &instr); // Parse ins_pipe rule | |
| 176 | |
| 177 // ***** Preprocessor functions ***** | |
| 178 void begin_if_def(bool taken) { | |
| 179 assert(_preproc_depth < _preproc_limit, "#ifdef nesting limit"); | |
| 180 int ppn = _preproc_depth++; | |
| 181 _preproc_taken[ppn] = taken; | |
| 182 // Invariant: _preproc_not_taken = SUM !_preproc_taken[0.._preproc_depth) | |
| 183 if (!_preproc_taken[ppn]) _preproc_not_taken += 1; | |
| 184 _preproc_else[ppn] = false; | |
| 185 } | |
| 186 void invert_if_def() { | |
| 187 assert(_preproc_depth > 0, "#ifdef matching"); | |
| 188 int ppn = _preproc_depth - 1; | |
| 189 assert(!_preproc_else[ppn], "multiple #else lines"); | |
| 190 _preproc_else[ppn] = true; | |
| 191 if (!_preproc_taken[ppn]) _preproc_not_taken -= 1; | |
| 192 _preproc_taken[ppn] = !_preproc_taken[ppn]; | |
| 193 if (!_preproc_taken[ppn]) _preproc_not_taken += 1; | |
| 194 } | |
| 195 void end_if_def() { | |
| 196 assert(_preproc_depth > 0, "#ifdef matching"); | |
| 197 int ppn = --_preproc_depth; | |
| 198 if (!_preproc_taken[ppn]) _preproc_not_taken -= 1; | |
| 199 } | |
| 200 bool preproc_taken() { | |
| 201 // Return true only if there is no directive hiding this text position. | |
| 202 return _preproc_not_taken == 0; | |
| 203 } | |
| 204 // Handle a '#' token. Return true if it disappeared. | |
| 205 bool handle_preproc_token(); | |
| 206 | |
| 207 // ***** Utility Functions for ADL Parser ****** | |
| 208 | |
| 209 // Parse one string argument inside parens: '(' string ')' ';' | |
| 210 char *parse_one_arg(const char *description); | |
| 211 | |
| 212 // Return the next identifier given a pointer into a line of the buffer. | |
| 213 char *get_ident() { return get_ident_common(true); } | |
| 214 char *get_ident_no_preproc() { return get_ident_common(false); } | |
| 215 char *get_ident_common(bool do_preproc); // Grab it from the file buffer | |
| 216 char *get_ident_dup(void); // Grab a duplicate of the identifier | |
| 217 char *get_ident_or_literal_constant(const char* description); | |
| 218 // Grab unique identifier from file buffer | |
| 219 char *get_unique_ident(FormDict &dict, const char *nameDescription); | |
| 220 // Return the next replacement variable identifier | |
| 221 char *get_rep_var_ident(void); | |
| 222 // Skip first '$' and make a duplicate of the string | |
| 223 char *get_rep_var_ident_dup(void); | |
| 224 // Return the next token given as a signed integer. | |
| 225 int get_int(void); | |
| 226 // Return the next token, a relational operator { ==, !=, <=, >= } | |
| 227 char *get_relation_dup(void); | |
| 228 | |
| 229 void get_oplist(NameList ¶meters, FormDict &operands);// Parse type-operand pairs | |
| 230 void get_effectlist(FormDict &effects, FormDict &operands); // Parse effect-operand pairs | |
| 231 // Return the contents of a parenthesized expression. | |
| 232 // Requires initial '(' and consumes final ')', which is replaced by '\0'. | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
233 char *get_paren_expr(const char *description, bool include_location = false); |
| 0 | 234 // Return expression up to next stop-char, which terminator replaces. |
| 235 // Does not require initial '('. Does not consume final stop-char. | |
| 236 // Final stop-char is left in _curchar, but is also is replaced by '\0'. | |
| 237 char *get_expr(const char *description, const char *stop_chars); | |
| 238 char *find_cpp_block(const char *description); // Parse a C++ code block | |
| 239 // Issue parser error message & go to EOL | |
| 240 void parse_err(int flag, const char *fmt, ...); | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
241 // Create a location marker for this file and line. |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
242 char *get_line_string(int linenum = 0); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
243 // Return a location marker which tells the C preprocessor to |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
244 // forget the previous location marker. (Requires awk postprocessing.) |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
245 char *end_line_marker() { return (char*)"\n#line 999999\n"; } |
| 0 | 246 |
| 247 // Return pointer to current character | |
| 248 inline char cur_char(void); | |
| 249 // Advance to next character, assign this to _curchar | |
| 250 inline void next_char(void); | |
| 251 inline void next_char_or_line(void); | |
| 252 // Advance File Buffer to next line, updating _curline | |
| 253 inline void next_line(void); | |
| 254 // Issue an error if we are not at the beginning of a line (exc. whitespace). | |
| 255 void ensure_start_of_line(void); | |
| 256 // Issue an error if we are not at the end of a line (exc. whitespace). | |
| 257 void ensure_end_of_line(void); | |
| 258 // Skip whitespace, leaving ptr pointing to first non-whitespace character | |
| 259 // Also handle preprocessor constructs like "#ifdef". | |
| 260 void skipws() { skipws_common(true); } | |
| 261 // Skip comments and spaces but not newlines or preprocessor constructs. | |
| 262 void skipws_no_preproc() { skipws_common(false); } | |
| 263 void skipws_common(bool do_preproc); | |
| 264 | |
| 265 FileBuff &_buf; // File buffer to be parsed | |
| 266 ArchDesc &_AD; // Architecture Description being built | |
| 267 | |
| 268 public: | |
| 269 | |
| 270 ADLParser(FileBuff &buf, ArchDesc &archDesc); // Create new ADLParser object | |
| 271 ~ADLParser(); // Destroy ADLParser object | |
| 272 | |
| 273 void parse(void); // Do the parsing & build forms lists | |
| 274 | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
275 int linenum() { return _buf.linenum(); } |
| 0 | 276 |
| 277 static bool is_literal_constant(const char *hex_string); | |
| 278 static bool is_hex_digit(char digit); | |
| 279 static bool is_int_token(const char* token, int& intval); | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
280 static bool equivalent_expressions(const char* str1, const char* str2); |
| 0 | 281 static void trim(char* &token); // trim leading & trailing spaces |
| 282 }; | |
| 1972 | 283 |
| 284 #endif // SHARE_VM_ADLC_ADLPARSE_HPP |