Mercurial > hg > truffle
annotate src/share/vm/adlc/adlparse.hpp @ 6972:bd7a7ce2e264
6830717: replay of compilations would help with debugging
Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method.
Reviewed-by: kvn, twisti, sspitsyn
Contributed-by: yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Mon, 12 Nov 2012 14:03:53 -0800 |
| parents | f03a3c8bd5e5 |
| children | 044b28168e20 |
| 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 | |
| 2008 | 159 void ins_encode_parse(InstructForm &inst); |
| 160 void ins_encode_parse_block(InstructForm &inst); | |
| 161 void ins_encode_parse_block_impl(InstructForm& inst, EncClass* encoding, char* ec_name); | |
| 162 | |
| 163 void constant_parse(InstructForm& inst); | |
| 164 void constant_parse_expression(EncClass* encoding, char* ec_name); | |
| 165 | |
| 0 | 166 Opcode *opcode_parse(InstructForm *insr); // Parse instruction opcode |
| 167 char *size_parse(InstructForm *insr); // Parse instruction size | |
| 168 Interface *interface_parse(); // Parse operand interface rule | |
| 169 Interface *mem_interface_parse(); // Parse memory interface rule | |
| 170 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
|
171 char *interface_field_parse(const char** format = NULL);// Parse field contents |
| 0 | 172 |
| 173 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
|
174 FormatRule *template_parse(void); // Parse format rule |
| 0 | 175 void effect_parse(InstructForm *instr); // Parse effect rule |
| 176 ExpandRule *expand_parse(InstructForm *instr); // Parse expand rule | |
| 177 RewriteRule *rewrite_parse(void); // Parse rewrite rule | |
| 178 Constraint *constraint_parse(void); // Parse constraint rule | |
| 179 ConstructRule *construct_parse(void); // Parse construct rule | |
| 180 void ins_pipe_parse(InstructForm &instr); // Parse ins_pipe rule | |
| 181 | |
| 182 // ***** Preprocessor functions ***** | |
| 183 void begin_if_def(bool taken) { | |
| 184 assert(_preproc_depth < _preproc_limit, "#ifdef nesting limit"); | |
| 185 int ppn = _preproc_depth++; | |
| 186 _preproc_taken[ppn] = taken; | |
| 187 // Invariant: _preproc_not_taken = SUM !_preproc_taken[0.._preproc_depth) | |
| 188 if (!_preproc_taken[ppn]) _preproc_not_taken += 1; | |
| 189 _preproc_else[ppn] = false; | |
| 190 } | |
| 191 void invert_if_def() { | |
| 192 assert(_preproc_depth > 0, "#ifdef matching"); | |
| 193 int ppn = _preproc_depth - 1; | |
| 194 assert(!_preproc_else[ppn], "multiple #else lines"); | |
| 195 _preproc_else[ppn] = true; | |
| 196 if (!_preproc_taken[ppn]) _preproc_not_taken -= 1; | |
| 197 _preproc_taken[ppn] = !_preproc_taken[ppn]; | |
| 198 if (!_preproc_taken[ppn]) _preproc_not_taken += 1; | |
| 199 } | |
| 200 void end_if_def() { | |
| 201 assert(_preproc_depth > 0, "#ifdef matching"); | |
| 202 int ppn = --_preproc_depth; | |
| 203 if (!_preproc_taken[ppn]) _preproc_not_taken -= 1; | |
| 204 } | |
| 205 bool preproc_taken() { | |
| 206 // Return true only if there is no directive hiding this text position. | |
| 207 return _preproc_not_taken == 0; | |
| 208 } | |
| 209 // Handle a '#' token. Return true if it disappeared. | |
| 210 bool handle_preproc_token(); | |
| 211 | |
| 212 // ***** Utility Functions for ADL Parser ****** | |
| 213 | |
| 214 // Parse one string argument inside parens: '(' string ')' ';' | |
| 215 char *parse_one_arg(const char *description); | |
| 216 | |
| 217 // Return the next identifier given a pointer into a line of the buffer. | |
| 218 char *get_ident() { return get_ident_common(true); } | |
| 219 char *get_ident_no_preproc() { return get_ident_common(false); } | |
| 220 char *get_ident_common(bool do_preproc); // Grab it from the file buffer | |
| 221 char *get_ident_dup(void); // Grab a duplicate of the identifier | |
| 222 char *get_ident_or_literal_constant(const char* description); | |
| 223 // Grab unique identifier from file buffer | |
| 224 char *get_unique_ident(FormDict &dict, const char *nameDescription); | |
| 225 // Return the next replacement variable identifier | |
| 226 char *get_rep_var_ident(void); | |
| 227 // Skip first '$' and make a duplicate of the string | |
| 228 char *get_rep_var_ident_dup(void); | |
| 229 // Return the next token given as a signed integer. | |
| 230 int get_int(void); | |
| 231 // Return the next token, a relational operator { ==, !=, <=, >= } | |
| 232 char *get_relation_dup(void); | |
| 233 | |
| 234 void get_oplist(NameList ¶meters, FormDict &operands);// Parse type-operand pairs | |
|
4120
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
2008
diff
changeset
|
235 void get_effectlist(FormDict &effects, FormDict &operands, bool& has_call); // Parse effect-operand pairs |
| 0 | 236 // Return the contents of a parenthesized expression. |
| 237 // 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
|
238 char *get_paren_expr(const char *description, bool include_location = false); |
| 0 | 239 // Return expression up to next stop-char, which terminator replaces. |
| 240 // Does not require initial '('. Does not consume final stop-char. | |
| 241 // Final stop-char is left in _curchar, but is also is replaced by '\0'. | |
| 242 char *get_expr(const char *description, const char *stop_chars); | |
| 243 char *find_cpp_block(const char *description); // Parse a C++ code block | |
| 244 // Issue parser error message & go to EOL | |
| 245 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
|
246 // 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
|
247 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
|
248 // 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
|
249 // 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
|
250 char *end_line_marker() { return (char*)"\n#line 999999\n"; } |
| 0 | 251 |
| 252 // Return pointer to current character | |
| 253 inline char cur_char(void); | |
| 254 // Advance to next character, assign this to _curchar | |
| 255 inline void next_char(void); | |
| 256 inline void next_char_or_line(void); | |
| 257 // Advance File Buffer to next line, updating _curline | |
| 258 inline void next_line(void); | |
| 259 // Issue an error if we are not at the beginning of a line (exc. whitespace). | |
| 260 void ensure_start_of_line(void); | |
| 261 // Issue an error if we are not at the end of a line (exc. whitespace). | |
| 262 void ensure_end_of_line(void); | |
| 263 // Skip whitespace, leaving ptr pointing to first non-whitespace character | |
| 264 // Also handle preprocessor constructs like "#ifdef". | |
| 265 void skipws() { skipws_common(true); } | |
| 266 // Skip comments and spaces but not newlines or preprocessor constructs. | |
| 267 void skipws_no_preproc() { skipws_common(false); } | |
| 268 void skipws_common(bool do_preproc); | |
| 269 | |
| 270 FileBuff &_buf; // File buffer to be parsed | |
| 271 ArchDesc &_AD; // Architecture Description being built | |
| 272 | |
| 273 public: | |
| 274 | |
| 275 ADLParser(FileBuff &buf, ArchDesc &archDesc); // Create new ADLParser object | |
| 276 ~ADLParser(); // Destroy ADLParser object | |
| 277 | |
| 278 void parse(void); // Do the parsing & build forms lists | |
| 279 | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
280 int linenum() { return _buf.linenum(); } |
| 0 | 281 |
| 282 static bool is_literal_constant(const char *hex_string); | |
| 283 static bool is_hex_digit(char digit); | |
| 284 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
|
285 static bool equivalent_expressions(const char* str1, const char* str2); |
| 0 | 286 static void trim(char* &token); // trim leading & trailing spaces |
| 287 }; | |
| 1972 | 288 |
| 289 #endif // SHARE_VM_ADLC_ADLPARSE_HPP |