|
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 int _linenum; // Count of line numbers seen so far |
|
74 char _curchar; // Current character from buffer |
|
75 FormDict &_globalNames; // Global names |
|
76 |
|
77 enum { _preproc_limit = 20 }; |
|
78 int _preproc_depth; // How deep are we into ifdefs? |
|
79 int _preproc_not_taken; // How deep in not-taken ifdefs? |
|
80 bool _preproc_taken[_preproc_limit]; // Are we taking this ifdef level? |
|
81 bool _preproc_else[_preproc_limit]; // Did this level have an else yet? |
|
82 |
|
83 // ***** Level 1 Parse functions ***** |
|
84 void instr_parse(void); // Parse instruction definitions |
|
85 void oper_parse(void); // Parse operand definitions |
|
86 void opclass_parse(void); // Parse operand class definitions |
|
87 void ins_attr_parse(void); // Parse instruction attrubute definitions |
|
88 void op_attr_parse(void); // Parse operand attrubute definitions |
|
89 void source_parse(void); // Parse source section |
|
90 void source_hpp_parse(void); // Parse source_hpp section |
|
91 void reg_parse(void); // Parse register section |
|
92 void encode_parse(void); // Parse encoding section |
|
93 void frame_parse(void); // Parse frame section |
|
94 void pipe_parse(void); // Parse pipeline section |
|
95 void definitions_parse(void); // Parse definitions section |
|
96 void peep_parse(void); // Parse peephole rule definitions |
|
97 void preproc_define(void); // Parse a #define statement |
|
98 void preproc_undef(void); // Parse an #undef statement |
|
99 |
|
100 // Helper functions for instr_parse(). |
|
101 void adjust_set_rule(InstructForm *instr); |
|
102 void matchrule_clone_and_swap(MatchRule *rule, const char* instr_ident, int& match_rules_cnt); |
|
103 |
|
104 // ***** Level 2 Parse functions ***** |
|
105 // Parse the components of the encode section |
|
106 void enc_class_parse(void); // Parse encoding class definition |
|
107 void enc_class_parse_block(EncClass* encoding, char* ec_name); |
|
108 |
|
109 // Parse the components of the frame section |
|
110 void stack_dir_parse(FrameForm *frame); // Parse the stack direction entry |
|
111 void sync_stack_slots_parse(FrameForm *frame); |
|
112 void frame_pointer_parse(FrameForm *frame, bool native); |
|
113 void interpreter_frame_pointer_parse(FrameForm *frame, bool native); |
|
114 void inline_cache_parse(FrameForm *frame, bool native); |
|
115 void interpreter_arg_ptr_parse(FrameForm *frame, bool native); |
|
116 void interpreter_method_oop_parse(FrameForm *frame, bool native); |
|
117 void cisc_spilling_operand_name_parse(FrameForm *frame, bool native); |
|
118 void stack_alignment_parse(FrameForm *frame); |
|
119 void return_addr_parse(FrameForm *frame, bool native); |
|
120 void preserve_stack_parse(FrameForm *frame); |
|
121 char *calling_convention_parse(); |
|
122 char *return_value_parse(); |
|
123 |
|
124 // Parse components of the register section |
|
125 void reg_def_parse(void); // Parse register definition |
|
126 void reg_class_parse(void); // Parse register class definition |
|
127 void alloc_class_parse(void); // Parse allocation class definition |
|
128 |
|
129 // Parse components of the definition section |
|
130 void int_def_parse(void); // Parse an integer definition |
|
131 |
|
132 // Parse components of a pipeline rule |
|
133 void resource_parse(PipelineForm &pipe); // Parse resource definition |
|
134 void pipe_desc_parse(PipelineForm &pipe); // Parse pipeline description definition |
|
135 void pipe_class_parse(PipelineForm &pipe); // Parse pipeline class definition |
|
136 |
|
137 // Parse components of a peephole rule |
|
138 void peep_match_parse(Peephole &peep); // Parse the peephole match rule |
|
139 void peep_constraint_parse(Peephole &peep);// Parse the peephole constraints |
|
140 void peep_replace_parse(Peephole &peep); // Parse peephole replacement rule |
|
141 |
|
142 // Parse the peep match rule tree |
|
143 InstructForm *peep_match_child_parse(PeepMatch &match, int parent, int &position, int input); |
|
144 |
|
145 // Parse components of an operand and/or instruction form |
|
146 Predicate *pred_parse(void); // Parse predicate rule |
|
147 // Parse match rule, and internal nodes |
|
148 MatchRule *match_parse(FormDict &operands); |
|
149 MatchNode *matchNode_parse(FormDict &operands, int &depth, |
|
150 int &numleaves, bool atroot); |
|
151 MatchNode *matchChild_parse(FormDict &operands, int &depth, |
|
152 int &numleaves, bool atroot); |
|
153 |
|
154 Attribute *attr_parse(char *ident);// Parse instr/operand attribute rule |
|
155 // Parse instruction encode rule |
|
156 InsEncode *ins_encode_parse(InstructForm &inst); |
|
157 InsEncode *ins_encode_parse_block(InstructForm &inst); |
|
158 Opcode *opcode_parse(InstructForm *insr); // Parse instruction opcode |
|
159 char *size_parse(InstructForm *insr); // Parse instruction size |
|
160 Interface *interface_parse(); // Parse operand interface rule |
|
161 Interface *mem_interface_parse(); // Parse memory interface rule |
|
162 Interface *cond_interface_parse(); // Parse conditional interface rule |
|
163 char *interface_field_parse();// Parse field contents |
|
164 |
|
165 FormatRule *format_parse(void); // Parse format rule |
|
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 |
|
266 int getlines( ) { return _linenum; } |
|
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 }; |