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