Mercurial > hg > graal-jvmci-8
annotate src/share/vm/adlc/adlparse.cpp @ 23286:dd9cc155639c
Merge with jdk8u66-b17
| author | Gilles Duboscq <gilles.m.duboscq@oracle.com> |
|---|---|
| date | Thu, 07 Jan 2016 17:28:46 +0100 |
| parents | 52b4284cb496 a1642365d69f |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
14223
de6a9e811145
8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013
mikael
parents:
12323
diff
changeset
|
2 * Copyright (c) 1997, 2013, 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:
628
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
628
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:
628
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 25 // ADLPARSE.CPP - Architecture Description Language Parser | |
| 26 // Authors: Chris Vick and Mike Paleczny | |
| 27 #include "adlc.hpp" | |
| 28 | |
| 29 //----------------------------ADLParser---------------------------------------- | |
| 30 // Create a new ADL parser | |
| 31 ADLParser::ADLParser(FileBuff& buffer, ArchDesc& archDesc) | |
| 32 : _buf(buffer), _AD(archDesc), | |
| 33 _globalNames(archDesc.globalNames()) { | |
| 34 _AD._syntax_errs = _AD._semantic_errs = 0; // No errors so far this file | |
| 35 _AD._warnings = 0; // No warnings either | |
| 36 _curline = _ptr = NULL; // No pointers into buffer yet | |
| 37 | |
| 38 _preproc_depth = 0; | |
| 39 _preproc_not_taken = 0; | |
| 40 | |
| 41 // Delimit command-line definitions from in-file definitions: | |
| 42 _AD._preproc_list.add_signal(); | |
| 43 } | |
| 44 | |
| 45 //------------------------------~ADLParser------------------------------------- | |
| 46 // Delete an ADL parser. | |
| 47 ADLParser::~ADLParser() { | |
| 48 if (!_AD._quiet_mode) | |
| 49 fprintf(stderr,"---------------------------- Errors and Warnings ----------------------------\n"); | |
| 50 #ifndef ASSERT | |
| 51 fprintf(stderr, "**************************************************************\n"); | |
| 52 fprintf(stderr, "***** WARNING: ASSERT is undefined, assertions disabled. *****\n"); | |
| 53 fprintf(stderr, "**************************************************************\n"); | |
| 54 #endif | |
| 55 if( _AD._syntax_errs + _AD._semantic_errs + _AD._warnings == 0 ) { | |
| 56 if (!_AD._quiet_mode) | |
| 57 fprintf(stderr,"No errors or warnings to report from phase-1 parse.\n" ); | |
| 58 } | |
| 59 else { | |
| 60 if( _AD._syntax_errs ) { // Any syntax errors? | |
| 61 fprintf(stderr,"%s: Found %d syntax error", _buf._fp->_name, _AD._syntax_errs); | |
| 62 if( _AD._syntax_errs > 1 ) fprintf(stderr,"s.\n\n"); | |
| 63 else fprintf(stderr,".\n\n"); | |
| 64 } | |
| 65 if( _AD._semantic_errs ) { // Any semantic errors? | |
| 66 fprintf(stderr,"%s: Found %d semantic error", _buf._fp->_name, _AD._semantic_errs); | |
| 67 if( _AD._semantic_errs > 1 ) fprintf(stderr,"s.\n\n"); | |
| 68 else fprintf(stderr,".\n\n"); | |
| 69 } | |
| 70 if( _AD._warnings ) { // Any warnings? | |
| 71 fprintf(stderr,"%s: Found %d warning", _buf._fp->_name, _AD._warnings); | |
| 72 if( _AD._warnings > 1 ) fprintf(stderr,"s.\n\n"); | |
| 73 else fprintf(stderr,".\n\n"); | |
| 74 } | |
| 75 } | |
| 76 if (!_AD._quiet_mode) | |
| 77 fprintf(stderr,"-----------------------------------------------------------------------------\n"); | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
78 _AD._TotalLines += linenum()-1; // -1 for overshoot in "nextline" routine |
| 0 | 79 |
| 80 // Write out information we have stored | |
| 81 // // UNIXism == fsync(stderr); | |
| 82 } | |
| 83 | |
| 84 //------------------------------parse------------------------------------------ | |
| 85 // Each top-level keyword should appear as the first non-whitespace on a line. | |
| 86 // | |
| 87 void ADLParser::parse() { | |
| 88 char *ident; | |
| 89 | |
| 90 // Iterate over the lines in the file buffer parsing Level 1 objects | |
| 91 for( next_line(); _curline != NULL; next_line()) { | |
| 92 _ptr = _curline; // Reset ptr to start of new line | |
| 93 skipws(); // Skip any leading whitespace | |
| 94 ident = get_ident(); // Get first token | |
| 95 if (ident == NULL) { // Empty line | |
| 96 continue; // Get the next line | |
| 97 } | |
| 2008 | 98 if (!strcmp(ident, "instruct")) instr_parse(); |
| 0 | 99 else if (!strcmp(ident, "operand")) oper_parse(); |
| 100 else if (!strcmp(ident, "opclass")) opclass_parse(); | |
| 101 else if (!strcmp(ident, "ins_attrib")) ins_attr_parse(); | |
| 102 else if (!strcmp(ident, "op_attrib")) op_attr_parse(); | |
| 103 else if (!strcmp(ident, "source")) source_parse(); | |
| 104 else if (!strcmp(ident, "source_hpp")) source_hpp_parse(); | |
| 105 else if (!strcmp(ident, "register")) reg_parse(); | |
| 106 else if (!strcmp(ident, "frame")) frame_parse(); | |
| 107 else if (!strcmp(ident, "encode")) encode_parse(); | |
| 108 else if (!strcmp(ident, "pipeline")) pipe_parse(); | |
| 109 else if (!strcmp(ident, "definitions")) definitions_parse(); | |
| 110 else if (!strcmp(ident, "peephole")) peep_parse(); | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
111 else if (!strcmp(ident, "#line")) preproc_line(); |
| 0 | 112 else if (!strcmp(ident, "#define")) preproc_define(); |
| 113 else if (!strcmp(ident, "#undef")) preproc_undef(); | |
| 114 else { | |
| 115 parse_err(SYNERR, "expected one of - instruct, operand, ins_attrib, op_attrib, source, register, pipeline, encode\n Found %s",ident); | |
| 116 } | |
| 117 } | |
|
6179
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
4121
diff
changeset
|
118 // Add reg_class spill_regs after parsing. |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
4121
diff
changeset
|
119 RegisterForm *regBlock = _AD.get_registers(); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
4121
diff
changeset
|
120 if (regBlock == NULL) { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
4121
diff
changeset
|
121 parse_err(SEMERR, "Did not declare 'register' definitions"); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
4121
diff
changeset
|
122 } |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
4121
diff
changeset
|
123 regBlock->addSpillRegClass(); |
| 0 | 124 |
| 125 // Done with parsing, check consistency. | |
| 126 | |
| 127 if (_preproc_depth != 0) { | |
| 128 parse_err(SYNERR, "End of file inside #ifdef"); | |
| 129 } | |
| 130 | |
| 131 // AttributeForms ins_cost and op_cost must be defined for default behaviour | |
| 132 if (_globalNames[AttributeForm::_ins_cost] == NULL) { | |
| 133 parse_err(SEMERR, "Did not declare 'ins_cost' attribute"); | |
| 134 } | |
| 135 if (_globalNames[AttributeForm::_op_cost] == NULL) { | |
| 136 parse_err(SEMERR, "Did not declare 'op_cost' attribute"); | |
| 137 } | |
| 138 } | |
| 139 | |
| 140 // ******************** Private Level 1 Parse Functions ******************** | |
| 141 //------------------------------instr_parse------------------------------------ | |
| 142 // Parse the contents of an instruction definition, build the InstructForm to | |
| 143 // represent that instruction, and add it to the InstructForm list. | |
| 144 void ADLParser::instr_parse(void) { | |
| 145 char *ident; | |
| 146 InstructForm *instr; | |
| 147 MatchRule *rule; | |
| 148 int match_rules_cnt = 0; | |
| 149 | |
| 150 // First get the name of the instruction | |
| 151 if( (ident = get_unique_ident(_globalNames,"instruction")) == NULL ) | |
| 152 return; | |
| 153 instr = new InstructForm(ident); // Create new instruction form | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
154 instr->_linenum = linenum(); |
| 0 | 155 _globalNames.Insert(ident, instr); // Add name to the name table |
| 156 // Debugging Stuff | |
| 157 if (_AD._adl_debug > 1) | |
| 158 fprintf(stderr,"Parsing Instruction Form %s\n", ident); | |
| 159 | |
| 160 // Then get the operands | |
| 161 skipws(); | |
| 162 if (_curchar != '(') { | |
| 163 parse_err(SYNERR, "missing '(' in instruct definition\n"); | |
| 164 } | |
| 165 // Parse the operand list | |
| 166 else get_oplist(instr->_parameters, instr->_localNames); | |
| 167 skipws(); // Skip leading whitespace | |
| 168 // Check for block delimiter | |
| 169 if ( (_curchar != '%') | |
| 170 || ( next_char(), (_curchar != '{')) ) { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
171 parse_err(SYNERR, "missing '%%{' in instruction definition\n"); |
| 0 | 172 return; |
| 173 } | |
| 174 next_char(); // Maintain the invariant | |
| 175 do { | |
| 176 ident = get_ident(); // Grab next identifier | |
| 177 if (ident == NULL) { | |
| 178 parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar); | |
| 179 continue; | |
| 180 } | |
| 181 if (!strcmp(ident, "predicate")) instr->_predicate = pred_parse(); | |
| 182 else if (!strcmp(ident, "match")) { | |
| 183 // Allow one instruction have several match rules. | |
| 184 rule = instr->_matrule; | |
| 185 if (rule == NULL) { | |
| 186 // This is first match rule encountered | |
| 187 rule = match_parse(instr->_localNames); | |
| 188 if (rule) { | |
| 189 instr->_matrule = rule; | |
| 190 // Special case the treatment of Control instructions. | |
| 191 if( instr->is_ideal_control() ) { | |
| 192 // Control instructions return a special result, 'Universe' | |
| 193 rule->_result = "Universe"; | |
| 194 } | |
| 195 // Check for commutative operations with tree operands. | |
| 196 matchrule_clone_and_swap(rule, instr->_ident, match_rules_cnt); | |
| 197 } | |
| 198 } else { | |
| 199 // Find the end of the match rule list | |
| 200 while (rule->_next != NULL) | |
| 201 rule = rule->_next; | |
| 202 // Add the new match rule to the list | |
| 203 rule->_next = match_parse(instr->_localNames); | |
| 204 if (rule->_next) { | |
| 205 rule = rule->_next; | |
| 206 if( instr->is_ideal_control() ) { | |
| 207 parse_err(SYNERR, "unique match rule expected for %s\n", rule->_name); | |
| 208 return; | |
| 209 } | |
| 210 assert(match_rules_cnt < 100," too many match rule clones"); | |
| 211 char* buf = (char*) malloc(strlen(instr->_ident) + 4); | |
| 212 sprintf(buf, "%s_%d", instr->_ident, match_rules_cnt++); | |
| 213 rule->_result = buf; | |
| 214 // Check for commutative operations with tree operands. | |
| 215 matchrule_clone_and_swap(rule, instr->_ident, match_rules_cnt); | |
| 216 } | |
| 217 } | |
| 218 } | |
| 219 else if (!strcmp(ident, "encode")) { | |
| 220 parse_err(SYNERR, "Instructions specify ins_encode, not encode\n"); | |
| 221 } | |
|
14428
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
222 else if (!strcmp(ident, "ins_encode")) ins_encode_parse(*instr); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
223 // Parse late expand keyword. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
224 else if (!strcmp(ident, "postalloc_expand")) postalloc_expand_parse(*instr); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
225 else if (!strcmp(ident, "opcode")) instr->_opcode = opcode_parse(instr); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
226 else if (!strcmp(ident, "size")) instr->_size = size_parse(instr); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
227 else if (!strcmp(ident, "effect")) effect_parse(instr); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
228 else if (!strcmp(ident, "expand")) instr->_exprule = expand_parse(instr); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
229 else if (!strcmp(ident, "rewrite")) instr->_rewrule = rewrite_parse(); |
| 0 | 230 else if (!strcmp(ident, "constraint")) { |
| 231 parse_err(SYNERR, "Instructions do not specify a constraint\n"); | |
| 232 } | |
| 233 else if (!strcmp(ident, "construct")) { | |
| 234 parse_err(SYNERR, "Instructions do not specify a construct\n"); | |
| 235 } | |
|
14428
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
236 else if (!strcmp(ident, "format")) instr->_format = format_parse(); |
| 0 | 237 else if (!strcmp(ident, "interface")) { |
| 238 parse_err(SYNERR, "Instructions do not specify an interface\n"); | |
| 239 } | |
| 2008 | 240 else if (!strcmp(ident, "ins_pipe")) ins_pipe_parse(*instr); |
| 0 | 241 else { // Done with staticly defined parts of instruction definition |
| 242 // Check identifier to see if it is the name of an attribute | |
| 243 const Form *form = _globalNames[ident]; | |
| 244 AttributeForm *attr = form ? form->is_attribute() : NULL; | |
|
14428
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
245 if (attr && (attr->_atype == INS_ATTR)) { |
| 0 | 246 // Insert the new attribute into the linked list. |
| 247 Attribute *temp = attr_parse(ident); | |
| 248 temp->_next = instr->_attribs; | |
| 249 instr->_attribs = temp; | |
| 250 } else { | |
|
14428
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
251 parse_err(SYNERR, "expected one of:\n predicate, match, encode, or the name of" |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
252 " an instruction attribute at %s\n", ident); |
| 0 | 253 } |
| 254 } | |
| 255 skipws(); | |
| 256 } while(_curchar != '%'); | |
| 257 next_char(); | |
| 258 if (_curchar != '}') { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
259 parse_err(SYNERR, "missing '%%}' in instruction definition\n"); |
| 0 | 260 return; |
| 261 } | |
| 262 // Check for "Set" form of chain rule | |
| 263 adjust_set_rule(instr); | |
|
14428
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
264 if (_AD._pipeline) { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
265 // No pipe required for late expand. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
266 if (instr->expands() || instr->postalloc_expands()) { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
267 if (instr->_ins_pipe) { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
268 parse_err(WARN, "ins_pipe and expand rule both specified for instruction \"%s\";" |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
269 " ins_pipe will be unused\n", instr->_ident); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
270 } |
| 0 | 271 } else { |
|
14428
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
272 if (!instr->_ins_pipe) { |
| 0 | 273 parse_err(WARN, "No ins_pipe specified for instruction \"%s\"\n", instr->_ident); |
|
14428
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
274 } |
| 0 | 275 } |
| 276 } | |
| 277 // Add instruction to tail of instruction list | |
| 278 _AD.addForm(instr); | |
| 279 | |
| 280 // Create instruction form for each additional match rule | |
| 281 rule = instr->_matrule; | |
| 282 if (rule != NULL) { | |
| 283 rule = rule->_next; | |
| 284 while (rule != NULL) { | |
| 285 ident = (char*)rule->_result; | |
| 286 InstructForm *clone = new InstructForm(ident, instr, rule); // Create new instruction form | |
| 287 _globalNames.Insert(ident, clone); // Add name to the name table | |
| 288 // Debugging Stuff | |
| 289 if (_AD._adl_debug > 1) | |
| 290 fprintf(stderr,"Parsing Instruction Form %s\n", ident); | |
| 291 // Check for "Set" form of chain rule | |
| 292 adjust_set_rule(clone); | |
| 293 // Add instruction to tail of instruction list | |
| 294 _AD.addForm(clone); | |
| 295 rule = rule->_next; | |
| 296 clone->_matrule->_next = NULL; // One match rule per clone | |
| 297 } | |
| 298 } | |
| 299 } | |
| 300 | |
| 301 //------------------------------matchrule_clone_and_swap----------------------- | |
| 302 // Check for commutative operations with subtree operands, | |
| 303 // create clones and swap operands. | |
| 304 void ADLParser::matchrule_clone_and_swap(MatchRule* rule, const char* instr_ident, int& match_rules_cnt) { | |
| 305 // Check for commutative operations with tree operands. | |
| 306 int count = 0; | |
| 307 rule->count_commutative_op(count); | |
| 308 if (count > 0) { | |
| 309 // Clone match rule and swap commutative operation's operands. | |
|
603
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
310 rule->matchrule_swap_commutative_op(instr_ident, count, match_rules_cnt); |
| 0 | 311 } |
| 312 } | |
| 313 | |
| 314 //------------------------------adjust_set_rule-------------------------------- | |
| 315 // Check for "Set" form of chain rule | |
| 316 void ADLParser::adjust_set_rule(InstructForm *instr) { | |
| 317 if (instr->_matrule == NULL || instr->_matrule->_rChild == NULL) return; | |
| 318 const char *rch = instr->_matrule->_rChild->_opType; | |
| 319 const Form *frm = _globalNames[rch]; | |
| 320 if( (! strcmp(instr->_matrule->_opType,"Set")) && | |
| 321 frm && frm->is_operand() && (! frm->ideal_only()) ) { | |
| 322 // Previous implementation, which missed leaP*, but worked for loadCon* | |
| 323 unsigned position = 0; | |
| 324 const char *result = NULL; | |
| 325 const char *name = NULL; | |
| 326 const char *optype = NULL; | |
| 327 MatchNode *right = instr->_matrule->_rChild; | |
| 328 if (right->base_operand(position, _globalNames, result, name, optype)) { | |
| 329 position = 1; | |
| 330 const char *result2 = NULL; | |
| 331 const char *name2 = NULL; | |
| 332 const char *optype2 = NULL; | |
| 333 // Can not have additional base operands in right side of match! | |
| 334 if ( ! right->base_operand( position, _globalNames, result2, name2, optype2) ) { | |
| 2008 | 335 if (instr->_predicate != NULL) |
| 336 parse_err(SYNERR, "ADLC does not support instruction chain rules with predicates"); | |
| 0 | 337 // Chain from input _ideal_operand_type_, |
| 338 // Needed for shared roots of match-trees | |
| 339 ChainList *lst = (ChainList *)_AD._chainRules[optype]; | |
| 340 if (lst == NULL) { | |
| 341 lst = new ChainList(); | |
| 342 _AD._chainRules.Insert(optype, lst); | |
| 343 } | |
| 344 if (!lst->search(instr->_matrule->_lChild->_opType)) { | |
| 345 const char *cost = instr->cost(); | |
| 346 if (cost == NULL) { | |
| 347 cost = ((AttributeForm*)_globalNames[AttributeForm::_ins_cost])->_attrdef; | |
| 348 } | |
| 349 // The ADLC does not support chaining from the ideal operand type | |
| 350 // of a predicated user-defined operand | |
| 351 if( frm->is_operand() == NULL || frm->is_operand()->_predicate == NULL ) { | |
| 352 lst->insert(instr->_matrule->_lChild->_opType,cost,instr->_ident); | |
| 353 } | |
| 354 } | |
| 355 // Chain from input _user_defined_operand_type_, | |
| 356 lst = (ChainList *)_AD._chainRules[result]; | |
| 357 if (lst == NULL) { | |
| 358 lst = new ChainList(); | |
| 359 _AD._chainRules.Insert(result, lst); | |
| 360 } | |
| 361 if (!lst->search(instr->_matrule->_lChild->_opType)) { | |
| 362 const char *cost = instr->cost(); | |
| 363 if (cost == NULL) { | |
| 364 cost = ((AttributeForm*)_globalNames[AttributeForm::_ins_cost])->_attrdef; | |
| 365 } | |
| 366 // It is safe to chain from the top-level user-defined operand even | |
| 367 // if it has a predicate, since the predicate is checked before | |
| 368 // the user-defined type is available. | |
| 369 lst->insert(instr->_matrule->_lChild->_opType,cost,instr->_ident); | |
| 370 } | |
| 371 } else { | |
| 372 // May have instruction chain rule if root of right-tree is an ideal | |
| 373 OperandForm *rightOp = _globalNames[right->_opType]->is_operand(); | |
| 374 if( rightOp ) { | |
| 375 const Form *rightRoot = _globalNames[rightOp->_matrule->_opType]; | |
| 376 if( rightRoot && rightRoot->ideal_only() ) { | |
| 377 const char *chain_op = NULL; | |
| 378 if( rightRoot->is_instruction() ) | |
| 379 chain_op = rightOp->_ident; | |
| 380 if( chain_op ) { | |
| 381 // Look-up the operation in chain rule table | |
| 382 ChainList *lst = (ChainList *)_AD._chainRules[chain_op]; | |
| 383 if (lst == NULL) { | |
| 384 lst = new ChainList(); | |
| 385 _AD._chainRules.Insert(chain_op, lst); | |
| 386 } | |
| 387 // if (!lst->search(instr->_matrule->_lChild->_opType)) { | |
| 388 const char *cost = instr->cost(); | |
| 389 if (cost == NULL) { | |
| 390 cost = ((AttributeForm*)_globalNames[AttributeForm::_ins_cost])->_attrdef; | |
| 391 } | |
| 392 // This chains from a top-level operand whose predicate, if any, | |
| 393 // has been checked. | |
| 394 lst->insert(instr->_matrule->_lChild->_opType,cost,instr->_ident); | |
| 395 // } | |
| 396 } | |
| 397 } | |
| 398 } | |
| 399 } // end chain rule from right-tree's ideal root | |
| 400 } | |
| 401 } | |
| 402 } | |
| 403 | |
| 404 | |
| 405 //------------------------------oper_parse------------------------------------- | |
| 406 void ADLParser::oper_parse(void) { | |
| 407 char *ident; | |
| 408 OperandForm *oper; | |
| 409 AttributeForm *attr; | |
| 410 MatchRule *rule; | |
| 411 | |
| 412 // First get the name of the operand | |
| 413 skipws(); | |
| 414 if( (ident = get_unique_ident(_globalNames,"operand")) == NULL ) | |
| 415 return; | |
| 416 oper = new OperandForm(ident); // Create new operand form | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
417 oper->_linenum = linenum(); |
| 0 | 418 _globalNames.Insert(ident, oper); // Add name to the name table |
| 419 | |
| 420 // Debugging Stuff | |
| 421 if (_AD._adl_debug > 1) fprintf(stderr,"Parsing Operand Form %s\n", ident); | |
| 422 | |
| 423 // Get the component operands | |
| 424 skipws(); | |
| 425 if (_curchar != '(') { | |
| 426 parse_err(SYNERR, "missing '(' in operand definition\n"); | |
| 427 return; | |
| 428 } | |
| 429 else get_oplist(oper->_parameters, oper->_localNames); // Parse the component operand list | |
| 430 skipws(); | |
| 431 // Check for block delimiter | |
| 432 if ((_curchar != '%') || (*(_ptr+1) != '{')) { // If not open block | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
433 parse_err(SYNERR, "missing '%%{' in operand definition\n"); |
| 0 | 434 return; |
| 435 } | |
| 436 next_char(); next_char(); // Skip over "%{" symbol | |
| 437 do { | |
| 438 ident = get_ident(); // Grab next identifier | |
| 439 if (ident == NULL) { | |
| 440 parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar); | |
| 441 continue; | |
| 442 } | |
| 443 if (!strcmp(ident, "predicate")) oper->_predicate = pred_parse(); | |
| 444 else if (!strcmp(ident, "match")) { | |
| 445 // Find the end of the match rule list | |
| 446 rule = oper->_matrule; | |
| 447 if (rule) { | |
| 448 while (rule->_next) rule = rule->_next; | |
| 449 // Add the new match rule to the list | |
| 450 rule->_next = match_parse(oper->_localNames); | |
| 451 if (rule->_next) { | |
| 452 rule->_next->_result = oper->_ident; | |
| 453 } | |
| 454 } | |
| 455 else { | |
| 456 // This is first match rule encountered | |
| 457 oper->_matrule = match_parse(oper->_localNames); | |
| 458 if (oper->_matrule) { | |
| 459 oper->_matrule->_result = oper->_ident; | |
| 460 } | |
| 461 } | |
| 462 } | |
| 463 else if (!strcmp(ident, "encode")) oper->_interface = interface_parse(); | |
| 464 else if (!strcmp(ident, "ins_encode")) { | |
| 465 parse_err(SYNERR, "Operands specify 'encode', not 'ins_encode'\n"); | |
| 466 } | |
| 467 else if (!strcmp(ident, "opcode")) { | |
| 468 parse_err(SYNERR, "Operands do not specify an opcode\n"); | |
| 469 } | |
| 470 else if (!strcmp(ident, "effect")) { | |
| 471 parse_err(SYNERR, "Operands do not specify an effect\n"); | |
| 472 } | |
| 473 else if (!strcmp(ident, "expand")) { | |
| 474 parse_err(SYNERR, "Operands do not specify an expand\n"); | |
| 475 } | |
| 476 else if (!strcmp(ident, "rewrite")) { | |
| 477 parse_err(SYNERR, "Operands do not specify a rewrite\n"); | |
| 478 } | |
| 479 else if (!strcmp(ident, "constraint"))oper->_constraint= constraint_parse(); | |
| 480 else if (!strcmp(ident, "construct")) oper->_construct = construct_parse(); | |
| 481 else if (!strcmp(ident, "format")) oper->_format = format_parse(); | |
| 482 else if (!strcmp(ident, "interface")) oper->_interface = interface_parse(); | |
| 483 // Check identifier to see if it is the name of an attribute | |
| 484 else if (((attr = _globalNames[ident]->is_attribute()) != NULL) && | |
| 485 (attr->_atype == OP_ATTR)) oper->_attribs = attr_parse(ident); | |
| 486 else { | |
| 487 parse_err(SYNERR, "expected one of - constraint, predicate, match, encode, format, construct, or the name of a defined operand attribute at %s\n", ident); | |
| 488 } | |
| 489 skipws(); | |
| 490 } while(_curchar != '%'); | |
| 491 next_char(); | |
| 492 if (_curchar != '}') { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
493 parse_err(SYNERR, "missing '%%}' in operand definition\n"); |
| 0 | 494 return; |
| 495 } | |
| 496 // Add operand to tail of operand list | |
| 497 _AD.addForm(oper); | |
| 498 } | |
| 499 | |
| 500 //------------------------------opclass_parse---------------------------------- | |
| 501 // Operand Classes are a block with a comma delimited list of operand names | |
| 502 void ADLParser::opclass_parse(void) { | |
| 503 char *ident; | |
| 504 OpClassForm *opc; | |
| 505 OperandForm *opForm; | |
| 506 | |
| 507 // First get the name of the operand class | |
| 508 skipws(); | |
| 509 if( (ident = get_unique_ident(_globalNames,"opclass")) == NULL ) | |
| 510 return; | |
| 511 opc = new OpClassForm(ident); // Create new operand class form | |
| 512 _globalNames.Insert(ident, opc); // Add name to the name table | |
| 513 | |
| 514 // Debugging Stuff | |
| 515 if (_AD._adl_debug > 1) | |
| 516 fprintf(stderr,"Parsing Operand Class Form %s\n", ident); | |
| 517 | |
| 518 // Get the list of operands | |
| 519 skipws(); | |
| 520 if (_curchar != '(') { | |
| 521 parse_err(SYNERR, "missing '(' in operand definition\n"); | |
| 522 return; | |
| 523 } | |
| 524 do { | |
| 525 next_char(); // Skip past open paren or comma | |
| 526 ident = get_ident(); // Grab next identifier | |
| 527 if (ident == NULL) { | |
| 528 parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar); | |
| 529 continue; | |
| 530 } | |
| 531 // Check identifier to see if it is the name of an operand | |
| 532 const Form *form = _globalNames[ident]; | |
| 533 opForm = form ? form->is_operand() : NULL; | |
| 534 if ( opForm ) { | |
| 535 opc->_oplst.addName(ident); // Add operand to opclass list | |
| 536 opForm->_classes.addName(opc->_ident);// Add opclass to operand list | |
| 537 } | |
| 538 else { | |
| 539 parse_err(SYNERR, "expected name of a defined operand at %s\n", ident); | |
| 540 } | |
| 541 skipws(); // skip trailing whitespace | |
| 542 } while (_curchar == ','); // Check for the comma | |
| 543 // Check for closing ')' | |
| 544 if (_curchar != ')') { | |
| 545 parse_err(SYNERR, "missing ')' or ',' in opclass definition\n"); | |
| 546 return; | |
| 547 } | |
| 548 next_char(); // Consume the ')' | |
| 549 skipws(); | |
| 550 // Check for closing ';' | |
| 551 if (_curchar != ';') { | |
| 552 parse_err(SYNERR, "missing ';' in opclass definition\n"); | |
| 553 return; | |
| 554 } | |
| 555 next_char(); // Consume the ';' | |
| 556 // Add operand to tail of operand list | |
| 557 _AD.addForm(opc); | |
| 558 } | |
| 559 | |
| 560 //------------------------------ins_attr_parse--------------------------------- | |
| 561 void ADLParser::ins_attr_parse(void) { | |
| 562 char *ident; | |
| 563 char *aexpr; | |
| 564 AttributeForm *attrib; | |
| 565 | |
| 566 // get name for the instruction attribute | |
| 567 skipws(); // Skip leading whitespace | |
| 568 if( (ident = get_unique_ident(_globalNames,"inst_attrib")) == NULL ) | |
| 569 return; | |
| 570 // Debugging Stuff | |
| 571 if (_AD._adl_debug > 1) fprintf(stderr,"Parsing Ins_Attribute Form %s\n", ident); | |
| 572 | |
| 573 // Get default value of the instruction attribute | |
| 574 skipws(); // Skip whitespace | |
| 575 if ((aexpr = get_paren_expr("attribute default expression string")) == NULL) { | |
| 576 parse_err(SYNERR, "missing '(' in ins_attrib definition\n"); | |
| 577 return; | |
| 578 } | |
| 579 // Debug Stuff | |
| 580 if (_AD._adl_debug > 1) fprintf(stderr,"Attribute Expression: %s\n", aexpr); | |
| 581 | |
| 582 // Check for terminator | |
| 583 if (_curchar != ';') { | |
| 584 parse_err(SYNERR, "missing ';' in ins_attrib definition\n"); | |
| 585 return; | |
| 586 } | |
| 587 next_char(); // Advance past the ';' | |
| 588 | |
| 589 // Construct the attribute, record global name, and store in ArchDesc | |
| 590 attrib = new AttributeForm(ident, INS_ATTR, aexpr); | |
| 591 _globalNames.Insert(ident, attrib); // Add name to the name table | |
| 592 _AD.addForm(attrib); | |
| 593 } | |
| 594 | |
| 595 //------------------------------op_attr_parse---------------------------------- | |
| 596 void ADLParser::op_attr_parse(void) { | |
| 597 char *ident; | |
| 598 char *aexpr; | |
| 599 AttributeForm *attrib; | |
| 600 | |
| 601 // get name for the operand attribute | |
| 602 skipws(); // Skip leading whitespace | |
| 603 if( (ident = get_unique_ident(_globalNames,"op_attrib")) == NULL ) | |
| 604 return; | |
| 605 // Debugging Stuff | |
| 606 if (_AD._adl_debug > 1) fprintf(stderr,"Parsing Op_Attribute Form %s\n", ident); | |
| 607 | |
| 608 // Get default value of the instruction attribute | |
| 609 skipws(); // Skip whitespace | |
| 610 if ((aexpr = get_paren_expr("attribute default expression string")) == NULL) { | |
| 611 parse_err(SYNERR, "missing '(' in op_attrib definition\n"); | |
| 612 return; | |
| 613 } | |
| 614 // Debug Stuff | |
| 615 if (_AD._adl_debug > 1) fprintf(stderr,"Attribute Expression: %s\n", aexpr); | |
| 616 | |
| 617 // Check for terminator | |
| 618 if (_curchar != ';') { | |
| 619 parse_err(SYNERR, "missing ';' in op_attrib definition\n"); | |
| 620 return; | |
| 621 } | |
| 622 next_char(); // Advance past the ';' | |
| 623 | |
| 624 // Construct the attribute, record global name, and store in ArchDesc | |
| 625 attrib = new AttributeForm(ident, OP_ATTR, aexpr); | |
| 626 _globalNames.Insert(ident, attrib); | |
| 627 _AD.addForm(attrib); | |
| 628 } | |
| 629 | |
| 630 //------------------------------definitions_parse----------------------------------- | |
| 631 void ADLParser::definitions_parse(void) { | |
| 632 skipws(); // Skip leading whitespace | |
| 633 if (_curchar == '%' && *(_ptr+1) == '{') { | |
| 634 next_char(); next_char(); // Skip "%{" | |
| 635 skipws(); | |
| 636 while (_curchar != '%' && *(_ptr+1) != '}') { | |
| 637 // Process each definition until finding closing string "%}" | |
| 638 char *token = get_ident(); | |
| 639 if (token == NULL) { | |
| 640 parse_err(SYNERR, "missing identifier inside definitions block.\n"); | |
| 641 return; | |
| 642 } | |
| 643 if (strcmp(token,"int_def")==0) { int_def_parse(); } | |
| 644 // if (strcmp(token,"str_def")==0) { str_def_parse(); } | |
| 645 skipws(); | |
| 646 } | |
| 647 } | |
| 648 else { | |
| 649 parse_err(SYNERR, "Missing %%{ ... %%} block after definitions keyword.\n"); | |
| 650 return; | |
| 651 } | |
| 652 } | |
| 653 | |
| 654 //------------------------------int_def_parse---------------------------------- | |
| 655 // Parse Example: | |
| 656 // int_def MEMORY_REF_COST ( 200, DEFAULT_COST * 2); | |
| 657 // <keyword> <name> ( <int_value>, <description> ); | |
| 658 // | |
| 659 void ADLParser::int_def_parse(void) { | |
| 660 char *name = NULL; // Name of definition | |
| 661 char *value = NULL; // its value, | |
| 662 int int_value = -1; // positive values only | |
| 663 char *description = NULL; // textual description | |
| 664 | |
| 665 // Get definition name | |
| 666 skipws(); // Skip whitespace | |
| 667 name = get_ident(); | |
| 668 if (name == NULL) { | |
| 669 parse_err(SYNERR, "missing definition name after int_def\n"); | |
| 670 return; | |
| 671 } | |
| 672 | |
| 673 // Check for value of int_def dname( integer_value [, string_expression ] ) | |
| 674 skipws(); | |
| 675 if (_curchar == '(') { | |
| 676 | |
| 677 // Parse the integer value. | |
| 678 next_char(); | |
| 679 value = get_ident(); | |
| 680 if (value == NULL) { | |
| 681 parse_err(SYNERR, "missing value in int_def\n"); | |
| 682 return; | |
| 683 } | |
| 684 if( !is_int_token(value, int_value) ) { | |
| 685 parse_err(SYNERR, "value in int_def is not recognized as integer\n"); | |
| 686 return; | |
| 687 } | |
| 688 skipws(); | |
| 689 | |
| 690 // Check for description | |
| 691 if (_curchar == ',') { | |
| 692 next_char(); // skip ',' | |
| 693 | |
| 694 description = get_expr("int_def description", ")"); | |
| 695 if (description == NULL) { | |
| 696 parse_err(SYNERR, "invalid or missing description in int_def\n"); | |
| 697 return; | |
| 698 } | |
| 699 trim(description); | |
| 700 } | |
| 701 | |
| 702 if (_curchar != ')') { | |
| 703 parse_err(SYNERR, "missing ')' in register definition statement\n"); | |
| 704 return; | |
| 705 } | |
| 706 next_char(); | |
| 707 } | |
| 708 | |
| 709 // Check for closing ';' | |
| 710 skipws(); | |
| 711 if (_curchar != ';') { | |
| 712 parse_err(SYNERR, "missing ';' after int_def\n"); | |
| 713 return; | |
| 714 } | |
| 715 next_char(); // move past ';' | |
| 716 | |
| 717 // Debug Stuff | |
| 718 if (_AD._adl_debug > 1) { | |
| 719 fprintf(stderr,"int_def: %s ( %s, %s )\n", name, | |
| 720 (value), (description ? description : "")); | |
| 721 } | |
| 722 | |
| 723 // Record new definition. | |
| 724 Expr *expr = new Expr(name, description, int_value, int_value); | |
| 725 const Expr *old_expr = _AD.globalDefs().define(name, expr); | |
| 726 if (old_expr != NULL) { | |
| 727 parse_err(SYNERR, "Duplicate definition\n"); | |
| 728 return; | |
| 729 } | |
| 730 | |
| 731 return; | |
| 732 } | |
| 733 | |
| 734 | |
| 735 //------------------------------source_parse----------------------------------- | |
| 736 void ADLParser::source_parse(void) { | |
| 737 SourceForm *source; // Encode class for instruction/operand | |
| 738 char *rule = NULL; // String representation of encode rule | |
| 739 | |
| 740 skipws(); // Skip leading whitespace | |
| 741 if ( (rule = find_cpp_block("source block")) == NULL ) { | |
| 742 parse_err(SYNERR, "incorrect or missing block for 'source'.\n"); | |
| 743 return; | |
| 744 } | |
| 745 // Debug Stuff | |
| 746 if (_AD._adl_debug > 1) fprintf(stderr,"Source Form: %s\n", rule); | |
| 747 | |
| 748 source = new SourceForm(rule); // Build new Source object | |
| 749 _AD.addForm(source); | |
| 750 // skipws(); | |
| 751 } | |
| 752 | |
| 753 //------------------------------source_hpp_parse------------------------------- | |
| 754 // Parse a source_hpp %{ ... %} block. | |
| 755 // The code gets stuck into the ad_<arch>.hpp file. | |
| 756 // If the source_hpp block appears before the register block in the AD | |
| 757 // file, it goes up at the very top of the ad_<arch>.hpp file, so that | |
| 758 // it can be used by register encodings, etc. Otherwise, it goes towards | |
| 759 // the bottom, where it's useful as a global definition to *.cpp files. | |
| 760 void ADLParser::source_hpp_parse(void) { | |
| 761 char *rule = NULL; // String representation of encode rule | |
| 762 | |
| 763 skipws(); // Skip leading whitespace | |
| 764 if ( (rule = find_cpp_block("source_hpp block")) == NULL ) { | |
| 765 parse_err(SYNERR, "incorrect or missing block for 'source_hpp'.\n"); | |
| 766 return; | |
| 767 } | |
| 768 // Debug Stuff | |
| 769 if (_AD._adl_debug > 1) fprintf(stderr,"Header Form: %s\n", rule); | |
| 770 | |
| 771 if (_AD.get_registers() == NULL) { | |
| 772 // Very early in the file, before reg_defs, we collect pre-headers. | |
| 773 PreHeaderForm* pre_header = new PreHeaderForm(rule); | |
| 774 _AD.addForm(pre_header); | |
| 775 } else { | |
| 776 // Normally, we collect header info, placed at the bottom of the hpp file. | |
| 777 HeaderForm* header = new HeaderForm(rule); | |
| 778 _AD.addForm(header); | |
| 779 } | |
| 780 } | |
| 781 | |
| 782 //------------------------------reg_parse-------------------------------------- | |
| 783 void ADLParser::reg_parse(void) { | |
|
6179
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
4121
diff
changeset
|
784 RegisterForm *regBlock = _AD.get_registers(); // Information about registers encoding |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
4121
diff
changeset
|
785 if (regBlock == NULL) { |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
4121
diff
changeset
|
786 // Create the RegisterForm for the architecture description. |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
4121
diff
changeset
|
787 regBlock = new RegisterForm(); // Build new Source object |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
4121
diff
changeset
|
788 _AD.addForm(regBlock); |
|
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
4121
diff
changeset
|
789 } |
| 0 | 790 |
| 791 skipws(); // Skip leading whitespace | |
| 792 if (_curchar == '%' && *(_ptr+1) == '{') { | |
| 793 next_char(); next_char(); // Skip "%{" | |
| 794 skipws(); | |
| 795 while (_curchar != '%' && *(_ptr+1) != '}') { | |
| 796 char *token = get_ident(); | |
| 797 if (token == NULL) { | |
| 798 parse_err(SYNERR, "missing identifier inside register block.\n"); | |
| 799 return; | |
| 800 } | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
801 if (strcmp(token,"reg_def")==0) { reg_def_parse(); } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
802 else if (strcmp(token,"reg_class")==0) { reg_class_parse(); } |
|
23049
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
803 else if (strcmp(token, "reg_class_dynamic") == 0) { reg_class_dynamic_parse(); } |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
804 else if (strcmp(token,"alloc_class")==0) { alloc_class_parse(); } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
805 else if (strcmp(token,"#define")==0) { preproc_define(); } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
806 else { parse_err(SYNERR, "bad token %s inside register block.\n", token); break; } |
| 0 | 807 skipws(); |
| 808 } | |
| 809 } | |
| 810 else { | |
| 811 parse_err(SYNERR, "Missing %c{ ... %c} block after register keyword.\n",'%','%'); | |
| 812 return; | |
| 813 } | |
| 814 } | |
| 815 | |
| 816 //------------------------------encode_parse----------------------------------- | |
| 817 void ADLParser::encode_parse(void) { | |
| 818 EncodeForm *encBlock; // Information about instruction/operand encoding | |
| 819 | |
| 820 _AD.getForm(&encBlock); | |
| 821 if ( encBlock == NULL) { | |
| 822 // Create the EncodeForm for the architecture description. | |
| 823 encBlock = new EncodeForm(); // Build new Source object | |
| 824 _AD.addForm(encBlock); | |
| 825 } | |
| 826 | |
| 827 skipws(); // Skip leading whitespace | |
| 828 if (_curchar == '%' && *(_ptr+1) == '{') { | |
| 829 next_char(); next_char(); // Skip "%{" | |
| 830 skipws(); | |
| 831 while (_curchar != '%' && *(_ptr+1) != '}') { | |
| 832 char *token = get_ident(); | |
| 833 if (token == NULL) { | |
| 834 parse_err(SYNERR, "missing identifier inside encoding block.\n"); | |
| 835 return; | |
| 836 } | |
| 837 if (strcmp(token,"enc_class")==0) { enc_class_parse(); } | |
| 838 skipws(); | |
| 839 } | |
| 840 } | |
| 841 else { | |
| 842 parse_err(SYNERR, "Missing %c{ ... %c} block after encode keyword.\n",'%','%'); | |
| 843 return; | |
| 844 } | |
| 845 } | |
| 846 | |
| 847 //------------------------------enc_class_parse-------------------------------- | |
| 848 void ADLParser::enc_class_parse(void) { | |
| 849 char *ec_name; // Name of encoding class being defined | |
| 850 | |
| 851 // Get encoding class name | |
| 852 skipws(); // Skip whitespace | |
| 853 ec_name = get_ident(); | |
| 854 if (ec_name == NULL) { | |
| 855 parse_err(SYNERR, "missing encoding class name after encode.\n"); | |
| 856 return; | |
| 857 } | |
| 858 | |
| 859 EncClass *encoding = _AD._encode->add_EncClass(ec_name); | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
860 encoding->_linenum = linenum(); |
| 0 | 861 |
| 862 skipws(); // Skip leading whitespace | |
| 863 // Check for optional parameter list | |
| 864 if (_curchar == '(') { | |
| 865 do { | |
| 866 char *pType = NULL; // parameter type | |
| 867 char *pName = NULL; // parameter name | |
| 868 | |
| 869 next_char(); // skip open paren & comma characters | |
| 870 skipws(); | |
| 871 if (_curchar == ')') break; | |
| 872 | |
| 873 // Get parameter type | |
| 874 pType = get_ident(); | |
| 875 if (pType == NULL) { | |
| 876 parse_err(SYNERR, "parameter type expected at %c\n", _curchar); | |
| 877 return; | |
| 878 } | |
| 879 | |
| 880 skipws(); | |
| 881 // Get parameter name | |
| 882 pName = get_ident(); | |
| 883 if (pName == NULL) { | |
| 884 parse_err(SYNERR, "parameter name expected at %c\n", _curchar); | |
| 885 return; | |
| 886 } | |
| 887 | |
| 888 // Record parameter type and name | |
| 889 encoding->add_parameter( pType, pName ); | |
| 890 | |
| 891 skipws(); | |
| 892 } while(_curchar == ','); | |
| 893 | |
| 894 if (_curchar != ')') parse_err(SYNERR, "missing ')'\n"); | |
| 895 else { | |
| 896 next_char(); // Skip ')' | |
| 897 } | |
| 898 } // Done with parameter list | |
| 899 | |
| 900 skipws(); | |
| 901 // Check for block starting delimiters | |
| 902 if ((_curchar != '%') || (*(_ptr+1) != '{')) { // If not open block | |
| 903 parse_err(SYNERR, "missing '%c{' in enc_class definition\n", '%'); | |
| 904 return; | |
| 905 } | |
| 906 next_char(); // Skip '%' | |
| 907 next_char(); // Skip '{' | |
| 908 | |
| 909 enc_class_parse_block(encoding, ec_name); | |
| 910 } | |
| 911 | |
| 912 | |
| 913 void ADLParser::enc_class_parse_block(EncClass* encoding, char* ec_name) { | |
| 914 skipws_no_preproc(); // Skip leading whitespace | |
| 915 // Prepend location descriptor, for debugging; cf. ADLParser::find_cpp_block | |
| 916 if (_AD._adlocation_debug) { | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
917 encoding->add_code(get_line_string()); |
| 0 | 918 } |
| 919 | |
| 920 // Collect the parts of the encode description | |
| 921 // (1) strings that are passed through to output | |
| 922 // (2) replacement/substitution variable, preceeded by a '$' | |
| 923 while ( (_curchar != '%') && (*(_ptr+1) != '}') ) { | |
| 924 | |
| 925 // (1) | |
| 926 // Check if there is a string to pass through to output | |
| 927 char *start = _ptr; // Record start of the next string | |
| 928 while ((_curchar != '$') && ((_curchar != '%') || (*(_ptr+1) != '}')) ) { | |
| 929 // If at the start of a comment, skip past it | |
| 930 if( (_curchar == '/') && ((*(_ptr+1) == '/') || (*(_ptr+1) == '*')) ) { | |
| 931 skipws_no_preproc(); | |
| 932 } else { | |
| 933 // ELSE advance to the next character, or start of the next line | |
| 934 next_char_or_line(); | |
| 935 } | |
| 936 } | |
| 937 // If a string was found, terminate it and record in EncClass | |
| 938 if ( start != _ptr ) { | |
| 939 *_ptr = '\0'; // Terminate the string | |
| 940 encoding->add_code(start); | |
| 941 } | |
| 942 | |
| 943 // (2) | |
| 944 // If we are at a replacement variable, | |
| 945 // copy it and record in EncClass | |
| 2008 | 946 if (_curchar == '$') { |
| 0 | 947 // Found replacement Variable |
| 2008 | 948 char* rep_var = get_rep_var_ident_dup(); |
| 0 | 949 // Add flag to _strings list indicating we should check _rep_vars |
| 950 encoding->add_rep_var(rep_var); | |
| 951 } | |
| 952 } // end while part of format description | |
| 953 next_char(); // Skip '%' | |
| 954 next_char(); // Skip '}' | |
| 955 | |
| 956 skipws(); | |
| 957 | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
958 if (_AD._adlocation_debug) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
959 encoding->add_code(end_line_marker()); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
960 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
961 |
| 0 | 962 // Debug Stuff |
| 963 if (_AD._adl_debug > 1) fprintf(stderr,"EncodingClass Form: %s\n", ec_name); | |
| 964 } | |
| 965 | |
| 966 //------------------------------frame_parse----------------------------------- | |
| 967 void ADLParser::frame_parse(void) { | |
| 968 FrameForm *frame; // Information about stack-frame layout | |
| 969 char *desc = NULL; // String representation of frame | |
| 970 | |
| 971 skipws(); // Skip leading whitespace | |
| 972 | |
| 973 frame = new FrameForm(); // Build new Frame object | |
| 974 // Check for open block sequence | |
| 975 skipws(); // Skip leading whitespace | |
| 976 if (_curchar == '%' && *(_ptr+1) == '{') { | |
| 977 next_char(); next_char(); // Skip "%{" | |
| 978 skipws(); | |
| 979 while (_curchar != '%' && *(_ptr+1) != '}') { | |
| 980 char *token = get_ident(); | |
| 981 if (token == NULL) { | |
| 982 parse_err(SYNERR, "missing identifier inside frame block.\n"); | |
| 983 return; | |
| 984 } | |
| 985 if (strcmp(token,"stack_direction")==0) { | |
| 986 stack_dir_parse(frame); | |
| 987 } | |
| 988 if (strcmp(token,"sync_stack_slots")==0) { | |
| 989 sync_stack_slots_parse(frame); | |
| 990 } | |
| 991 if (strcmp(token,"frame_pointer")==0) { | |
| 992 frame_pointer_parse(frame, false); | |
| 993 } | |
| 994 if (strcmp(token,"interpreter_frame_pointer")==0) { | |
| 995 interpreter_frame_pointer_parse(frame, false); | |
| 996 } | |
| 997 if (strcmp(token,"inline_cache_reg")==0) { | |
| 998 inline_cache_parse(frame, false); | |
| 999 } | |
| 1000 if (strcmp(token,"compiler_method_oop_reg")==0) { | |
| 1001 parse_err(WARN, "Using obsolete Token, compiler_method_oop_reg"); | |
| 1002 skipws(); | |
| 1003 } | |
| 1004 if (strcmp(token,"interpreter_method_oop_reg")==0) { | |
| 1005 interpreter_method_oop_parse(frame, false); | |
| 1006 } | |
| 1007 if (strcmp(token,"cisc_spilling_operand_name")==0) { | |
| 1008 cisc_spilling_operand_name_parse(frame, false); | |
| 1009 } | |
| 1010 if (strcmp(token,"stack_alignment")==0) { | |
| 1011 stack_alignment_parse(frame); | |
| 1012 } | |
| 1013 if (strcmp(token,"return_addr")==0) { | |
| 1014 return_addr_parse(frame, false); | |
| 1015 } | |
| 1016 if (strcmp(token,"in_preserve_stack_slots")==0) { | |
| 1017 preserve_stack_parse(frame); | |
| 1018 } | |
| 1019 if (strcmp(token,"out_preserve_stack_slots")==0) { | |
| 1020 parse_err(WARN, "Using obsolete token, out_preserve_stack_slots"); | |
| 1021 skipws(); | |
| 1022 } | |
| 1023 if (strcmp(token,"varargs_C_out_slots_killed")==0) { | |
| 1024 frame->_varargs_C_out_slots_killed = parse_one_arg("varargs C out slots killed"); | |
| 1025 } | |
| 1026 if (strcmp(token,"calling_convention")==0) { | |
| 1027 frame->_calling_convention = calling_convention_parse(); | |
| 1028 } | |
| 1029 if (strcmp(token,"return_value")==0) { | |
| 1030 frame->_return_value = return_value_parse(); | |
| 1031 } | |
| 1032 if (strcmp(token,"c_frame_pointer")==0) { | |
| 1033 frame_pointer_parse(frame, true); | |
| 1034 } | |
| 1035 if (strcmp(token,"c_return_addr")==0) { | |
| 1036 return_addr_parse(frame, true); | |
| 1037 } | |
| 1038 if (strcmp(token,"c_calling_convention")==0) { | |
| 1039 frame->_c_calling_convention = calling_convention_parse(); | |
| 1040 } | |
| 1041 if (strcmp(token,"c_return_value")==0) { | |
| 1042 frame->_c_return_value = return_value_parse(); | |
| 1043 } | |
| 1044 | |
| 1045 skipws(); | |
| 1046 } | |
| 1047 } | |
| 1048 else { | |
| 1049 parse_err(SYNERR, "Missing %c{ ... %c} block after encode keyword.\n",'%','%'); | |
| 1050 return; | |
| 1051 } | |
| 1052 // All Java versions are required, native versions are optional | |
| 1053 if(frame->_frame_pointer == NULL) { | |
| 1054 parse_err(SYNERR, "missing frame pointer definition in frame section.\n"); | |
| 1055 return; | |
| 1056 } | |
| 1057 // !!!!! !!!!! | |
| 1058 // if(frame->_interpreter_frame_ptr_reg == NULL) { | |
| 1059 // parse_err(SYNERR, "missing interpreter frame pointer definition in frame section.\n"); | |
| 1060 // return; | |
| 1061 // } | |
| 1062 if(frame->_alignment == NULL) { | |
| 1063 parse_err(SYNERR, "missing alignment definition in frame section.\n"); | |
| 1064 return; | |
| 1065 } | |
| 1066 if(frame->_return_addr == NULL) { | |
| 1067 parse_err(SYNERR, "missing return address location in frame section.\n"); | |
| 1068 return; | |
| 1069 } | |
| 1070 if(frame->_in_preserve_slots == NULL) { | |
| 1071 parse_err(SYNERR, "missing stack slot preservation definition in frame section.\n"); | |
| 1072 return; | |
| 1073 } | |
| 1074 if(frame->_varargs_C_out_slots_killed == NULL) { | |
| 1075 parse_err(SYNERR, "missing varargs C out slots killed definition in frame section.\n"); | |
| 1076 return; | |
| 1077 } | |
| 1078 if(frame->_calling_convention == NULL) { | |
| 1079 parse_err(SYNERR, "missing calling convention definition in frame section.\n"); | |
| 1080 return; | |
| 1081 } | |
| 1082 if(frame->_return_value == NULL) { | |
| 1083 parse_err(SYNERR, "missing return value definition in frame section.\n"); | |
| 1084 return; | |
| 1085 } | |
| 1086 // Fill natives in identically with the Java versions if not present. | |
| 1087 if(frame->_c_frame_pointer == NULL) { | |
| 1088 frame->_c_frame_pointer = frame->_frame_pointer; | |
| 1089 } | |
| 1090 if(frame->_c_return_addr == NULL) { | |
| 1091 frame->_c_return_addr = frame->_return_addr; | |
| 1092 frame->_c_return_addr_loc = frame->_return_addr_loc; | |
| 1093 } | |
| 1094 if(frame->_c_calling_convention == NULL) { | |
| 1095 frame->_c_calling_convention = frame->_calling_convention; | |
| 1096 } | |
| 1097 if(frame->_c_return_value == NULL) { | |
| 1098 frame->_c_return_value = frame->_return_value; | |
| 1099 } | |
| 1100 | |
| 1101 // Debug Stuff | |
| 1102 if (_AD._adl_debug > 1) fprintf(stderr,"Frame Form: %s\n", desc); | |
| 1103 | |
| 1104 // Create the EncodeForm for the architecture description. | |
| 1105 _AD.addForm(frame); | |
| 1106 // skipws(); | |
| 1107 } | |
| 1108 | |
| 1109 //------------------------------stack_dir_parse-------------------------------- | |
| 1110 void ADLParser::stack_dir_parse(FrameForm *frame) { | |
| 1111 char *direction = parse_one_arg("stack direction entry"); | |
| 1112 if (strcmp(direction, "TOWARDS_LOW") == 0) { | |
| 1113 frame->_direction = false; | |
| 1114 } | |
| 1115 else if (strcmp(direction, "TOWARDS_HIGH") == 0) { | |
| 1116 frame->_direction = true; | |
| 1117 } | |
| 1118 else { | |
| 1119 parse_err(SYNERR, "invalid value inside stack direction entry.\n"); | |
| 1120 return; | |
| 1121 } | |
| 1122 } | |
| 1123 | |
| 1124 //------------------------------sync_stack_slots_parse------------------------- | |
| 1125 void ADLParser::sync_stack_slots_parse(FrameForm *frame) { | |
| 1126 // Assign value into frame form | |
| 1127 frame->_sync_stack_slots = parse_one_arg("sync stack slots entry"); | |
| 1128 } | |
| 1129 | |
| 1130 //------------------------------frame_pointer_parse---------------------------- | |
| 1131 void ADLParser::frame_pointer_parse(FrameForm *frame, bool native) { | |
| 1132 char *frame_pointer = parse_one_arg("frame pointer entry"); | |
| 1133 // Assign value into frame form | |
| 1134 if (native) { frame->_c_frame_pointer = frame_pointer; } | |
| 1135 else { frame->_frame_pointer = frame_pointer; } | |
| 1136 } | |
| 1137 | |
| 1138 //------------------------------interpreter_frame_pointer_parse---------------------------- | |
| 1139 void ADLParser::interpreter_frame_pointer_parse(FrameForm *frame, bool native) { | |
| 1140 frame->_interpreter_frame_pointer_reg = parse_one_arg("interpreter frame pointer entry"); | |
| 1141 } | |
| 1142 | |
| 1143 //------------------------------inline_cache_parse----------------------------- | |
| 1144 void ADLParser::inline_cache_parse(FrameForm *frame, bool native) { | |
| 1145 frame->_inline_cache_reg = parse_one_arg("inline cache reg entry"); | |
| 1146 } | |
| 1147 | |
| 1148 //------------------------------interpreter_method_oop_parse------------------ | |
| 1149 void ADLParser::interpreter_method_oop_parse(FrameForm *frame, bool native) { | |
| 1150 frame->_interpreter_method_oop_reg = parse_one_arg("method oop reg entry"); | |
| 1151 } | |
| 1152 | |
| 1153 //------------------------------cisc_spilling_operand_parse--------------------- | |
| 1154 void ADLParser::cisc_spilling_operand_name_parse(FrameForm *frame, bool native) { | |
| 1155 frame->_cisc_spilling_operand_name = parse_one_arg("cisc spilling operand name"); | |
| 1156 } | |
| 1157 | |
| 1158 //------------------------------stack_alignment_parse-------------------------- | |
| 1159 void ADLParser::stack_alignment_parse(FrameForm *frame) { | |
| 1160 char *alignment = parse_one_arg("stack alignment entry"); | |
| 1161 // Assign value into frame | |
| 1162 frame->_alignment = alignment; | |
| 1163 } | |
| 1164 | |
| 1165 //------------------------------parse_one_arg------------------------------- | |
| 1166 char *ADLParser::parse_one_arg(const char *description) { | |
| 1167 char *token = NULL; | |
| 1168 if(_curchar == '(') { | |
| 1169 next_char(); | |
| 1170 skipws(); | |
| 1171 token = get_expr(description, ")"); | |
| 1172 if (token == NULL) { | |
| 1173 parse_err(SYNERR, "missing value inside %s.\n", description); | |
| 1174 return NULL; | |
| 1175 } | |
| 1176 next_char(); // skip the close paren | |
| 1177 if(_curchar != ';') { // check for semi-colon | |
| 1178 parse_err(SYNERR, "missing %c in.\n", ';', description); | |
| 1179 return NULL; | |
| 1180 } | |
| 1181 next_char(); // skip the semi-colon | |
| 1182 } | |
| 1183 else { | |
| 1184 parse_err(SYNERR, "Missing %c in.\n", '(', description); | |
| 1185 return NULL; | |
| 1186 } | |
| 1187 | |
| 1188 trim(token); | |
| 1189 return token; | |
| 1190 } | |
| 1191 | |
| 1192 //------------------------------return_addr_parse------------------------------ | |
| 1193 void ADLParser::return_addr_parse(FrameForm *frame, bool native) { | |
| 1194 bool in_register = true; | |
| 1195 if(_curchar == '(') { | |
| 1196 next_char(); | |
| 1197 skipws(); | |
| 1198 char *token = get_ident(); | |
| 1199 if (token == NULL) { | |
| 1200 parse_err(SYNERR, "missing value inside return address entry.\n"); | |
| 1201 return; | |
| 1202 } | |
| 1203 // check for valid values for stack/register | |
| 1204 if (strcmp(token, "REG") == 0) { | |
| 1205 in_register = true; | |
| 1206 } | |
| 1207 else if (strcmp(token, "STACK") == 0) { | |
| 1208 in_register = false; | |
| 1209 } | |
| 1210 else { | |
| 1211 parse_err(SYNERR, "invalid value inside return_address entry.\n"); | |
| 1212 return; | |
| 1213 } | |
| 1214 if (native) { frame->_c_return_addr_loc = in_register; } | |
| 1215 else { frame->_return_addr_loc = in_register; } | |
| 1216 | |
| 1217 // Parse expression that specifies register or stack position | |
| 1218 skipws(); | |
| 1219 char *token2 = get_expr("return address entry", ")"); | |
| 1220 if (token2 == NULL) { | |
| 1221 parse_err(SYNERR, "missing value inside return address entry.\n"); | |
| 1222 return; | |
| 1223 } | |
| 1224 next_char(); // skip the close paren | |
| 1225 if (native) { frame->_c_return_addr = token2; } | |
| 1226 else { frame->_return_addr = token2; } | |
| 1227 | |
| 1228 if(_curchar != ';') { // check for semi-colon | |
| 1229 parse_err(SYNERR, "missing %c in return address entry.\n", ';'); | |
| 1230 return; | |
| 1231 } | |
| 1232 next_char(); // skip the semi-colon | |
| 1233 } | |
| 1234 else { | |
| 1235 parse_err(SYNERR, "Missing %c in return_address entry.\n", '('); | |
| 1236 } | |
| 1237 } | |
| 1238 | |
| 1239 //------------------------------preserve_stack_parse--------------------------- | |
| 1240 void ADLParser::preserve_stack_parse(FrameForm *frame) { | |
| 1241 if(_curchar == '(') { | |
| 1242 char *token = get_paren_expr("preserve_stack_slots"); | |
| 1243 frame->_in_preserve_slots = token; | |
| 1244 | |
| 1245 if(_curchar != ';') { // check for semi-colon | |
| 1246 parse_err(SYNERR, "missing %c in preserve stack slot entry.\n", ';'); | |
| 1247 return; | |
| 1248 } | |
| 1249 next_char(); // skip the semi-colon | |
| 1250 } | |
| 1251 else { | |
| 1252 parse_err(SYNERR, "Missing %c in preserve stack slot entry.\n", '('); | |
| 1253 } | |
| 1254 } | |
| 1255 | |
| 1256 //------------------------------calling_convention_parse----------------------- | |
| 1257 char *ADLParser::calling_convention_parse() { | |
| 1258 char *desc = NULL; // String representation of calling_convention | |
| 1259 | |
| 1260 skipws(); // Skip leading whitespace | |
| 1261 if ( (desc = find_cpp_block("calling convention block")) == NULL ) { | |
| 1262 parse_err(SYNERR, "incorrect or missing block for 'calling_convention'.\n"); | |
| 1263 } | |
| 1264 return desc; | |
| 1265 } | |
| 1266 | |
| 1267 //------------------------------return_value_parse----------------------------- | |
| 1268 char *ADLParser::return_value_parse() { | |
| 1269 char *desc = NULL; // String representation of calling_convention | |
| 1270 | |
| 1271 skipws(); // Skip leading whitespace | |
| 1272 if ( (desc = find_cpp_block("return value block")) == NULL ) { | |
| 1273 parse_err(SYNERR, "incorrect or missing block for 'return_value'.\n"); | |
| 1274 } | |
| 1275 return desc; | |
| 1276 } | |
| 1277 | |
| 1278 //------------------------------ins_pipe_parse--------------------------------- | |
| 1279 void ADLParser::ins_pipe_parse(InstructForm &instr) { | |
| 1280 char * ident; | |
| 1281 | |
| 1282 skipws(); | |
| 1283 if ( _curchar != '(' ) { // Check for delimiter | |
| 1284 parse_err(SYNERR, "missing \"(\" in ins_pipe definition\n"); | |
| 1285 return; | |
| 1286 } | |
| 1287 | |
| 1288 next_char(); | |
| 1289 ident = get_ident(); // Grab next identifier | |
| 1290 | |
| 1291 if (ident == NULL) { | |
| 1292 parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar); | |
| 1293 return; | |
| 1294 } | |
| 1295 | |
| 1296 skipws(); | |
| 1297 if ( _curchar != ')' ) { // Check for delimiter | |
| 1298 parse_err(SYNERR, "missing \")\" in ins_pipe definition\n"); | |
| 1299 return; | |
| 1300 } | |
| 1301 | |
| 1302 next_char(); // skip the close paren | |
| 1303 if(_curchar != ';') { // check for semi-colon | |
| 1304 parse_err(SYNERR, "missing %c in return value entry.\n", ';'); | |
| 1305 return; | |
| 1306 } | |
| 1307 next_char(); // skip the semi-colon | |
| 1308 | |
| 1309 // Check ident for validity | |
| 1310 if (_AD._pipeline && !_AD._pipeline->_classlist.search(ident)) { | |
| 1311 parse_err(SYNERR, "\"%s\" is not a valid pipeline class\n", ident); | |
| 1312 return; | |
| 1313 } | |
| 1314 | |
| 1315 // Add this instruction to the list in the pipeline class | |
| 1316 _AD._pipeline->_classdict[ident]->is_pipeclass()->_instructs.addName(instr._ident); | |
| 1317 | |
| 1318 // Set the name of the pipeline class in the instruction | |
| 1319 instr._ins_pipe = ident; | |
| 1320 return; | |
| 1321 } | |
| 1322 | |
| 1323 //------------------------------pipe_parse------------------------------------- | |
| 1324 void ADLParser::pipe_parse(void) { | |
| 1325 PipelineForm *pipeline; // Encode class for instruction/operand | |
| 1326 char * ident; | |
| 1327 | |
| 1328 pipeline = new PipelineForm(); // Build new Source object | |
| 1329 _AD.addForm(pipeline); | |
| 1330 | |
| 1331 skipws(); // Skip leading whitespace | |
| 1332 // Check for block delimiter | |
| 1333 if ( (_curchar != '%') | |
| 1334 || ( next_char(), (_curchar != '{')) ) { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
1335 parse_err(SYNERR, "missing '%%{' in pipeline definition\n"); |
| 0 | 1336 return; |
| 1337 } | |
| 1338 next_char(); // Maintain the invariant | |
| 1339 do { | |
| 1340 ident = get_ident(); // Grab next identifier | |
| 1341 if (ident == NULL) { | |
| 1342 parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar); | |
| 1343 continue; | |
| 1344 } | |
| 1345 if (!strcmp(ident, "resources" )) resource_parse(*pipeline); | |
| 1346 else if (!strcmp(ident, "pipe_desc" )) pipe_desc_parse(*pipeline); | |
| 1347 else if (!strcmp(ident, "pipe_class")) pipe_class_parse(*pipeline); | |
| 1348 else if (!strcmp(ident, "define")) { | |
| 1349 skipws(); | |
| 1350 if ( (_curchar != '%') | |
| 1351 || ( next_char(), (_curchar != '{')) ) { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
1352 parse_err(SYNERR, "expected '%%{'\n"); |
| 0 | 1353 return; |
| 1354 } | |
| 1355 next_char(); skipws(); | |
| 1356 | |
| 1357 char *node_class = get_ident(); | |
| 1358 if (node_class == NULL) { | |
| 1359 parse_err(SYNERR, "expected identifier, found \"%c\"\n", _curchar); | |
| 1360 return; | |
| 1361 } | |
| 1362 | |
| 1363 skipws(); | |
| 1364 if (_curchar != ',' && _curchar != '=') { | |
| 1365 parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar); | |
| 1366 break; | |
| 1367 } | |
| 1368 next_char(); skipws(); | |
| 1369 | |
| 1370 char *pipe_class = get_ident(); | |
| 1371 if (pipe_class == NULL) { | |
| 1372 parse_err(SYNERR, "expected identifier, found \"%c\"\n", _curchar); | |
| 1373 return; | |
| 1374 } | |
| 1375 if (_curchar != ';' ) { | |
| 1376 parse_err(SYNERR, "expected `;`, found '%c'\n", _curchar); | |
| 1377 break; | |
| 1378 } | |
| 1379 next_char(); // Skip over semi-colon | |
| 1380 | |
| 1381 skipws(); | |
| 1382 if ( (_curchar != '%') | |
| 1383 || ( next_char(), (_curchar != '}')) ) { | |
| 1384 parse_err(SYNERR, "expected '%%}', found \"%c\"\n", _curchar); | |
| 1385 } | |
| 1386 next_char(); | |
| 1387 | |
| 1388 // Check ident for validity | |
| 1389 if (_AD._pipeline && !_AD._pipeline->_classlist.search(pipe_class)) { | |
| 1390 parse_err(SYNERR, "\"%s\" is not a valid pipeline class\n", pipe_class); | |
| 1391 return; | |
| 1392 } | |
| 1393 | |
| 1394 // Add this machine node to the list in the pipeline class | |
| 1395 _AD._pipeline->_classdict[pipe_class]->is_pipeclass()->_instructs.addName(node_class); | |
| 1396 | |
| 1397 MachNodeForm *machnode = new MachNodeForm(node_class); // Create new machnode form | |
| 1398 machnode->_machnode_pipe = pipe_class; | |
| 1399 | |
| 1400 _AD.addForm(machnode); | |
| 1401 } | |
| 1402 else if (!strcmp(ident, "attributes")) { | |
| 6850 | 1403 bool vsi_seen = false; |
| 0 | 1404 |
| 1405 skipws(); | |
| 1406 if ( (_curchar != '%') | |
| 1407 || ( next_char(), (_curchar != '{')) ) { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
1408 parse_err(SYNERR, "expected '%%{'\n"); |
| 0 | 1409 return; |
| 1410 } | |
| 1411 next_char(); skipws(); | |
| 1412 | |
| 1413 while (_curchar != '%') { | |
| 1414 ident = get_ident(); | |
| 1415 if (ident == NULL) | |
| 1416 break; | |
| 1417 | |
| 1418 if (!strcmp(ident, "variable_size_instructions")) { | |
| 1419 skipws(); | |
| 1420 if (_curchar == ';') { | |
| 1421 next_char(); skipws(); | |
| 1422 } | |
| 1423 | |
| 1424 pipeline->_variableSizeInstrs = true; | |
| 1425 vsi_seen = true; | |
| 1426 continue; | |
| 1427 } | |
| 1428 | |
| 1429 if (!strcmp(ident, "fixed_size_instructions")) { | |
| 1430 skipws(); | |
| 1431 if (_curchar == ';') { | |
| 1432 next_char(); skipws(); | |
| 1433 } | |
| 1434 | |
| 1435 pipeline->_variableSizeInstrs = false; | |
| 1436 vsi_seen = true; | |
| 1437 continue; | |
| 1438 } | |
| 1439 | |
| 1440 if (!strcmp(ident, "branch_has_delay_slot")) { | |
| 1441 skipws(); | |
| 1442 if (_curchar == ';') { | |
| 1443 next_char(); skipws(); | |
| 1444 } | |
| 1445 | |
| 1446 pipeline->_branchHasDelaySlot = true; | |
| 1447 continue; | |
| 1448 } | |
| 1449 | |
| 1450 if (!strcmp(ident, "max_instructions_per_bundle")) { | |
| 1451 skipws(); | |
| 1452 if (_curchar != '=') { | |
| 1453 parse_err(SYNERR, "expected `=`\n"); | |
| 1454 break; | |
| 1455 } | |
| 1456 | |
| 1457 next_char(); skipws(); | |
| 1458 pipeline->_maxInstrsPerBundle = get_int(); | |
| 1459 skipws(); | |
| 1460 | |
| 1461 if (_curchar == ';') { | |
| 1462 next_char(); skipws(); | |
| 1463 } | |
| 1464 | |
| 1465 continue; | |
| 1466 } | |
| 1467 | |
| 1468 if (!strcmp(ident, "max_bundles_per_cycle")) { | |
| 1469 skipws(); | |
| 1470 if (_curchar != '=') { | |
| 1471 parse_err(SYNERR, "expected `=`\n"); | |
| 1472 break; | |
| 1473 } | |
| 1474 | |
| 1475 next_char(); skipws(); | |
| 1476 pipeline->_maxBundlesPerCycle = get_int(); | |
| 1477 skipws(); | |
| 1478 | |
| 1479 if (_curchar == ';') { | |
| 1480 next_char(); skipws(); | |
| 1481 } | |
| 1482 | |
| 1483 continue; | |
| 1484 } | |
| 1485 | |
| 1486 if (!strcmp(ident, "instruction_unit_size")) { | |
| 1487 skipws(); | |
| 1488 if (_curchar != '=') { | |
| 1489 parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar); | |
| 1490 break; | |
| 1491 } | |
| 1492 | |
| 1493 next_char(); skipws(); | |
| 1494 pipeline->_instrUnitSize = get_int(); | |
| 1495 skipws(); | |
| 1496 | |
| 1497 if (_curchar == ';') { | |
| 1498 next_char(); skipws(); | |
| 1499 } | |
| 1500 | |
| 1501 continue; | |
| 1502 } | |
| 1503 | |
| 1504 if (!strcmp(ident, "bundle_unit_size")) { | |
| 1505 skipws(); | |
| 1506 if (_curchar != '=') { | |
| 1507 parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar); | |
| 1508 break; | |
| 1509 } | |
| 1510 | |
| 1511 next_char(); skipws(); | |
| 1512 pipeline->_bundleUnitSize = get_int(); | |
| 1513 skipws(); | |
| 1514 | |
| 1515 if (_curchar == ';') { | |
| 1516 next_char(); skipws(); | |
| 1517 } | |
| 1518 | |
| 1519 continue; | |
| 1520 } | |
| 1521 | |
| 1522 if (!strcmp(ident, "instruction_fetch_unit_size")) { | |
| 1523 skipws(); | |
| 1524 if (_curchar != '=') { | |
| 1525 parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar); | |
| 1526 break; | |
| 1527 } | |
| 1528 | |
| 1529 next_char(); skipws(); | |
| 1530 pipeline->_instrFetchUnitSize = get_int(); | |
| 1531 skipws(); | |
| 1532 | |
| 1533 if (_curchar == ';') { | |
| 1534 next_char(); skipws(); | |
| 1535 } | |
| 1536 | |
| 1537 continue; | |
| 1538 } | |
| 1539 | |
| 1540 if (!strcmp(ident, "instruction_fetch_units")) { | |
| 1541 skipws(); | |
| 1542 if (_curchar != '=') { | |
| 1543 parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar); | |
| 1544 break; | |
| 1545 } | |
| 1546 | |
| 1547 next_char(); skipws(); | |
| 1548 pipeline->_instrFetchUnits = get_int(); | |
| 1549 skipws(); | |
| 1550 | |
| 1551 if (_curchar == ';') { | |
| 1552 next_char(); skipws(); | |
| 1553 } | |
| 1554 | |
| 1555 continue; | |
| 1556 } | |
| 1557 | |
| 1558 if (!strcmp(ident, "nops")) { | |
| 1559 skipws(); | |
| 1560 if (_curchar != '(') { | |
| 1561 parse_err(SYNERR, "expected `(`, found '%c'\n", _curchar); | |
| 1562 break; | |
| 1563 } | |
| 1564 | |
| 1565 next_char(); skipws(); | |
| 1566 | |
| 1567 while (_curchar != ')') { | |
| 1568 ident = get_ident(); | |
| 1569 if (ident == NULL) { | |
| 1570 parse_err(SYNERR, "expected identifier for nop instruction, found '%c'\n", _curchar); | |
| 1571 break; | |
| 1572 } | |
| 1573 | |
| 1574 pipeline->_noplist.addName(ident); | |
| 1575 pipeline->_nopcnt++; | |
| 1576 skipws(); | |
| 1577 | |
| 1578 if (_curchar == ',') { | |
| 1579 next_char(); skipws(); | |
| 1580 } | |
| 1581 } | |
| 1582 | |
| 1583 next_char(); skipws(); | |
| 1584 | |
| 1585 if (_curchar == ';') { | |
| 1586 next_char(); skipws(); | |
| 1587 } | |
| 1588 | |
| 1589 continue; | |
| 1590 } | |
| 1591 | |
| 1592 parse_err(SYNERR, "unknown specifier \"%s\"\n", ident); | |
| 1593 } | |
| 1594 | |
| 1595 if ( (_curchar != '%') | |
| 1596 || ( next_char(), (_curchar != '}')) ) { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
1597 parse_err(SYNERR, "expected '%%}', found \"%c\"\n", _curchar); |
| 0 | 1598 } |
| 1599 next_char(); skipws(); | |
| 1600 | |
| 1601 if (pipeline->_maxInstrsPerBundle == 0) | |
| 1602 parse_err(SYNERR, "\"max_instructions_per_bundle\" unspecified\n"); | |
| 1603 if (pipeline->_instrUnitSize == 0 && pipeline->_bundleUnitSize == 0) | |
| 1604 parse_err(SYNERR, "\"instruction_unit_size\" and \"bundle_unit_size\" unspecified\n"); | |
| 1605 if (pipeline->_instrFetchUnitSize == 0) | |
| 1606 parse_err(SYNERR, "\"instruction_fetch_unit_size\" unspecified\n"); | |
| 1607 if (pipeline->_instrFetchUnits == 0) | |
| 1608 parse_err(SYNERR, "\"instruction_fetch_units\" unspecified\n"); | |
| 1609 if (!vsi_seen) | |
| 1610 parse_err(SYNERR, "\"variable_size_instruction\" or \"fixed_size_instruction\" unspecified\n"); | |
| 1611 } | |
| 1612 else { // Done with staticly defined parts of instruction definition | |
| 1613 parse_err(SYNERR, "expected one of \"resources\", \"pipe_desc\", \"pipe_class\", found \"%s\"\n", ident); | |
| 1614 return; | |
| 1615 } | |
| 1616 skipws(); | |
| 1617 if (_curchar == ';') | |
| 1618 skipws(); | |
| 1619 } while(_curchar != '%'); | |
| 1620 | |
| 1621 next_char(); | |
| 1622 if (_curchar != '}') { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
1623 parse_err(SYNERR, "missing \"%%}\" in pipeline definition\n"); |
| 0 | 1624 return; |
| 1625 } | |
| 1626 | |
| 1627 next_char(); | |
| 1628 } | |
| 1629 | |
| 1630 //------------------------------resource_parse---------------------------- | |
| 1631 void ADLParser::resource_parse(PipelineForm &pipeline) { | |
| 1632 ResourceForm *resource; | |
| 1633 char * ident; | |
| 1634 char * expr; | |
| 1635 unsigned mask; | |
| 1636 pipeline._rescount = 0; | |
| 1637 | |
| 1638 skipws(); // Skip leading whitespace | |
| 1639 | |
| 1640 if (_curchar != '(') { | |
| 1641 parse_err(SYNERR, "missing \"(\" in resource definition\n"); | |
| 1642 return; | |
| 1643 } | |
| 1644 | |
| 1645 do { | |
| 1646 next_char(); // Skip "(" or "," | |
| 1647 ident = get_ident(); // Grab next identifier | |
| 1648 | |
| 6850 | 1649 if (_AD._adl_debug > 1) { |
| 1650 if (ident != NULL) { | |
| 1651 fprintf(stderr, "resource_parse: identifier: %s\n", ident); | |
| 1652 } | |
| 1653 } | |
| 1654 | |
| 0 | 1655 if (ident == NULL) { |
| 1656 parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar); | |
| 1657 return; | |
| 1658 } | |
| 1659 skipws(); | |
| 1660 | |
| 1661 if (_curchar != '=') { | |
| 1662 mask = (1 << pipeline._rescount++); | |
| 1663 } | |
| 1664 else { | |
| 1665 next_char(); skipws(); | |
| 1666 expr = get_ident(); // Grab next identifier | |
| 1667 if (expr == NULL) { | |
| 1668 parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar); | |
| 1669 return; | |
| 1670 } | |
| 1671 resource = (ResourceForm *) pipeline._resdict[expr]; | |
| 1672 if (resource == NULL) { | |
| 1673 parse_err(SYNERR, "resource \"%s\" is not defined\n", expr); | |
| 1674 return; | |
| 1675 } | |
| 1676 mask = resource->mask(); | |
| 1677 | |
| 1678 skipws(); | |
| 1679 while (_curchar == '|') { | |
| 1680 next_char(); skipws(); | |
| 1681 | |
| 1682 expr = get_ident(); // Grab next identifier | |
| 1683 if (expr == NULL) { | |
| 1684 parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar); | |
| 1685 return; | |
| 1686 } | |
| 1687 | |
| 1688 resource = (ResourceForm *) pipeline._resdict[expr]; // Look up the value | |
| 1689 if (resource == NULL) { | |
| 1690 parse_err(SYNERR, "resource \"%s\" is not defined\n", expr); | |
| 1691 return; | |
| 1692 } | |
| 1693 | |
| 1694 mask |= resource->mask(); | |
| 1695 skipws(); | |
| 1696 } | |
| 1697 } | |
| 1698 | |
| 1699 resource = new ResourceForm(mask); | |
| 1700 | |
| 1701 pipeline._resdict.Insert(ident, resource); | |
| 1702 pipeline._reslist.addName(ident); | |
| 1703 } while (_curchar == ','); | |
| 1704 | |
| 1705 if (_curchar != ')') { | |
| 1706 parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar); | |
| 1707 return; | |
| 1708 } | |
| 1709 | |
| 1710 next_char(); // Skip ")" | |
| 1711 if (_curchar == ';') | |
| 1712 next_char(); // Skip ";" | |
| 1713 } | |
| 1714 | |
| 1715 //------------------------------resource_parse---------------------------- | |
| 1716 void ADLParser::pipe_desc_parse(PipelineForm &pipeline) { | |
| 1717 char * ident; | |
| 1718 | |
| 1719 skipws(); // Skip leading whitespace | |
| 1720 | |
| 1721 if (_curchar != '(') { | |
| 1722 parse_err(SYNERR, "missing \"(\" in pipe_desc definition\n"); | |
| 1723 return; | |
| 1724 } | |
| 1725 | |
| 1726 do { | |
| 1727 next_char(); // Skip "(" or "," | |
| 1728 ident = get_ident(); // Grab next identifier | |
| 1729 if (ident == NULL) { | |
| 1730 parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar); | |
| 1731 return; | |
| 1732 } | |
| 1733 | |
| 1734 // Add the name to the list | |
| 1735 pipeline._stages.addName(ident); | |
| 1736 pipeline._stagecnt++; | |
| 1737 | |
| 1738 skipws(); | |
| 1739 } while (_curchar == ','); | |
| 1740 | |
| 1741 if (_curchar != ')') { | |
| 1742 parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar); | |
| 1743 return; | |
| 1744 } | |
| 1745 | |
| 1746 next_char(); // Skip ")" | |
| 1747 if (_curchar == ';') | |
| 1748 next_char(); // Skip ";" | |
| 1749 } | |
| 1750 | |
| 1751 //------------------------------pipe_class_parse-------------------------- | |
| 1752 void ADLParser::pipe_class_parse(PipelineForm &pipeline) { | |
| 1753 PipeClassForm *pipe_class; | |
| 1754 char * ident; | |
| 1755 char * stage; | |
| 1756 char * read_or_write; | |
| 1757 int is_write; | |
| 1758 int is_read; | |
| 1759 OperandForm *oper; | |
| 1760 | |
| 1761 skipws(); // Skip leading whitespace | |
| 1762 | |
| 1763 ident = get_ident(); // Grab next identifier | |
| 1764 | |
| 1765 if (ident == NULL) { | |
| 1766 parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar); | |
| 1767 return; | |
| 1768 } | |
| 1769 | |
| 1770 // Create a record for the pipe_class | |
| 1771 pipe_class = new PipeClassForm(ident, ++pipeline._classcnt); | |
| 1772 pipeline._classdict.Insert(ident, pipe_class); | |
| 1773 pipeline._classlist.addName(ident); | |
| 1774 | |
| 1775 // Then get the operands | |
| 1776 skipws(); | |
| 1777 if (_curchar != '(') { | |
| 1778 parse_err(SYNERR, "missing \"(\" in pipe_class definition\n"); | |
| 1779 } | |
| 1780 // Parse the operand list | |
| 1781 else get_oplist(pipe_class->_parameters, pipe_class->_localNames); | |
| 1782 skipws(); // Skip leading whitespace | |
| 1783 // Check for block delimiter | |
| 1784 if ( (_curchar != '%') | |
| 1785 || ( next_char(), (_curchar != '{')) ) { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
1786 parse_err(SYNERR, "missing \"%%{\" in pipe_class definition\n"); |
| 0 | 1787 return; |
| 1788 } | |
| 1789 next_char(); | |
| 1790 | |
| 1791 do { | |
| 1792 ident = get_ident(); // Grab next identifier | |
| 1793 if (ident == NULL) { | |
| 1794 parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar); | |
| 1795 continue; | |
| 1796 } | |
| 1797 skipws(); | |
| 1798 | |
| 1799 if (!strcmp(ident, "fixed_latency")) { | |
| 1800 skipws(); | |
| 1801 if (_curchar != '(') { | |
| 1802 parse_err(SYNERR, "missing \"(\" in latency definition\n"); | |
| 1803 return; | |
| 1804 } | |
| 1805 next_char(); skipws(); | |
| 1806 if( !isdigit(_curchar) ) { | |
| 1807 parse_err(SYNERR, "number expected for \"%c\" in latency definition\n", _curchar); | |
| 1808 return; | |
| 1809 } | |
| 1810 int fixed_latency = get_int(); | |
| 1811 skipws(); | |
| 1812 if (_curchar != ')') { | |
| 1813 parse_err(SYNERR, "missing \")\" in latency definition\n"); | |
| 1814 return; | |
| 1815 } | |
| 1816 next_char(); skipws(); | |
| 1817 if (_curchar != ';') { | |
| 1818 parse_err(SYNERR, "missing \";\" in latency definition\n"); | |
| 1819 return; | |
| 1820 } | |
| 1821 | |
| 1822 pipe_class->setFixedLatency(fixed_latency); | |
| 1823 next_char(); skipws(); | |
| 1824 continue; | |
| 1825 } | |
| 1826 | |
| 1827 if (!strcmp(ident, "zero_instructions") || | |
| 1828 !strcmp(ident, "no_instructions")) { | |
| 1829 skipws(); | |
| 1830 if (_curchar != ';') { | |
| 1831 parse_err(SYNERR, "missing \";\" in latency definition\n"); | |
| 1832 return; | |
| 1833 } | |
| 1834 | |
| 1835 pipe_class->setInstructionCount(0); | |
| 1836 next_char(); skipws(); | |
| 1837 continue; | |
| 1838 } | |
| 1839 | |
| 1840 if (!strcmp(ident, "one_instruction_with_delay_slot") || | |
| 1841 !strcmp(ident, "single_instruction_with_delay_slot")) { | |
| 1842 skipws(); | |
| 1843 if (_curchar != ';') { | |
| 1844 parse_err(SYNERR, "missing \";\" in latency definition\n"); | |
| 1845 return; | |
| 1846 } | |
| 1847 | |
| 1848 pipe_class->setInstructionCount(1); | |
| 1849 pipe_class->setBranchDelay(true); | |
| 1850 next_char(); skipws(); | |
| 1851 continue; | |
| 1852 } | |
| 1853 | |
| 1854 if (!strcmp(ident, "one_instruction") || | |
| 1855 !strcmp(ident, "single_instruction")) { | |
| 1856 skipws(); | |
| 1857 if (_curchar != ';') { | |
| 1858 parse_err(SYNERR, "missing \";\" in latency definition\n"); | |
| 1859 return; | |
| 1860 } | |
| 1861 | |
| 1862 pipe_class->setInstructionCount(1); | |
| 1863 next_char(); skipws(); | |
| 1864 continue; | |
| 1865 } | |
| 1866 | |
| 1867 if (!strcmp(ident, "instructions_in_first_bundle") || | |
| 1868 !strcmp(ident, "instruction_count")) { | |
| 1869 skipws(); | |
| 1870 | |
| 1871 int number_of_instructions = 1; | |
| 1872 | |
| 1873 if (_curchar != '(') { | |
| 1874 parse_err(SYNERR, "\"(\" expected at \"%c\"\n", _curchar); | |
| 1875 continue; | |
| 1876 } | |
| 1877 | |
| 1878 next_char(); skipws(); | |
| 1879 number_of_instructions = get_int(); | |
| 1880 | |
| 1881 skipws(); | |
| 1882 if (_curchar != ')') { | |
| 1883 parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar); | |
| 1884 continue; | |
| 1885 } | |
| 1886 | |
| 1887 next_char(); skipws(); | |
| 1888 if (_curchar != ';') { | |
| 1889 parse_err(SYNERR, "missing \";\" in latency definition\n"); | |
| 1890 return; | |
| 1891 } | |
| 1892 | |
| 1893 pipe_class->setInstructionCount(number_of_instructions); | |
| 1894 next_char(); skipws(); | |
| 1895 continue; | |
| 1896 } | |
| 1897 | |
| 1898 if (!strcmp(ident, "multiple_bundles")) { | |
| 1899 skipws(); | |
| 1900 if (_curchar != ';') { | |
| 1901 parse_err(SYNERR, "missing \";\" after multiple bundles\n"); | |
| 1902 return; | |
| 1903 } | |
| 1904 | |
| 1905 pipe_class->setMultipleBundles(true); | |
| 1906 next_char(); skipws(); | |
| 1907 continue; | |
| 1908 } | |
| 1909 | |
| 1910 if (!strcmp(ident, "has_delay_slot")) { | |
| 1911 skipws(); | |
| 1912 if (_curchar != ';') { | |
| 1913 parse_err(SYNERR, "missing \";\" after \"has_delay_slot\"\n"); | |
| 1914 return; | |
| 1915 } | |
| 1916 | |
| 1917 pipe_class->setBranchDelay(true); | |
| 1918 next_char(); skipws(); | |
| 1919 continue; | |
| 1920 } | |
| 1921 | |
| 1922 if (!strcmp(ident, "force_serialization")) { | |
| 1923 skipws(); | |
| 1924 if (_curchar != ';') { | |
| 1925 parse_err(SYNERR, "missing \";\" after \"force_serialization\"\n"); | |
| 1926 return; | |
| 1927 } | |
| 1928 | |
| 1929 pipe_class->setForceSerialization(true); | |
| 1930 next_char(); skipws(); | |
| 1931 continue; | |
| 1932 } | |
| 1933 | |
| 1934 if (!strcmp(ident, "may_have_no_code")) { | |
| 1935 skipws(); | |
| 1936 if (_curchar != ';') { | |
| 1937 parse_err(SYNERR, "missing \";\" after \"may_have_no_code\"\n"); | |
| 1938 return; | |
| 1939 } | |
| 1940 | |
| 1941 pipe_class->setMayHaveNoCode(true); | |
| 1942 next_char(); skipws(); | |
| 1943 continue; | |
| 1944 } | |
| 1945 | |
| 1946 const Form *parm = pipe_class->_localNames[ident]; | |
| 1947 if (parm != NULL) { | |
| 1948 oper = parm->is_operand(); | |
| 1949 if (oper == NULL && !parm->is_opclass()) { | |
| 1950 parse_err(SYNERR, "operand name expected at %s\n", ident); | |
| 1951 continue; | |
| 1952 } | |
| 1953 | |
| 1954 if (_curchar != ':') { | |
| 1955 parse_err(SYNERR, "\":\" expected at \"%c\"\n", _curchar); | |
| 1956 continue; | |
| 1957 } | |
| 1958 next_char(); skipws(); | |
| 1959 stage = get_ident(); | |
| 1960 if (stage == NULL) { | |
| 1961 parse_err(SYNERR, "pipeline stage identifier expected at \"%c\"\n", _curchar); | |
| 1962 continue; | |
| 1963 } | |
| 1964 | |
| 1965 skipws(); | |
| 1966 if (_curchar != '(') { | |
| 1967 parse_err(SYNERR, "\"(\" expected at \"%c\"\n", _curchar); | |
| 1968 continue; | |
| 1969 } | |
| 1970 | |
| 1971 next_char(); | |
| 1972 read_or_write = get_ident(); | |
| 1973 if (read_or_write == NULL) { | |
| 1974 parse_err(SYNERR, "\"read\" or \"write\" expected at \"%c\"\n", _curchar); | |
| 1975 continue; | |
| 1976 } | |
| 1977 | |
| 1978 is_read = strcmp(read_or_write, "read") == 0; | |
| 1979 is_write = strcmp(read_or_write, "write") == 0; | |
| 1980 if (!is_read && !is_write) { | |
| 1981 parse_err(SYNERR, "\"read\" or \"write\" expected at \"%c\"\n", _curchar); | |
| 1982 continue; | |
| 1983 } | |
| 1984 | |
| 1985 skipws(); | |
| 1986 if (_curchar != ')') { | |
| 1987 parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar); | |
| 1988 continue; | |
| 1989 } | |
| 1990 | |
| 1991 next_char(); skipws(); | |
| 1992 int more_instrs = 0; | |
| 1993 if (_curchar == '+') { | |
| 1994 next_char(); skipws(); | |
| 1995 if (_curchar < '0' || _curchar > '9') { | |
| 1996 parse_err(SYNERR, "<number> expected at \"%c\"\n", _curchar); | |
| 1997 continue; | |
| 1998 } | |
| 1999 while (_curchar >= '0' && _curchar <= '9') { | |
| 2000 more_instrs *= 10; | |
| 2001 more_instrs += _curchar - '0'; | |
| 2002 next_char(); | |
| 2003 } | |
| 2004 skipws(); | |
| 2005 } | |
| 2006 | |
| 2007 PipeClassOperandForm *pipe_operand = new PipeClassOperandForm(stage, is_write, more_instrs); | |
| 2008 pipe_class->_localUsage.Insert(ident, pipe_operand); | |
| 2009 | |
| 2010 if (_curchar == '%') | |
| 2011 continue; | |
| 2012 | |
| 2013 if (_curchar != ';') { | |
| 2014 parse_err(SYNERR, "\";\" expected at \"%c\"\n", _curchar); | |
| 2015 continue; | |
| 2016 } | |
| 2017 next_char(); skipws(); | |
| 2018 continue; | |
| 2019 } | |
| 2020 | |
| 2021 // Scan for Resource Specifier | |
| 2022 const Form *res = pipeline._resdict[ident]; | |
| 2023 if (res != NULL) { | |
| 2024 int cyclecnt = 1; | |
| 2025 if (_curchar != ':') { | |
| 2026 parse_err(SYNERR, "\":\" expected at \"%c\"\n", _curchar); | |
| 2027 continue; | |
| 2028 } | |
| 2029 next_char(); skipws(); | |
| 2030 stage = get_ident(); | |
| 2031 if (stage == NULL) { | |
| 2032 parse_err(SYNERR, "pipeline stage identifier expected at \"%c\"\n", _curchar); | |
| 2033 continue; | |
| 2034 } | |
| 2035 | |
| 2036 skipws(); | |
| 2037 if (_curchar == '(') { | |
| 2038 next_char(); | |
| 2039 cyclecnt = get_int(); | |
| 2040 | |
| 2041 skipws(); | |
| 2042 if (_curchar != ')') { | |
| 2043 parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar); | |
| 2044 continue; | |
| 2045 } | |
| 2046 | |
| 2047 next_char(); skipws(); | |
| 2048 } | |
| 2049 | |
| 2050 PipeClassResourceForm *resource = new PipeClassResourceForm(ident, stage, cyclecnt); | |
| 2051 int stagenum = pipeline._stages.index(stage); | |
| 2052 if (pipeline._maxcycleused < (stagenum+cyclecnt)) | |
| 2053 pipeline._maxcycleused = (stagenum+cyclecnt); | |
| 2054 pipe_class->_resUsage.addForm(resource); | |
| 2055 | |
| 2056 if (_curchar == '%') | |
| 2057 continue; | |
| 2058 | |
| 2059 if (_curchar != ';') { | |
| 2060 parse_err(SYNERR, "\";\" expected at \"%c\"\n", _curchar); | |
| 2061 continue; | |
| 2062 } | |
| 2063 next_char(); skipws(); | |
| 2064 continue; | |
| 2065 } | |
| 2066 | |
| 2067 parse_err(SYNERR, "resource expected at \"%s\"\n", ident); | |
| 2068 return; | |
| 2069 } while(_curchar != '%'); | |
| 2070 | |
| 2071 next_char(); | |
| 2072 if (_curchar != '}') { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
2073 parse_err(SYNERR, "missing \"%%}\" in pipe_class definition\n"); |
| 0 | 2074 return; |
| 2075 } | |
| 2076 | |
| 2077 next_char(); | |
| 2078 } | |
| 2079 | |
| 2080 //------------------------------peep_parse------------------------------------- | |
| 2081 void ADLParser::peep_parse(void) { | |
| 2082 Peephole *peep; // Pointer to current peephole rule form | |
| 2083 char *desc = NULL; // String representation of rule | |
| 2084 | |
| 2085 skipws(); // Skip leading whitespace | |
| 2086 | |
| 2087 peep = new Peephole(); // Build new Peephole object | |
| 2088 // Check for open block sequence | |
| 2089 skipws(); // Skip leading whitespace | |
| 2090 if (_curchar == '%' && *(_ptr+1) == '{') { | |
| 2091 next_char(); next_char(); // Skip "%{" | |
| 2092 skipws(); | |
| 2093 while (_curchar != '%' && *(_ptr+1) != '}') { | |
| 2094 char *token = get_ident(); | |
| 2095 if (token == NULL) { | |
| 2096 parse_err(SYNERR, "missing identifier inside peephole rule.\n"); | |
| 2097 return; | |
| 2098 } | |
| 2099 // check for legal subsections of peephole rule | |
| 2100 if (strcmp(token,"peepmatch")==0) { | |
| 2101 peep_match_parse(*peep); } | |
| 2102 else if (strcmp(token,"peepconstraint")==0) { | |
| 2103 peep_constraint_parse(*peep); } | |
| 2104 else if (strcmp(token,"peepreplace")==0) { | |
| 2105 peep_replace_parse(*peep); } | |
| 2106 else { | |
| 2107 parse_err(SYNERR, "expected peepmatch, peepconstraint, or peepreplace for identifier %s.\n", token); | |
| 2108 } | |
| 2109 skipws(); | |
| 2110 } | |
| 2111 } | |
| 2112 else { | |
| 2113 parse_err(SYNERR, "Missing %%{ ... %%} block after peephole keyword.\n"); | |
| 2114 return; | |
| 2115 } | |
| 2116 next_char(); // Skip past '%' | |
| 2117 next_char(); // Skip past '}' | |
| 2118 } | |
| 2119 | |
| 2120 // ******************** Private Level 2 Parse Functions ******************** | |
| 2121 //------------------------------constraint_parse------------------------------ | |
| 2122 Constraint *ADLParser::constraint_parse(void) { | |
| 2123 char *func; | |
| 2124 char *arg; | |
| 2125 | |
| 2126 // Check for constraint expression | |
| 2127 skipws(); | |
| 2128 if (_curchar != '(') { | |
| 2129 parse_err(SYNERR, "missing constraint expression, (...)\n"); | |
| 2130 return NULL; | |
| 2131 } | |
| 2132 next_char(); // Skip past '(' | |
| 2133 | |
| 2134 // Get constraint function | |
| 2135 skipws(); | |
| 2136 func = get_ident(); | |
| 2137 if (func == NULL) { | |
| 2138 parse_err(SYNERR, "missing function in constraint expression.\n"); | |
| 2139 return NULL; | |
| 2140 } | |
| 2141 if (strcmp(func,"ALLOC_IN_RC")==0 | |
| 2142 || strcmp(func,"IS_R_CLASS")==0) { | |
| 2143 // Check for '(' before argument | |
| 2144 skipws(); | |
| 2145 if (_curchar != '(') { | |
| 2146 parse_err(SYNERR, "missing '(' for constraint function's argument.\n"); | |
| 2147 return NULL; | |
| 2148 } | |
| 2149 next_char(); | |
| 2150 | |
| 2151 // Get it's argument | |
| 2152 skipws(); | |
| 2153 arg = get_ident(); | |
| 2154 if (arg == NULL) { | |
| 2155 parse_err(SYNERR, "missing argument for constraint function %s\n",func); | |
| 2156 return NULL; | |
| 2157 } | |
| 2158 // Check for ')' after argument | |
| 2159 skipws(); | |
| 2160 if (_curchar != ')') { | |
| 2161 parse_err(SYNERR, "missing ')' after constraint function argument %s\n",arg); | |
| 2162 return NULL; | |
| 2163 } | |
| 2164 next_char(); | |
| 2165 } else { | |
| 2166 parse_err(SYNERR, "Invalid constraint function %s\n",func); | |
| 2167 return NULL; | |
| 2168 } | |
| 2169 | |
| 2170 // Check for closing paren and ';' | |
| 2171 skipws(); | |
| 2172 if (_curchar != ')') { | |
| 2173 parse_err(SYNERR, "Missing ')' for constraint function %s\n",func); | |
| 2174 return NULL; | |
| 2175 } | |
| 2176 next_char(); | |
| 2177 skipws(); | |
| 2178 if (_curchar != ';') { | |
| 2179 parse_err(SYNERR, "Missing ';' after constraint.\n"); | |
| 2180 return NULL; | |
| 2181 } | |
| 2182 next_char(); | |
| 2183 | |
| 2184 // Create new "Constraint" | |
| 2185 Constraint *constraint = new Constraint(func,arg); | |
| 2186 return constraint; | |
| 2187 } | |
| 2188 | |
| 2189 //------------------------------constr_parse----------------------------------- | |
| 2190 ConstructRule *ADLParser::construct_parse(void) { | |
| 2191 return NULL; | |
| 2192 } | |
| 2193 | |
| 2194 | |
| 2195 //------------------------------reg_def_parse---------------------------------- | |
| 2196 void ADLParser::reg_def_parse(void) { | |
| 2197 char *rname; // Name of register being defined | |
| 2198 | |
| 2199 // Get register name | |
| 2200 skipws(); // Skip whitespace | |
| 2201 rname = get_ident(); | |
| 2202 if (rname == NULL) { | |
| 2203 parse_err(SYNERR, "missing register name after reg_def\n"); | |
| 2204 return; | |
| 2205 } | |
| 2206 | |
| 2207 // Check for definition of register calling convention (save on call, ...), | |
| 2208 // register save type, and register encoding value. | |
| 2209 skipws(); | |
| 2210 char *callconv = NULL; | |
| 2211 char *c_conv = NULL; | |
| 2212 char *idealtype = NULL; | |
| 2213 char *encoding = NULL; | |
| 2214 char *concrete = NULL; | |
| 2215 if (_curchar == '(') { | |
| 2216 next_char(); | |
| 2217 callconv = get_ident(); | |
| 2218 // Parse the internal calling convention, must be NS, SOC, SOE, or AS. | |
| 2219 if (callconv == NULL) { | |
| 2220 parse_err(SYNERR, "missing register calling convention value\n"); | |
| 2221 return; | |
| 2222 } | |
| 2223 if(strcmp(callconv, "SOC") && strcmp(callconv,"SOE") && | |
| 2224 strcmp(callconv, "NS") && strcmp(callconv, "AS")) { | |
| 2225 parse_err(SYNERR, "invalid value for register calling convention\n"); | |
| 2226 } | |
| 2227 skipws(); | |
| 2228 if (_curchar != ',') { | |
| 2229 parse_err(SYNERR, "missing comma in register definition statement\n"); | |
| 2230 return; | |
| 2231 } | |
| 2232 next_char(); | |
| 2233 | |
| 2234 // Parse the native calling convention, must be NS, SOC, SOE, AS | |
| 2235 c_conv = get_ident(); | |
| 2236 if (c_conv == NULL) { | |
| 2237 parse_err(SYNERR, "missing register native calling convention value\n"); | |
| 2238 return; | |
| 2239 } | |
| 2240 if(strcmp(c_conv, "SOC") && strcmp(c_conv,"SOE") && | |
| 2241 strcmp(c_conv, "NS") && strcmp(c_conv, "AS")) { | |
| 2242 parse_err(SYNERR, "invalid value for register calling convention\n"); | |
| 2243 } | |
| 2244 skipws(); | |
| 2245 if (_curchar != ',') { | |
| 2246 parse_err(SYNERR, "missing comma in register definition statement\n"); | |
| 2247 return; | |
| 2248 } | |
| 2249 next_char(); | |
| 2250 skipws(); | |
| 2251 | |
| 2252 // Parse the ideal save type | |
| 2253 idealtype = get_ident(); | |
| 2254 if (idealtype == NULL) { | |
| 2255 parse_err(SYNERR, "missing register save type value\n"); | |
| 2256 return; | |
| 2257 } | |
| 2258 skipws(); | |
| 2259 if (_curchar != ',') { | |
| 2260 parse_err(SYNERR, "missing comma in register definition statement\n"); | |
| 2261 return; | |
| 2262 } | |
| 2263 next_char(); | |
| 2264 skipws(); | |
| 2265 | |
| 2266 // Parse the encoding value | |
| 2267 encoding = get_expr("encoding", ","); | |
| 2268 if (encoding == NULL) { | |
| 2269 parse_err(SYNERR, "missing register encoding value\n"); | |
| 2270 return; | |
| 2271 } | |
| 2272 trim(encoding); | |
| 2273 if (_curchar != ',') { | |
| 2274 parse_err(SYNERR, "missing comma in register definition statement\n"); | |
| 2275 return; | |
| 2276 } | |
| 2277 next_char(); | |
| 2278 skipws(); | |
| 2279 // Parse the concrete name type | |
| 2280 // concrete = get_ident(); | |
| 2281 concrete = get_expr("concrete", ")"); | |
| 2282 if (concrete == NULL) { | |
| 2283 parse_err(SYNERR, "missing vm register name value\n"); | |
| 2284 return; | |
| 2285 } | |
| 2286 | |
| 2287 if (_curchar != ')') { | |
| 2288 parse_err(SYNERR, "missing ')' in register definition statement\n"); | |
| 2289 return; | |
| 2290 } | |
| 2291 next_char(); | |
| 2292 } | |
| 2293 | |
| 2294 // Check for closing ';' | |
| 2295 skipws(); | |
| 2296 if (_curchar != ';') { | |
| 2297 parse_err(SYNERR, "missing ';' after reg_def\n"); | |
| 2298 return; | |
| 2299 } | |
| 2300 next_char(); // move past ';' | |
| 2301 | |
| 2302 // Debug Stuff | |
| 2303 if (_AD._adl_debug > 1) { | |
| 2304 fprintf(stderr,"Register Definition: %s ( %s, %s %s )\n", rname, | |
| 2305 (callconv ? callconv : ""), (c_conv ? c_conv : ""), concrete); | |
| 2306 } | |
| 2307 | |
| 2308 // Record new register definition. | |
| 2309 _AD._register->addRegDef(rname, callconv, c_conv, idealtype, encoding, concrete); | |
| 2310 return; | |
| 2311 } | |
| 2312 | |
| 2313 //------------------------------reg_class_parse-------------------------------- | |
| 2314 void ADLParser::reg_class_parse(void) { | |
| 2315 char *cname; // Name of register class being defined | |
| 2316 | |
| 2317 // Get register class name | |
| 2318 skipws(); // Skip leading whitespace | |
| 2319 cname = get_ident(); | |
| 2320 if (cname == NULL) { | |
| 2321 parse_err(SYNERR, "missing register class name after 'reg_class'\n"); | |
| 2322 return; | |
| 2323 } | |
| 2324 // Debug Stuff | |
| 2325 if (_AD._adl_debug >1) fprintf(stderr,"Register Class: %s\n", cname); | |
| 2326 | |
| 2327 skipws(); | |
| 2328 if (_curchar == '(') { | |
|
23049
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2329 // A register list is defined for the register class. |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2330 // Collect registers into a generic RegClass register class. |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2331 RegClass* reg_class = _AD._register->addRegClass<RegClass>(cname); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2332 |
| 0 | 2333 next_char(); // Skip '(' |
| 2334 skipws(); | |
| 2335 while (_curchar != ')') { | |
| 2336 char *rname = get_ident(); | |
| 2337 if (rname==NULL) { | |
| 2338 parse_err(SYNERR, "missing identifier inside reg_class list.\n"); | |
| 2339 return; | |
| 2340 } | |
| 2341 RegDef *regDef = _AD._register->getRegDef(rname); | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
2342 if (!regDef) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
2343 parse_err(SEMERR, "unknown identifier %s inside reg_class list.\n", rname); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
2344 } else { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
2345 reg_class->addReg(regDef); // add regDef to regClass |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
2346 } |
| 0 | 2347 |
| 2348 // Check for ',' and position to next token. | |
| 2349 skipws(); | |
| 2350 if (_curchar == ',') { | |
| 2351 next_char(); // Skip trailing ',' | |
| 2352 skipws(); | |
| 2353 } | |
| 2354 } | |
| 2355 next_char(); // Skip closing ')' | |
|
4121
db2e64ca2d5a
7090968: Allow adlc register class to depend on runtime conditions
roland
parents:
4120
diff
changeset
|
2356 } else if (_curchar == '%') { |
|
23049
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2357 // A code snippet is defined for the register class. |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2358 // Collect the code snippet into a CodeSnippetRegClass register class. |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2359 CodeSnippetRegClass* reg_class = _AD._register->addRegClass<CodeSnippetRegClass>(cname); |
|
4121
db2e64ca2d5a
7090968: Allow adlc register class to depend on runtime conditions
roland
parents:
4120
diff
changeset
|
2360 char *code = find_cpp_block("reg class"); |
|
db2e64ca2d5a
7090968: Allow adlc register class to depend on runtime conditions
roland
parents:
4120
diff
changeset
|
2361 if (code == NULL) { |
|
db2e64ca2d5a
7090968: Allow adlc register class to depend on runtime conditions
roland
parents:
4120
diff
changeset
|
2362 parse_err(SYNERR, "missing code declaration for reg class.\n"); |
|
db2e64ca2d5a
7090968: Allow adlc register class to depend on runtime conditions
roland
parents:
4120
diff
changeset
|
2363 return; |
|
db2e64ca2d5a
7090968: Allow adlc register class to depend on runtime conditions
roland
parents:
4120
diff
changeset
|
2364 } |
|
23049
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2365 reg_class->set_code_snippet(code); |
|
4121
db2e64ca2d5a
7090968: Allow adlc register class to depend on runtime conditions
roland
parents:
4120
diff
changeset
|
2366 return; |
| 0 | 2367 } |
| 2368 | |
| 2369 // Check for terminating ';' | |
| 2370 skipws(); | |
| 2371 if (_curchar != ';') { | |
| 2372 parse_err(SYNERR, "missing ';' at end of reg_class definition.\n"); | |
| 2373 return; | |
| 2374 } | |
| 2375 next_char(); // Skip trailing ';' | |
| 2376 | |
| 2377 // Check RegClass size, must be <= 32 registers in class. | |
| 2378 | |
| 2379 return; | |
| 2380 } | |
| 2381 | |
|
23049
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2382 //------------------------------reg_class_dynamic_parse------------------------ |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2383 void ADLParser::reg_class_dynamic_parse(void) { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2384 char *cname; // Name of dynamic register class being defined |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2385 |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2386 // Get register class name |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2387 skipws(); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2388 cname = get_ident(); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2389 if (cname == NULL) { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2390 parse_err(SYNERR, "missing dynamic register class name after 'reg_class_dynamic'\n"); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2391 return; |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2392 } |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2393 |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2394 if (_AD._adl_debug > 1) { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2395 fprintf(stdout, "Dynamic Register Class: %s\n", cname); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2396 } |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2397 |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2398 skipws(); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2399 if (_curchar != '(') { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2400 parse_err(SYNERR, "missing '(' at the beginning of reg_class_dynamic definition\n"); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2401 return; |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2402 } |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2403 next_char(); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2404 skipws(); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2405 |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2406 // Collect two register classes and the C++ code representing the condition code used to |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2407 // select between the two classes into a ConditionalRegClass register class. |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2408 ConditionalRegClass* reg_class = _AD._register->addRegClass<ConditionalRegClass>(cname); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2409 int i; |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2410 for (i = 0; i < 2; i++) { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2411 char* name = get_ident(); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2412 if (name == NULL) { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2413 parse_err(SYNERR, "missing class identifier inside reg_class_dynamic list.\n"); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2414 return; |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2415 } |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2416 RegClass* rc = _AD._register->getRegClass(name); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2417 if (rc == NULL) { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2418 parse_err(SEMERR, "unknown identifier %s inside reg_class_dynamic list.\n", name); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2419 } else { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2420 reg_class->set_rclass_at_index(i, rc); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2421 } |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2422 |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2423 skipws(); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2424 if (_curchar == ',') { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2425 next_char(); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2426 skipws(); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2427 } else { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2428 parse_err(SYNERR, "missing separator ',' inside reg_class_dynamic list.\n"); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2429 } |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2430 } |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2431 |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2432 // Collect the condition code. |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2433 skipws(); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2434 if (_curchar == '%') { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2435 char* code = find_cpp_block("reg class dynamic"); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2436 if (code == NULL) { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2437 parse_err(SYNERR, "missing code declaration for reg_class_dynamic.\n"); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2438 return; |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2439 } |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2440 reg_class->set_condition_code(code); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2441 } else { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2442 parse_err(SYNERR, "missing %% at the beginning of code block in reg_class_dynamic definition\n"); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2443 return; |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2444 } |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2445 |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2446 skipws(); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2447 if (_curchar != ')') { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2448 parse_err(SYNERR, "missing ')' at the end of reg_class_dynamic definition\n"); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2449 return; |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2450 } |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2451 next_char(); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2452 |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2453 skipws(); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2454 if (_curchar != ';') { |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2455 parse_err(SYNERR, "missing ';' at the end of reg_class_dynamic definition.\n"); |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2456 return; |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2457 } |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2458 next_char(); // Skip trailing ';' |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2459 |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2460 return; |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2461 } |
|
a1642365d69f
8075798: Allow ADLC register class to depend on runtime conditions also for cisc-spillable classes
zmajo
parents:
14456
diff
changeset
|
2462 |
| 0 | 2463 //------------------------------alloc_class_parse------------------------------ |
| 2464 void ADLParser::alloc_class_parse(void) { | |
| 2465 char *name; // Name of allocation class being defined | |
| 2466 | |
| 2467 // Get allocation class name | |
| 2468 skipws(); // Skip leading whitespace | |
| 2469 name = get_ident(); | |
| 2470 if (name == NULL) { | |
| 2471 parse_err(SYNERR, "missing allocation class name after 'reg_class'\n"); | |
| 2472 return; | |
| 2473 } | |
| 2474 // Debug Stuff | |
| 2475 if (_AD._adl_debug >1) fprintf(stderr,"Allocation Class: %s\n", name); | |
| 2476 | |
| 2477 AllocClass *alloc_class = _AD._register->addAllocClass(name); | |
| 2478 | |
| 2479 // Collect registers in class | |
| 2480 skipws(); | |
| 2481 if (_curchar == '(') { | |
| 2482 next_char(); // Skip '(' | |
| 2483 skipws(); | |
| 2484 while (_curchar != ')') { | |
| 2485 char *rname = get_ident(); | |
| 2486 if (rname==NULL) { | |
| 2487 parse_err(SYNERR, "missing identifier inside reg_class list.\n"); | |
| 2488 return; | |
| 2489 } | |
| 2490 // Check if name is a RegDef | |
| 2491 RegDef *regDef = _AD._register->getRegDef(rname); | |
| 2492 if (regDef) { | |
| 2493 alloc_class->addReg(regDef); // add regDef to allocClass | |
| 2494 } else { | |
| 2495 | |
| 2496 // name must be a RegDef or a RegClass | |
| 2497 parse_err(SYNERR, "name %s should be a previously defined reg_def.\n", rname); | |
| 2498 return; | |
| 2499 } | |
| 2500 | |
| 2501 // Check for ',' and position to next token. | |
| 2502 skipws(); | |
| 2503 if (_curchar == ',') { | |
| 2504 next_char(); // Skip trailing ',' | |
| 2505 skipws(); | |
| 2506 } | |
| 2507 } | |
| 2508 next_char(); // Skip closing ')' | |
| 2509 } | |
| 2510 | |
| 2511 // Check for terminating ';' | |
| 2512 skipws(); | |
| 2513 if (_curchar != ';') { | |
| 2514 parse_err(SYNERR, "missing ';' at end of reg_class definition.\n"); | |
| 2515 return; | |
| 2516 } | |
| 2517 next_char(); // Skip trailing ';' | |
| 2518 | |
| 2519 return; | |
| 2520 } | |
| 2521 | |
| 2522 //------------------------------peep_match_child_parse------------------------- | |
| 2523 InstructForm *ADLParser::peep_match_child_parse(PeepMatch &match, int parent, int &position, int input){ | |
| 2524 char *token = NULL; | |
| 2525 int lparen = 0; // keep track of parenthesis nesting depth | |
| 2526 int rparen = 0; // position of instruction at this depth | |
| 2527 InstructForm *inst_seen = NULL; | |
| 2528 | |
| 2529 // Walk the match tree, | |
| 2530 // Record <parent, position, instruction name, input position> | |
| 2531 while ( lparen >= rparen ) { | |
| 2532 skipws(); | |
| 2533 // Left paren signals start of an input, collect with recursive call | |
| 2534 if (_curchar == '(') { | |
| 2535 ++lparen; | |
| 2536 next_char(); | |
| 6850 | 2537 ( void ) peep_match_child_parse(match, parent, position, rparen); |
| 0 | 2538 } |
| 2539 // Right paren signals end of an input, may be more | |
| 2540 else if (_curchar == ')') { | |
| 2541 ++rparen; | |
| 2542 if( rparen == lparen ) { // IF rparen matches an lparen I've seen | |
| 2543 next_char(); // move past ')' | |
| 2544 } else { // ELSE leave ')' for parent | |
| 2545 assert( rparen == lparen + 1, "Should only see one extra ')'"); | |
| 2546 // if an instruction was not specified for this paren-pair | |
| 2547 if( ! inst_seen ) { // record signal entry | |
| 2548 match.add_instruction( parent, position, NameList::_signal, input ); | |
| 2549 ++position; | |
| 2550 } | |
| 2551 // ++input; // TEMPORARY | |
| 2552 return inst_seen; | |
| 2553 } | |
| 2554 } | |
| 2555 // if no parens, then check for instruction name | |
| 2556 // This instruction is the parent of a sub-tree | |
| 2557 else if ((token = get_ident_dup()) != NULL) { | |
| 2558 const Form *form = _AD._globalNames[token]; | |
| 2559 if (form) { | |
| 2560 InstructForm *inst = form->is_instruction(); | |
| 2561 // Record the first instruction at this level | |
| 2562 if( inst_seen == NULL ) { | |
| 2563 inst_seen = inst; | |
| 2564 } | |
| 2565 if (inst) { | |
| 2566 match.add_instruction( parent, position, token, input ); | |
| 2567 parent = position; | |
| 2568 ++position; | |
| 2569 } else { | |
| 2570 parse_err(SYNERR, "instruction name expected at identifier %s.\n", | |
| 2571 token); | |
| 2572 return inst_seen; | |
| 2573 } | |
| 2574 } | |
| 2575 else { | |
| 2576 parse_err(SYNERR, "missing identifier in peepmatch rule.\n"); | |
| 2577 return NULL; | |
| 2578 } | |
| 2579 } | |
| 2580 else { | |
| 2581 parse_err(SYNERR, "missing identifier in peepmatch rule.\n"); | |
| 2582 return NULL; | |
| 2583 } | |
| 2584 | |
| 2585 } // end while | |
| 2586 | |
| 2587 assert( false, "ShouldNotReachHere();"); | |
| 2588 return NULL; | |
| 2589 } | |
| 2590 | |
| 2591 //------------------------------peep_match_parse------------------------------- | |
| 2592 // Syntax for a peepmatch rule | |
| 2593 // | |
| 2594 // peepmatch ( root_instr_name [(instruction subtree)] [,(instruction subtree)]* ); | |
| 2595 // | |
| 2596 void ADLParser::peep_match_parse(Peephole &peep) { | |
| 2597 | |
| 2598 skipws(); | |
| 2599 // Check the structure of the rule | |
| 2600 // Check for open paren | |
| 2601 if (_curchar != '(') { | |
| 2602 parse_err(SYNERR, "missing '(' at start of peepmatch rule.\n"); | |
| 2603 return; | |
| 2604 } | |
| 2605 next_char(); // skip '(' | |
| 2606 | |
| 2607 // Construct PeepMatch and parse the peepmatch rule. | |
| 2608 PeepMatch *match = new PeepMatch(_ptr); | |
| 2609 int parent = -1; // parent of root | |
| 2610 int position = 0; // zero-based positions | |
| 2611 int input = 0; // input position in parent's operands | |
| 2612 InstructForm *root= peep_match_child_parse( *match, parent, position, input); | |
| 2613 if( root == NULL ) { | |
| 2614 parse_err(SYNERR, "missing instruction-name at start of peepmatch.\n"); | |
| 2615 return; | |
| 2616 } | |
| 2617 | |
| 2618 if( _curchar != ')' ) { | |
| 2619 parse_err(SYNERR, "missing ')' at end of peepmatch.\n"); | |
| 2620 return; | |
| 2621 } | |
| 2622 next_char(); // skip ')' | |
| 2623 | |
| 2624 // Check for closing semicolon | |
| 2625 skipws(); | |
| 2626 if( _curchar != ';' ) { | |
| 2627 parse_err(SYNERR, "missing ';' at end of peepmatch.\n"); | |
| 2628 return; | |
| 2629 } | |
| 2630 next_char(); // skip ';' | |
| 2631 | |
| 2632 // Store match into peep, and store peep into instruction | |
| 2633 peep.add_match(match); | |
| 2634 root->append_peephole(&peep); | |
| 2635 } | |
| 2636 | |
| 2637 //------------------------------peep_constraint_parse-------------------------- | |
| 2638 // Syntax for a peepconstraint rule | |
| 2639 // A parenthesized list of relations between operands in peepmatch subtree | |
| 2640 // | |
| 2641 // peepconstraint %{ | |
| 2642 // (instruction_number.operand_name | |
| 2643 // relational_op | |
| 2644 // instruction_number.operand_name OR register_name | |
| 2645 // [, ...] ); | |
| 2646 // | |
| 2647 // // instruction numbers are zero-based using topological order in peepmatch | |
| 2648 // | |
| 2649 void ADLParser::peep_constraint_parse(Peephole &peep) { | |
| 2650 | |
| 2651 skipws(); | |
| 2652 // Check the structure of the rule | |
| 2653 // Check for open paren | |
| 2654 if (_curchar != '(') { | |
| 2655 parse_err(SYNERR, "missing '(' at start of peepconstraint rule.\n"); | |
| 2656 return; | |
| 2657 } | |
| 2658 else { | |
| 2659 next_char(); // Skip '(' | |
| 2660 } | |
| 2661 | |
| 2662 // Check for a constraint | |
| 2663 skipws(); | |
| 2664 while( _curchar != ')' ) { | |
| 2665 // Get information on the left instruction and its operand | |
| 2666 // left-instructions's number | |
|
603
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
2667 int left_inst = get_int(); |
| 0 | 2668 // Left-instruction's operand |
| 2669 skipws(); | |
| 2670 if( _curchar != '.' ) { | |
| 2671 parse_err(SYNERR, "missing '.' in peepconstraint after instruction number.\n"); | |
| 2672 return; | |
| 2673 } | |
| 2674 next_char(); // Skip '.' | |
| 2675 char *left_op = get_ident_dup(); | |
| 2676 | |
| 2677 skipws(); | |
| 2678 // Collect relational operator | |
| 2679 char *relation = get_relation_dup(); | |
| 2680 | |
| 2681 skipws(); | |
| 2682 // Get information on the right instruction and its operand | |
|
603
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
2683 int right_inst; // Right-instructions's number |
| 0 | 2684 if( isdigit(_curchar) ) { |
| 2685 right_inst = get_int(); | |
| 2686 // Right-instruction's operand | |
| 2687 skipws(); | |
| 2688 if( _curchar != '.' ) { | |
| 2689 parse_err(SYNERR, "missing '.' in peepconstraint after instruction number.\n"); | |
| 2690 return; | |
| 2691 } | |
| 2692 next_char(); // Skip '.' | |
| 2693 } else { | |
| 2694 right_inst = -1; // Flag as being a register constraint | |
| 2695 } | |
| 2696 | |
| 2697 char *right_op = get_ident_dup(); | |
| 2698 | |
| 2699 // Construct the next PeepConstraint | |
| 2700 PeepConstraint *constraint = new PeepConstraint( left_inst, left_op, | |
| 2701 relation, | |
| 2702 right_inst, right_op ); | |
| 2703 // And append it to the list for this peephole rule | |
| 2704 peep.append_constraint( constraint ); | |
| 2705 | |
| 2706 // Check for another constraint, or end of rule | |
| 2707 skipws(); | |
| 2708 if( _curchar == ',' ) { | |
| 2709 next_char(); // Skip ',' | |
| 2710 skipws(); | |
| 2711 } | |
| 2712 else if( _curchar != ')' ) { | |
| 2713 parse_err(SYNERR, "expected ',' or ')' after peephole constraint.\n"); | |
| 2714 return; | |
| 2715 } | |
| 2716 } // end while( processing constraints ) | |
| 2717 next_char(); // Skip ')' | |
| 2718 | |
| 2719 // Check for terminating ';' | |
| 2720 skipws(); | |
| 2721 if (_curchar != ';') { | |
| 2722 parse_err(SYNERR, "missing ';' at end of peepconstraint.\n"); | |
| 2723 return; | |
| 2724 } | |
| 2725 next_char(); // Skip trailing ';' | |
| 2726 } | |
| 2727 | |
| 2728 | |
| 2729 //------------------------------peep_replace_parse----------------------------- | |
| 2730 // Syntax for a peepreplace rule | |
| 2731 // root instruction name followed by a | |
| 2732 // parenthesized list of whitespace separated instruction.operand specifiers | |
| 2733 // | |
| 2734 // peepreplace ( instr_name ( [instruction_number.operand_name]* ) ); | |
| 2735 // | |
| 2736 // | |
| 2737 void ADLParser::peep_replace_parse(Peephole &peep) { | |
| 2738 int lparen = 0; // keep track of parenthesis nesting depth | |
| 2739 int rparen = 0; // keep track of parenthesis nesting depth | |
| 2740 int icount = 0; // count of instructions in rule for naming | |
| 2741 char *str = NULL; | |
| 2742 char *token = NULL; | |
| 2743 | |
| 2744 skipws(); | |
| 2745 // Check for open paren | |
| 2746 if (_curchar != '(') { | |
| 2747 parse_err(SYNERR, "missing '(' at start of peepreplace rule.\n"); | |
| 2748 return; | |
| 2749 } | |
| 2750 else { | |
| 2751 lparen++; | |
| 2752 next_char(); | |
| 2753 } | |
| 2754 | |
| 2755 // Check for root instruction | |
| 2756 char *inst = get_ident_dup(); | |
| 2757 const Form *form = _AD._globalNames[inst]; | |
| 2758 if( form == NULL || form->is_instruction() == NULL ) { | |
| 2759 parse_err(SYNERR, "Instruction name expected at start of peepreplace.\n"); | |
| 2760 return; | |
| 2761 } | |
| 2762 | |
| 2763 // Store string representation of rule into replace | |
| 2764 PeepReplace *replace = new PeepReplace(str); | |
| 2765 replace->add_instruction( inst ); | |
| 2766 | |
| 2767 skipws(); | |
| 2768 // Start of root's operand-list | |
| 2769 if (_curchar != '(') { | |
| 2770 parse_err(SYNERR, "missing '(' at peepreplace root's operand-list.\n"); | |
| 2771 return; | |
| 2772 } | |
| 2773 else { | |
| 2774 lparen++; | |
| 2775 next_char(); | |
| 2776 } | |
| 2777 | |
| 2778 skipws(); | |
| 2779 // Get the list of operands | |
| 2780 while( _curchar != ')' ) { | |
| 2781 // Get information on an instruction and its operand | |
| 2782 // instructions's number | |
| 2783 int inst_num = get_int(); | |
| 2784 // Left-instruction's operand | |
| 2785 skipws(); | |
| 2786 if( _curchar != '.' ) { | |
| 2787 parse_err(SYNERR, "missing '.' in peepreplace after instruction number.\n"); | |
| 2788 return; | |
| 2789 } | |
| 2790 next_char(); // Skip '.' | |
| 2791 char *inst_op = get_ident_dup(); | |
| 2792 if( inst_op == NULL ) { | |
| 2793 parse_err(SYNERR, "missing operand identifier in peepreplace.\n"); | |
| 2794 return; | |
| 2795 } | |
| 2796 | |
| 2797 // Record this operand's position in peepmatch | |
| 2798 replace->add_operand( inst_num, inst_op ); | |
| 2799 skipws(); | |
| 2800 } | |
| 2801 | |
| 2802 // Check for the end of operands list | |
| 2803 skipws(); | |
| 2804 assert( _curchar == ')', "While loop should have advanced to ')'."); | |
| 2805 next_char(); // Skip ')' | |
| 2806 | |
| 2807 skipws(); | |
| 2808 // Check for end of peepreplace | |
| 2809 if( _curchar != ')' ) { | |
| 2810 parse_err(SYNERR, "missing ')' at end of peepmatch.\n"); | |
| 2811 parse_err(SYNERR, "Support one replacement instruction.\n"); | |
| 2812 return; | |
| 2813 } | |
| 2814 next_char(); // Skip ')' | |
| 2815 | |
| 2816 // Check for closing semicolon | |
| 2817 skipws(); | |
| 2818 if( _curchar != ';' ) { | |
| 2819 parse_err(SYNERR, "missing ';' at end of peepreplace.\n"); | |
| 2820 return; | |
| 2821 } | |
| 2822 next_char(); // skip ';' | |
| 2823 | |
| 2824 // Store replace into peep | |
| 2825 peep.add_replace( replace ); | |
| 2826 } | |
| 2827 | |
| 2828 //------------------------------pred_parse------------------------------------- | |
| 2829 Predicate *ADLParser::pred_parse(void) { | |
| 2830 Predicate *predicate; // Predicate class for operand | |
| 2831 char *rule = NULL; // String representation of predicate | |
| 2832 | |
| 2833 skipws(); // Skip leading whitespace | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
2834 int line = linenum(); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
2835 if ( (rule = get_paren_expr("pred expression", true)) == NULL ) { |
| 0 | 2836 parse_err(SYNERR, "incorrect or missing expression for 'predicate'\n"); |
| 2837 return NULL; | |
| 2838 } | |
| 2839 // Debug Stuff | |
| 2840 if (_AD._adl_debug > 1) fprintf(stderr,"Predicate: %s\n", rule); | |
| 2841 if (_curchar != ';') { | |
| 2842 parse_err(SYNERR, "missing ';' in predicate definition\n"); | |
| 2843 return NULL; | |
| 2844 } | |
| 2845 next_char(); // Point after the terminator | |
| 2846 | |
| 2847 predicate = new Predicate(rule); // Build new predicate object | |
| 2848 skipws(); | |
| 2849 return predicate; | |
| 2850 } | |
| 2851 | |
| 2852 | |
| 2853 //------------------------------ins_encode_parse_block------------------------- | |
| 2854 // Parse the block form of ins_encode. See ins_encode_parse for more details | |
| 2008 | 2855 void ADLParser::ins_encode_parse_block(InstructForm& inst) { |
| 0 | 2856 // Create a new encoding name based on the name of the instruction |
| 2857 // definition, which should be unique. | |
| 2008 | 2858 const char* prefix = "__ins_encode_"; |
| 2859 char* ec_name = (char*) malloc(strlen(inst._ident) + strlen(prefix) + 1); | |
| 0 | 2860 sprintf(ec_name, "%s%s", prefix, inst._ident); |
| 2861 | |
| 2862 assert(_AD._encode->encClass(ec_name) == NULL, "shouldn't already exist"); | |
| 2008 | 2863 EncClass* encoding = _AD._encode->add_EncClass(ec_name); |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
2864 encoding->_linenum = linenum(); |
| 0 | 2865 |
| 2866 // synthesize the arguments list for the enc_class from the | |
| 2867 // arguments to the instruct definition. | |
| 2008 | 2868 const char* param = NULL; |
| 0 | 2869 inst._parameters.reset(); |
| 2870 while ((param = inst._parameters.iter()) != NULL) { | |
| 2008 | 2871 OperandForm* opForm = (OperandForm*) inst._localNames[param]; |
| 0 | 2872 encoding->add_parameter(opForm->_ident, param); |
| 2873 } | |
| 2874 | |
|
14428
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
2875 if (!inst._is_postalloc_expand) { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
2876 // Define a MacroAssembler instance for use by the encoding. The |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
2877 // name is chosen to match the __ idiom used for assembly in other |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
2878 // parts of hotspot and assumes the existence of the standard |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
2879 // #define __ _masm. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
2880 encoding->add_code(" MacroAssembler _masm(&cbuf);\n"); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
2881 } |
| 0 | 2882 |
| 2883 // Parse the following %{ }% block | |
| 2008 | 2884 ins_encode_parse_block_impl(inst, encoding, ec_name); |
| 0 | 2885 |
| 2886 // Build an encoding rule which invokes the encoding rule we just | |
| 2887 // created, passing all arguments that we received. | |
| 2008 | 2888 InsEncode* encrule = new InsEncode(); // Encode class for instruction |
| 2889 NameAndList* params = encrule->add_encode(ec_name); | |
| 0 | 2890 inst._parameters.reset(); |
| 2891 while ((param = inst._parameters.iter()) != NULL) { | |
| 2892 params->add_entry(param); | |
| 2893 } | |
| 2894 | |
|
3793
fe240d87c6ec
7061101: adlc should complain about mixing block and expression forms of ins_encode
never
parents:
2008
diff
changeset
|
2895 // Check for duplicate ins_encode sections after parsing the block |
|
fe240d87c6ec
7061101: adlc should complain about mixing block and expression forms of ins_encode
never
parents:
2008
diff
changeset
|
2896 // so that parsing can continue and find any other errors. |
|
fe240d87c6ec
7061101: adlc should complain about mixing block and expression forms of ins_encode
never
parents:
2008
diff
changeset
|
2897 if (inst._insencode != NULL) { |
|
fe240d87c6ec
7061101: adlc should complain about mixing block and expression forms of ins_encode
never
parents:
2008
diff
changeset
|
2898 parse_err(SYNERR, "Multiple ins_encode sections defined\n"); |
|
fe240d87c6ec
7061101: adlc should complain about mixing block and expression forms of ins_encode
never
parents:
2008
diff
changeset
|
2899 return; |
|
fe240d87c6ec
7061101: adlc should complain about mixing block and expression forms of ins_encode
never
parents:
2008
diff
changeset
|
2900 } |
|
fe240d87c6ec
7061101: adlc should complain about mixing block and expression forms of ins_encode
never
parents:
2008
diff
changeset
|
2901 |
| 2008 | 2902 // Set encode class of this instruction. |
| 2903 inst._insencode = encrule; | |
| 2904 } | |
| 2905 | |
| 2906 | |
| 2907 void ADLParser::ins_encode_parse_block_impl(InstructForm& inst, EncClass* encoding, char* ec_name) { | |
| 2908 skipws_no_preproc(); // Skip leading whitespace | |
| 2909 // Prepend location descriptor, for debugging; cf. ADLParser::find_cpp_block | |
| 2910 if (_AD._adlocation_debug) { | |
| 2911 encoding->add_code(get_line_string()); | |
| 2912 } | |
| 2913 | |
| 2914 // Collect the parts of the encode description | |
| 2915 // (1) strings that are passed through to output | |
| 2916 // (2) replacement/substitution variable, preceeded by a '$' | |
| 2917 while ((_curchar != '%') && (*(_ptr+1) != '}')) { | |
| 2918 | |
| 2919 // (1) | |
| 2920 // Check if there is a string to pass through to output | |
| 2921 char *start = _ptr; // Record start of the next string | |
| 2922 while ((_curchar != '$') && ((_curchar != '%') || (*(_ptr+1) != '}')) ) { | |
| 2923 // If at the start of a comment, skip past it | |
| 2924 if( (_curchar == '/') && ((*(_ptr+1) == '/') || (*(_ptr+1) == '*')) ) { | |
| 2925 skipws_no_preproc(); | |
| 2926 } else { | |
| 2927 // ELSE advance to the next character, or start of the next line | |
| 2928 next_char_or_line(); | |
| 2929 } | |
| 2930 } | |
| 2931 // If a string was found, terminate it and record in EncClass | |
| 2932 if (start != _ptr) { | |
| 2933 *_ptr = '\0'; // Terminate the string | |
| 2934 encoding->add_code(start); | |
| 2935 } | |
| 2936 | |
| 2937 // (2) | |
| 2938 // If we are at a replacement variable, | |
| 2939 // copy it and record in EncClass | |
| 2940 if (_curchar == '$') { | |
| 2941 // Found replacement Variable | |
| 2942 char* rep_var = get_rep_var_ident_dup(); | |
| 2943 | |
| 2944 // Add flag to _strings list indicating we should check _rep_vars | |
| 2945 encoding->add_rep_var(rep_var); | |
| 2946 | |
| 2947 skipws(); | |
| 2948 | |
| 2949 // Check if this instruct is a MachConstantNode. | |
| 2950 if (strcmp(rep_var, "constanttablebase") == 0) { | |
| 2951 // This instruct is a MachConstantNode. | |
|
14434
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
2952 inst.set_needs_constant_base(true); |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
2953 if (strncmp("MachCall", inst.mach_base_class(_globalNames), strlen("MachCall")) != 0 ) { |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
2954 inst.set_is_mach_constant(true); |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
2955 } |
| 2008 | 2956 |
| 2957 if (_curchar == '(') { | |
|
14428
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
2958 parse_err(SYNERR, "constanttablebase in instruct %s cannot have an argument " |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
2959 "(only constantaddress and constantoffset)", ec_name); |
| 2008 | 2960 return; |
| 2961 } | |
| 2962 } | |
| 2963 else if ((strcmp(rep_var, "constantaddress") == 0) || | |
| 2964 (strcmp(rep_var, "constantoffset") == 0)) { | |
| 2965 // This instruct is a MachConstantNode. | |
| 2966 inst.set_is_mach_constant(true); | |
| 2967 | |
| 2968 // If the constant keyword has an argument, parse it. | |
| 2969 if (_curchar == '(') constant_parse(inst); | |
| 2970 } | |
| 2971 } | |
| 2972 } // end while part of format description | |
| 2973 next_char(); // Skip '%' | |
| 2974 next_char(); // Skip '}' | |
| 2975 | |
| 2976 skipws(); | |
| 2977 | |
| 2978 if (_AD._adlocation_debug) { | |
| 2979 encoding->add_code(end_line_marker()); | |
| 2980 } | |
| 2981 | |
| 2982 // Debug Stuff | |
| 2983 if (_AD._adl_debug > 1) fprintf(stderr, "EncodingClass Form: %s\n", ec_name); | |
| 0 | 2984 } |
| 2985 | |
| 2986 | |
| 2987 //------------------------------ins_encode_parse------------------------------- | |
| 2988 // Encode rules have the form | |
| 2989 // ins_encode( encode_class_name(parameter_list), ... ); | |
| 2990 // | |
| 2991 // The "encode_class_name" must be defined in the encode section | |
| 2992 // The parameter list contains $names that are locals. | |
| 2993 // | |
| 2994 // Alternatively it can be written like this: | |
| 2995 // | |
| 2996 // ins_encode %{ | |
| 2997 // ... // body | |
| 2998 // %} | |
| 2999 // | |
| 3000 // which synthesizes a new encoding class taking the same arguments as | |
| 3001 // the InstructForm, and automatically prefixes the definition with: | |
| 3002 // | |
| 3003 // MacroAssembler masm(&cbuf);\n"); | |
| 3004 // | |
| 3005 // making it more compact to take advantage of the MacroAssembler and | |
| 3006 // placing the assembly closer to it's use by instructions. | |
| 2008 | 3007 void ADLParser::ins_encode_parse(InstructForm& inst) { |
| 0 | 3008 |
| 3009 // Parse encode class name | |
| 3010 skipws(); // Skip whitespace | |
| 3011 if (_curchar != '(') { | |
| 3012 // Check for ins_encode %{ form | |
| 3013 if ((_curchar == '%') && (*(_ptr+1) == '{')) { | |
| 3014 next_char(); // Skip '%' | |
| 3015 next_char(); // Skip '{' | |
| 3016 | |
| 3017 // Parse the block form of ins_encode | |
| 2008 | 3018 ins_encode_parse_block(inst); |
| 3019 return; | |
| 0 | 3020 } |
| 3021 | |
| 3022 parse_err(SYNERR, "missing '%%{' or '(' in ins_encode definition\n"); | |
| 2008 | 3023 return; |
| 0 | 3024 } |
| 3025 next_char(); // move past '(' | |
| 3026 skipws(); | |
| 3027 | |
| 3028 InsEncode *encrule = new InsEncode(); // Encode class for instruction | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3029 encrule->_linenum = linenum(); |
| 0 | 3030 char *ec_name = NULL; // String representation of encode rule |
| 3031 // identifier is optional. | |
| 3032 while (_curchar != ')') { | |
| 3033 ec_name = get_ident(); | |
| 3034 if (ec_name == NULL) { | |
| 3035 parse_err(SYNERR, "Invalid encode class name after 'ins_encode('.\n"); | |
| 2008 | 3036 return; |
| 0 | 3037 } |
| 3038 // Check that encoding is defined in the encode section | |
| 3039 EncClass *encode_class = _AD._encode->encClass(ec_name); | |
| 3040 if (encode_class == NULL) { | |
| 3041 // Like to defer checking these till later... | |
| 3042 // parse_err(WARN, "Using an undefined encode class '%s' in 'ins_encode'.\n", ec_name); | |
| 3043 } | |
| 3044 | |
| 3045 // Get list for encode method's parameters | |
| 3046 NameAndList *params = encrule->add_encode(ec_name); | |
| 3047 | |
| 3048 // Parse the parameters to this encode method. | |
| 3049 skipws(); | |
| 3050 if ( _curchar == '(' ) { | |
| 3051 next_char(); // move past '(' for parameters | |
| 3052 | |
| 3053 // Parse the encode method's parameters | |
| 3054 while (_curchar != ')') { | |
| 3055 char *param = get_ident_or_literal_constant("encoding operand"); | |
| 3056 if ( param != NULL ) { | |
|
14434
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3057 |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3058 // Check if this instruct is a MachConstantNode. |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3059 if (strcmp(param, "constanttablebase") == 0) { |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3060 // This instruct is a MachConstantNode. |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3061 inst.set_needs_constant_base(true); |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3062 if (strncmp("MachCall", inst.mach_base_class(_globalNames), strlen("MachCall")) != 0 ) { |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3063 inst.set_is_mach_constant(true); |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3064 } |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3065 |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3066 if (_curchar == '(') { |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3067 parse_err(SYNERR, "constanttablebase in instruct %s cannot have an argument " |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3068 "(only constantaddress and constantoffset)", ec_name); |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3069 return; |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3070 } |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3071 } else { |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3072 // Found a parameter: |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3073 // Check it is a local name, add it to the list, then check for more |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3074 // New: allow hex constants as parameters to an encode method. |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3075 // New: allow parenthesized expressions as parameters. |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3076 // New: allow "primary", "secondary", "tertiary" as parameters. |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3077 // New: allow user-defined register name as parameter |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3078 if ( (inst._localNames[param] == NULL) && |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3079 !ADLParser::is_literal_constant(param) && |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3080 (Opcode::as_opcode_type(param) == Opcode::NOT_AN_OPCODE) && |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3081 ((_AD._register == NULL ) || (_AD._register->getRegDef(param) == NULL)) ) { |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3082 parse_err(SYNERR, "Using non-locally defined parameter %s for encoding %s.\n", param, ec_name); |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3083 return; |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3084 } |
| 0 | 3085 } |
| 3086 params->add_entry(param); | |
| 3087 | |
| 3088 skipws(); | |
| 3089 if (_curchar == ',' ) { | |
| 3090 // More parameters to come | |
| 3091 next_char(); // move past ',' between parameters | |
| 3092 skipws(); // Skip to next parameter | |
| 3093 } | |
| 3094 else if (_curchar == ')') { | |
| 3095 // Done with parameter list | |
| 3096 } | |
| 3097 else { | |
| 3098 // Only ',' or ')' are valid after a parameter name | |
| 3099 parse_err(SYNERR, "expected ',' or ')' after parameter %s.\n", | |
| 3100 ec_name); | |
| 2008 | 3101 return; |
| 0 | 3102 } |
| 3103 | |
| 3104 } else { | |
| 3105 skipws(); | |
| 3106 // Did not find a parameter | |
| 3107 if (_curchar == ',') { | |
| 3108 parse_err(SYNERR, "Expected encode parameter before ',' in encoding %s.\n", ec_name); | |
| 2008 | 3109 return; |
| 0 | 3110 } |
| 3111 if (_curchar != ')') { | |
| 3112 parse_err(SYNERR, "Expected ')' after encode parameters.\n"); | |
| 2008 | 3113 return; |
| 0 | 3114 } |
| 3115 } | |
| 3116 } // WHILE loop collecting parameters | |
| 3117 next_char(); // move past ')' at end of parameters | |
| 3118 } // done with parameter list for encoding | |
| 3119 | |
| 3120 // Check for ',' or ')' after encoding | |
| 3121 skipws(); // move to character after parameters | |
| 3122 if ( _curchar == ',' ) { | |
| 3123 // Found a ',' | |
| 3124 next_char(); // move past ',' between encode methods | |
| 3125 skipws(); | |
| 3126 } | |
| 3127 else if ( _curchar != ')' ) { | |
| 3128 // If not a ',' then only a ')' is allowed | |
| 3129 parse_err(SYNERR, "Expected ')' after encoding %s.\n", ec_name); | |
| 2008 | 3130 return; |
| 0 | 3131 } |
| 3132 | |
| 3133 // Check for ',' separating parameters | |
| 3134 // if ( _curchar != ',' && _curchar != ')' ) { | |
| 3135 // parse_err(SYNERR, "expected ',' or ')' after encode method inside ins_encode.\n"); | |
| 3136 // return NULL; | |
| 3137 // } | |
| 3138 | |
| 3139 } // done parsing ins_encode methods and their parameters | |
| 3140 if (_curchar != ')') { | |
| 3141 parse_err(SYNERR, "Missing ')' at end of ins_encode description.\n"); | |
| 2008 | 3142 return; |
| 0 | 3143 } |
| 3144 next_char(); // move past ')' | |
| 3145 skipws(); // Skip leading whitespace | |
| 3146 | |
| 3147 if ( _curchar != ';' ) { | |
| 3148 parse_err(SYNERR, "Missing ';' at end of ins_encode.\n"); | |
| 2008 | 3149 return; |
| 0 | 3150 } |
| 3151 next_char(); // move past ';' | |
| 3152 skipws(); // be friendly to oper_parse() | |
| 3153 | |
|
3793
fe240d87c6ec
7061101: adlc should complain about mixing block and expression forms of ins_encode
never
parents:
2008
diff
changeset
|
3154 // Check for duplicate ins_encode sections after parsing the block |
|
fe240d87c6ec
7061101: adlc should complain about mixing block and expression forms of ins_encode
never
parents:
2008
diff
changeset
|
3155 // so that parsing can continue and find any other errors. |
|
fe240d87c6ec
7061101: adlc should complain about mixing block and expression forms of ins_encode
never
parents:
2008
diff
changeset
|
3156 if (inst._insencode != NULL) { |
|
fe240d87c6ec
7061101: adlc should complain about mixing block and expression forms of ins_encode
never
parents:
2008
diff
changeset
|
3157 parse_err(SYNERR, "Multiple ins_encode sections defined\n"); |
|
fe240d87c6ec
7061101: adlc should complain about mixing block and expression forms of ins_encode
never
parents:
2008
diff
changeset
|
3158 return; |
|
fe240d87c6ec
7061101: adlc should complain about mixing block and expression forms of ins_encode
never
parents:
2008
diff
changeset
|
3159 } |
|
fe240d87c6ec
7061101: adlc should complain about mixing block and expression forms of ins_encode
never
parents:
2008
diff
changeset
|
3160 |
| 0 | 3161 // Debug Stuff |
| 3162 if (_AD._adl_debug > 1) fprintf(stderr,"Instruction Encode: %s\n", ec_name); | |
| 3163 | |
| 2008 | 3164 // Set encode class of this instruction. |
| 3165 inst._insencode = encrule; | |
| 3166 } | |
| 3167 | |
|
14428
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3168 //------------------------------postalloc_expand_parse--------------------------- |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3169 // Encode rules have the form |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3170 // postalloc_expand( encode_class_name(parameter_list) ); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3171 // |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3172 // The "encode_class_name" must be defined in the encode section. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3173 // The parameter list contains $names that are locals. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3174 // |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3175 // This is just a copy of ins_encode_parse without the loop. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3176 void ADLParser::postalloc_expand_parse(InstructForm& inst) { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3177 inst._is_postalloc_expand = true; |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3178 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3179 // Parse encode class name. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3180 skipws(); // Skip whitespace. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3181 if (_curchar != '(') { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3182 // Check for postalloc_expand %{ form |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3183 if ((_curchar == '%') && (*(_ptr+1) == '{')) { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3184 next_char(); // Skip '%' |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3185 next_char(); // Skip '{' |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3186 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3187 // Parse the block form of postalloc_expand |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3188 ins_encode_parse_block(inst); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3189 return; |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3190 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3191 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3192 parse_err(SYNERR, "missing '(' in postalloc_expand definition\n"); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3193 return; |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3194 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3195 next_char(); // Move past '('. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3196 skipws(); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3197 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3198 InsEncode *encrule = new InsEncode(); // Encode class for instruction. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3199 encrule->_linenum = linenum(); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3200 char *ec_name = NULL; // String representation of encode rule. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3201 // identifier is optional. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3202 if (_curchar != ')') { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3203 ec_name = get_ident(); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3204 if (ec_name == NULL) { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3205 parse_err(SYNERR, "Invalid postalloc_expand class name after 'postalloc_expand('.\n"); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3206 return; |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3207 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3208 // Check that encoding is defined in the encode section. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3209 EncClass *encode_class = _AD._encode->encClass(ec_name); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3210 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3211 // Get list for encode method's parameters |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3212 NameAndList *params = encrule->add_encode(ec_name); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3213 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3214 // Parse the parameters to this encode method. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3215 skipws(); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3216 if (_curchar == '(') { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3217 next_char(); // Move past '(' for parameters. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3218 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3219 // Parse the encode method's parameters. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3220 while (_curchar != ')') { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3221 char *param = get_ident_or_literal_constant("encoding operand"); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3222 if (param != NULL) { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3223 // Found a parameter: |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3224 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3225 // First check for constant table support. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3226 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3227 // Check if this instruct is a MachConstantNode. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3228 if (strcmp(param, "constanttablebase") == 0) { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3229 // This instruct is a MachConstantNode. |
|
14434
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3230 inst.set_needs_constant_base(true); |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3231 if (strncmp("MachCall", inst.mach_base_class(_globalNames), strlen("MachCall")) != 0 ) { |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3232 inst.set_is_mach_constant(true); |
|
318d0622a6d7
8028580: PPC64 (part 114/120): Support for Call nodes with constants.
goetz
parents:
14431
diff
changeset
|
3233 } |
|
14428
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3234 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3235 if (_curchar == '(') { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3236 parse_err(SYNERR, "constanttablebase in instruct %s cannot have an argument " |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3237 "(only constantaddress and constantoffset)", ec_name); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3238 return; |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3239 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3240 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3241 else if ((strcmp(param, "constantaddress") == 0) || |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3242 (strcmp(param, "constantoffset") == 0)) { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3243 // This instruct is a MachConstantNode. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3244 inst.set_is_mach_constant(true); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3245 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3246 // If the constant keyword has an argument, parse it. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3247 if (_curchar == '(') constant_parse(inst); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3248 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3249 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3250 // Else check it is a local name, add it to the list, then check for more. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3251 // New: allow hex constants as parameters to an encode method. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3252 // New: allow parenthesized expressions as parameters. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3253 // New: allow "primary", "secondary", "tertiary" as parameters. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3254 // New: allow user-defined register name as parameter. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3255 else if ((inst._localNames[param] == NULL) && |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3256 !ADLParser::is_literal_constant(param) && |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3257 (Opcode::as_opcode_type(param) == Opcode::NOT_AN_OPCODE) && |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3258 ((_AD._register == NULL) || (_AD._register->getRegDef(param) == NULL))) { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3259 parse_err(SYNERR, "Using non-locally defined parameter %s for encoding %s.\n", param, ec_name); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3260 return; |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3261 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3262 params->add_entry(param); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3263 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3264 skipws(); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3265 if (_curchar == ',') { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3266 // More parameters to come. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3267 next_char(); // Move past ',' between parameters. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3268 skipws(); // Skip to next parameter. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3269 } else if (_curchar == ')') { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3270 // Done with parameter list |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3271 } else { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3272 // Only ',' or ')' are valid after a parameter name. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3273 parse_err(SYNERR, "expected ',' or ')' after parameter %s.\n", ec_name); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3274 return; |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3275 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3276 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3277 } else { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3278 skipws(); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3279 // Did not find a parameter. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3280 if (_curchar == ',') { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3281 parse_err(SYNERR, "Expected encode parameter before ',' in postalloc_expand %s.\n", ec_name); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3282 return; |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3283 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3284 if (_curchar != ')') { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3285 parse_err(SYNERR, "Expected ')' after postalloc_expand parameters.\n"); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3286 return; |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3287 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3288 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3289 } // WHILE loop collecting parameters. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3290 next_char(); // Move past ')' at end of parameters. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3291 } // Done with parameter list for encoding. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3292 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3293 // Check for ',' or ')' after encoding. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3294 skipws(); // Move to character after parameters. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3295 if (_curchar != ')') { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3296 // Only a ')' is allowed. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3297 parse_err(SYNERR, "Expected ')' after postalloc_expand %s.\n", ec_name); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3298 return; |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3299 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3300 } // Done parsing postalloc_expand method and their parameters. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3301 if (_curchar != ')') { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3302 parse_err(SYNERR, "Missing ')' at end of postalloc_expand description.\n"); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3303 return; |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3304 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3305 next_char(); // Move past ')'. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3306 skipws(); // Skip leading whitespace. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3307 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3308 if (_curchar != ';') { |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3309 parse_err(SYNERR, "Missing ';' at end of postalloc_expand.\n"); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3310 return; |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3311 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3312 next_char(); // Move past ';'. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3313 skipws(); // Be friendly to oper_parse(). |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3314 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3315 // Debug Stuff. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3316 if (_AD._adl_debug > 1) fprintf(stderr, "Instruction postalloc_expand: %s\n", ec_name); |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3317 |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3318 // Set encode class of this instruction. |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3319 inst._insencode = encrule; |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3320 } |
|
044b28168e20
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
12323
diff
changeset
|
3321 |
| 2008 | 3322 |
| 3323 //------------------------------constant_parse--------------------------------- | |
| 3324 // Parse a constant expression. | |
| 3325 void ADLParser::constant_parse(InstructForm& inst) { | |
| 3326 // Create a new encoding name based on the name of the instruction | |
| 3327 // definition, which should be unique. | |
| 3328 const char* prefix = "__constant_"; | |
| 3329 char* ec_name = (char*) malloc(strlen(inst._ident) + strlen(prefix) + 1); | |
| 3330 sprintf(ec_name, "%s%s", prefix, inst._ident); | |
| 3331 | |
| 3332 assert(_AD._encode->encClass(ec_name) == NULL, "shouldn't already exist"); | |
| 3333 EncClass* encoding = _AD._encode->add_EncClass(ec_name); | |
| 3334 encoding->_linenum = linenum(); | |
| 3335 | |
| 3336 // synthesize the arguments list for the enc_class from the | |
| 3337 // arguments to the instruct definition. | |
| 3338 const char* param = NULL; | |
| 3339 inst._parameters.reset(); | |
| 3340 while ((param = inst._parameters.iter()) != NULL) { | |
| 3341 OperandForm* opForm = (OperandForm*) inst._localNames[param]; | |
| 3342 encoding->add_parameter(opForm->_ident, param); | |
| 3343 } | |
| 3344 | |
| 3345 // Parse the following ( ) expression. | |
| 3346 constant_parse_expression(encoding, ec_name); | |
| 3347 | |
| 3348 // Build an encoding rule which invokes the encoding rule we just | |
| 3349 // created, passing all arguments that we received. | |
| 3350 InsEncode* encrule = new InsEncode(); // Encode class for instruction | |
| 3351 NameAndList* params = encrule->add_encode(ec_name); | |
| 3352 inst._parameters.reset(); | |
| 3353 while ((param = inst._parameters.iter()) != NULL) { | |
| 3354 params->add_entry(param); | |
| 3355 } | |
| 3356 | |
| 3357 // Set encode class of this instruction. | |
| 3358 inst._constant = encrule; | |
| 3359 } | |
| 3360 | |
| 3361 | |
| 3362 //------------------------------constant_parse_expression---------------------- | |
| 3363 void ADLParser::constant_parse_expression(EncClass* encoding, char* ec_name) { | |
| 3364 skipws(); | |
| 3365 | |
| 3366 // Prepend location descriptor, for debugging; cf. ADLParser::find_cpp_block | |
| 3367 if (_AD._adlocation_debug) { | |
| 3368 encoding->add_code(get_line_string()); | |
| 3369 } | |
| 3370 | |
| 3371 // Start code line. | |
| 3372 encoding->add_code(" _constant = C->constant_table().add"); | |
| 3373 | |
| 3374 // Parse everything in ( ) expression. | |
|
4114
6729bbc1fcd6
7003454: order constants in constant table by number of references in code
twisti
parents:
3842
diff
changeset
|
3375 encoding->add_code("(this, "); |
| 2008 | 3376 next_char(); // Skip '(' |
| 3377 int parens_depth = 1; | |
| 3378 | |
| 3379 // Collect the parts of the constant expression. | |
| 3380 // (1) strings that are passed through to output | |
| 3381 // (2) replacement/substitution variable, preceeded by a '$' | |
| 3382 while (parens_depth > 0) { | |
| 3383 if (_curchar == '(') { | |
| 3384 parens_depth++; | |
| 3385 encoding->add_code("("); | |
| 3386 next_char(); | |
| 3387 } | |
| 3388 else if (_curchar == ')') { | |
| 3389 parens_depth--; | |
|
4114
6729bbc1fcd6
7003454: order constants in constant table by number of references in code
twisti
parents:
3842
diff
changeset
|
3390 if (parens_depth > 0) |
|
6729bbc1fcd6
7003454: order constants in constant table by number of references in code
twisti
parents:
3842
diff
changeset
|
3391 encoding->add_code(")"); |
| 2008 | 3392 next_char(); |
| 3393 } | |
| 3394 else { | |
| 3395 // (1) | |
| 3396 // Check if there is a string to pass through to output | |
| 3397 char *start = _ptr; // Record start of the next string | |
| 3398 while ((_curchar != '$') && (_curchar != '(') && (_curchar != ')')) { | |
| 3399 next_char(); | |
| 3400 } | |
| 3401 // If a string was found, terminate it and record in EncClass | |
| 3402 if (start != _ptr) { | |
| 3403 *_ptr = '\0'; // Terminate the string | |
| 3404 encoding->add_code(start); | |
| 3405 } | |
| 3406 | |
| 3407 // (2) | |
| 3408 // If we are at a replacement variable, copy it and record in EncClass. | |
| 3409 if (_curchar == '$') { | |
| 3410 // Found replacement Variable | |
| 3411 char* rep_var = get_rep_var_ident_dup(); | |
| 3412 encoding->add_rep_var(rep_var); | |
| 3413 } | |
| 3414 } | |
| 3415 } | |
| 3416 | |
| 3417 // Finish code line. | |
|
4114
6729bbc1fcd6
7003454: order constants in constant table by number of references in code
twisti
parents:
3842
diff
changeset
|
3418 encoding->add_code(");"); |
| 2008 | 3419 |
| 3420 if (_AD._adlocation_debug) { | |
| 3421 encoding->add_code(end_line_marker()); | |
| 3422 } | |
| 3423 | |
| 3424 // Debug Stuff | |
| 3425 if (_AD._adl_debug > 1) fprintf(stderr, "EncodingClass Form: %s\n", ec_name); | |
| 0 | 3426 } |
| 3427 | |
| 3428 | |
| 3429 //------------------------------size_parse----------------------------------- | |
| 6850 | 3430 // Parse a 'size(<expr>)' attribute which specifies the size of the |
| 3431 // emitted instructions in bytes. <expr> can be a C++ expression, | |
| 3432 // e.g. a constant. | |
| 0 | 3433 char* ADLParser::size_parse(InstructForm *instr) { |
| 3434 char* sizeOfInstr = NULL; | |
| 3435 | |
| 3436 // Get value of the instruction's size | |
| 3437 skipws(); | |
| 3438 | |
| 3439 // Parse size | |
| 3440 sizeOfInstr = get_paren_expr("size expression"); | |
| 3441 if (sizeOfInstr == NULL) { | |
| 3442 parse_err(SYNERR, "size of opcode expected at %c\n", _curchar); | |
| 3443 return NULL; | |
| 3444 } | |
| 3445 | |
| 3446 skipws(); | |
| 3447 | |
| 3448 // Check for terminator | |
| 3449 if (_curchar != ';') { | |
| 3450 parse_err(SYNERR, "missing ';' in ins_attrib definition\n"); | |
| 3451 return NULL; | |
| 3452 } | |
| 3453 next_char(); // Advance past the ';' | |
| 3454 skipws(); // necessary for instr_parse() | |
| 3455 | |
| 3456 // Debug Stuff | |
| 3457 if (_AD._adl_debug > 1) { | |
| 3458 if (sizeOfInstr != NULL) { | |
| 3459 fprintf(stderr,"size of opcode: %s\n", sizeOfInstr); | |
| 3460 } | |
| 3461 } | |
| 3462 | |
| 3463 return sizeOfInstr; | |
| 3464 } | |
| 3465 | |
| 3466 | |
| 3467 //------------------------------opcode_parse----------------------------------- | |
| 3468 Opcode * ADLParser::opcode_parse(InstructForm *instr) { | |
| 3469 char *primary = NULL; | |
| 3470 char *secondary = NULL; | |
| 3471 char *tertiary = NULL; | |
| 3472 | |
| 3473 char *val = NULL; | |
| 3474 Opcode *opcode = NULL; | |
| 3475 | |
| 3476 // Get value of the instruction's opcode | |
| 3477 skipws(); | |
| 3478 if (_curchar != '(') { // Check for parenthesized operand list | |
| 3479 parse_err(SYNERR, "missing '(' in expand instruction declaration\n"); | |
| 3480 return NULL; | |
| 3481 } | |
| 3482 next_char(); // skip open paren | |
| 3483 skipws(); | |
| 3484 if (_curchar != ')') { | |
| 3485 // Parse primary, secondary, and tertiary opcodes, if provided. | |
| 3486 if ( ((primary = get_ident_or_literal_constant("primary opcode")) == NULL) ) { | |
| 3487 parse_err(SYNERR, "primary hex opcode expected at %c\n", _curchar); | |
| 3488 return NULL; | |
| 3489 } | |
| 3490 skipws(); | |
| 3491 if (_curchar == ',') { | |
| 3492 next_char(); | |
| 3493 skipws(); | |
| 3494 // Parse secondary opcode | |
| 3495 if ( ((secondary = get_ident_or_literal_constant("secondary opcode")) == NULL) ) { | |
| 3496 parse_err(SYNERR, "secondary hex opcode expected at %c\n", _curchar); | |
| 3497 return NULL; | |
| 3498 } | |
| 3499 skipws(); | |
| 3500 if (_curchar == ',') { | |
| 3501 next_char(); | |
| 3502 skipws(); | |
| 3503 // Parse tertiary opcode | |
| 3504 if ( ((tertiary = get_ident_or_literal_constant("tertiary opcode")) == NULL) ) { | |
| 3505 parse_err(SYNERR,"tertiary hex opcode expected at %c\n", _curchar); | |
| 3506 return NULL; | |
| 3507 } | |
| 3508 skipws(); | |
| 3509 } | |
| 3510 } | |
| 3511 skipws(); | |
| 3512 if (_curchar != ')') { | |
| 3513 parse_err(SYNERR, "Missing ')' in opcode description\n"); | |
| 3514 return NULL; | |
| 3515 } | |
| 3516 } | |
| 3517 next_char(); // Skip ')' | |
| 3518 skipws(); | |
| 3519 // Check for terminator | |
| 3520 if (_curchar != ';') { | |
| 3521 parse_err(SYNERR, "missing ';' in ins_attrib definition\n"); | |
| 3522 return NULL; | |
| 3523 } | |
| 3524 next_char(); // Advance past the ';' | |
| 3525 skipws(); // necessary for instr_parse() | |
| 3526 | |
| 3527 // Debug Stuff | |
| 3528 if (_AD._adl_debug > 1) { | |
| 3529 if (primary != NULL) fprintf(stderr,"primary opcode: %s\n", primary); | |
| 3530 if (secondary != NULL) fprintf(stderr,"secondary opcode: %s\n", secondary); | |
| 3531 if (tertiary != NULL) fprintf(stderr,"tertiary opcode: %s\n", tertiary); | |
| 3532 } | |
| 3533 | |
| 3534 // Generate new object and return | |
| 3535 opcode = new Opcode(primary, secondary, tertiary); | |
| 3536 return opcode; | |
| 3537 } | |
| 3538 | |
| 3539 | |
| 3540 //------------------------------interface_parse-------------------------------- | |
| 3541 Interface *ADLParser::interface_parse(void) { | |
| 3542 char *iface_name = NULL; // Name of interface class being used | |
| 3543 char *iface_code = NULL; // Describe components of this class | |
| 3544 | |
| 3545 // Get interface class name | |
| 3546 skipws(); // Skip whitespace | |
| 3547 if (_curchar != '(') { | |
| 3548 parse_err(SYNERR, "Missing '(' at start of interface description.\n"); | |
| 3549 return NULL; | |
| 3550 } | |
| 3551 next_char(); // move past '(' | |
| 3552 skipws(); | |
| 3553 iface_name = get_ident(); | |
| 3554 if (iface_name == NULL) { | |
| 3555 parse_err(SYNERR, "missing interface name after 'interface'.\n"); | |
| 3556 return NULL; | |
| 3557 } | |
| 3558 skipws(); | |
| 3559 if (_curchar != ')') { | |
| 3560 parse_err(SYNERR, "Missing ')' after name of interface.\n"); | |
| 3561 return NULL; | |
| 3562 } | |
| 3563 next_char(); // move past ')' | |
| 3564 | |
| 3565 // Get details of the interface, | |
| 3566 // for the type of interface indicated by iface_name. | |
| 3567 Interface *inter = NULL; | |
| 3568 skipws(); | |
| 3569 if ( _curchar != ';' ) { | |
| 3570 if ( strcmp(iface_name,"MEMORY_INTER") == 0 ) { | |
| 3571 inter = mem_interface_parse(); | |
| 3572 } | |
| 3573 else if ( strcmp(iface_name,"COND_INTER") == 0 ) { | |
| 3574 inter = cond_interface_parse(); | |
| 3575 } | |
| 3576 // The parse routines consume the "%}" | |
| 3577 | |
| 3578 // Check for probable extra ';' after defining block. | |
| 3579 if ( _curchar == ';' ) { | |
| 3580 parse_err(SYNERR, "Extra ';' after defining interface block.\n"); | |
| 3581 next_char(); // Skip ';' | |
| 3582 return NULL; | |
| 3583 } | |
| 3584 } else { | |
| 3585 next_char(); // move past ';' | |
| 3586 | |
| 3587 // Create appropriate interface object | |
| 3588 if ( strcmp(iface_name,"REG_INTER") == 0 ) { | |
| 3589 inter = new RegInterface(); | |
| 3590 } | |
| 3591 else if ( strcmp(iface_name,"CONST_INTER") == 0 ) { | |
| 3592 inter = new ConstInterface(); | |
| 3593 } | |
| 3594 } | |
| 3595 skipws(); // be friendly to oper_parse() | |
| 3596 // Debug Stuff | |
| 3597 if (_AD._adl_debug > 1) fprintf(stderr,"Interface Form: %s\n", iface_name); | |
| 3598 | |
| 3599 // Create appropriate interface object and return. | |
| 3600 return inter; | |
| 3601 } | |
| 3602 | |
| 3603 | |
| 3604 //------------------------------mem_interface_parse---------------------------- | |
| 3605 Interface *ADLParser::mem_interface_parse(void) { | |
| 3606 // Fields for MemInterface | |
| 3607 char *base = NULL; | |
| 3608 char *index = NULL; | |
| 3609 char *scale = NULL; | |
| 3610 char *disp = NULL; | |
| 3611 | |
| 3612 if (_curchar != '%') { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
3613 parse_err(SYNERR, "Missing '%%{' for 'interface' block.\n"); |
| 0 | 3614 return NULL; |
| 3615 } | |
| 3616 next_char(); // Skip '%' | |
| 3617 if (_curchar != '{') { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
3618 parse_err(SYNERR, "Missing '%%{' for 'interface' block.\n"); |
| 0 | 3619 return NULL; |
| 3620 } | |
| 3621 next_char(); // Skip '{' | |
| 3622 skipws(); | |
| 3623 do { | |
| 3624 char *field = get_ident(); | |
| 3625 if (field == NULL) { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
3626 parse_err(SYNERR, "Expected keyword, base|index|scale|disp, or '%%}' ending interface.\n"); |
| 0 | 3627 return NULL; |
| 3628 } | |
| 3629 if ( strcmp(field,"base") == 0 ) { | |
| 3630 base = interface_field_parse(); | |
| 3631 } | |
| 3632 else if ( strcmp(field,"index") == 0 ) { | |
| 3633 index = interface_field_parse(); | |
| 3634 } | |
| 3635 else if ( strcmp(field,"scale") == 0 ) { | |
| 3636 scale = interface_field_parse(); | |
| 3637 } | |
| 3638 else if ( strcmp(field,"disp") == 0 ) { | |
| 3639 disp = interface_field_parse(); | |
| 3640 } | |
| 3641 else { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
3642 parse_err(SYNERR, "Expected keyword, base|index|scale|disp, or '%%}' ending interface.\n"); |
| 0 | 3643 return NULL; |
| 3644 } | |
| 3645 } while( _curchar != '%' ); | |
| 3646 next_char(); // Skip '%' | |
| 3647 if ( _curchar != '}' ) { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
3648 parse_err(SYNERR, "Missing '%%}' for 'interface' block.\n"); |
| 0 | 3649 return NULL; |
| 3650 } | |
| 3651 next_char(); // Skip '}' | |
| 3652 | |
| 3653 // Construct desired object and return | |
| 3654 Interface *inter = new MemInterface(base, index, scale, disp); | |
| 3655 return inter; | |
| 3656 } | |
| 3657 | |
| 3658 | |
| 3659 //------------------------------cond_interface_parse--------------------------- | |
| 3660 Interface *ADLParser::cond_interface_parse(void) { | |
| 3661 char *equal; | |
| 3662 char *not_equal; | |
| 3663 char *less; | |
| 3664 char *greater_equal; | |
| 3665 char *less_equal; | |
| 3666 char *greater; | |
| 12323 | 3667 char *overflow; |
| 3668 char *no_overflow; | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3669 const char *equal_format = "eq"; |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3670 const char *not_equal_format = "ne"; |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3671 const char *less_format = "lt"; |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3672 const char *greater_equal_format = "ge"; |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3673 const char *less_equal_format = "le"; |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3674 const char *greater_format = "gt"; |
| 12323 | 3675 const char *overflow_format = "o"; |
| 3676 const char *no_overflow_format = "no"; | |
| 0 | 3677 |
| 3678 if (_curchar != '%') { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
3679 parse_err(SYNERR, "Missing '%%{' for 'cond_interface' block.\n"); |
| 0 | 3680 return NULL; |
| 3681 } | |
| 3682 next_char(); // Skip '%' | |
| 3683 if (_curchar != '{') { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
3684 parse_err(SYNERR, "Missing '%%{' for 'cond_interface' block.\n"); |
| 0 | 3685 return NULL; |
| 3686 } | |
| 3687 next_char(); // Skip '{' | |
| 3688 skipws(); | |
| 3689 do { | |
| 3690 char *field = get_ident(); | |
| 3691 if (field == NULL) { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
3692 parse_err(SYNERR, "Expected keyword, base|index|scale|disp, or '%%}' ending interface.\n"); |
| 0 | 3693 return NULL; |
| 3694 } | |
| 3695 if ( strcmp(field,"equal") == 0 ) { | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3696 equal = interface_field_parse(&equal_format); |
| 0 | 3697 } |
| 3698 else if ( strcmp(field,"not_equal") == 0 ) { | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3699 not_equal = interface_field_parse(¬_equal_format); |
| 0 | 3700 } |
| 3701 else if ( strcmp(field,"less") == 0 ) { | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3702 less = interface_field_parse(&less_format); |
| 0 | 3703 } |
| 3704 else if ( strcmp(field,"greater_equal") == 0 ) { | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3705 greater_equal = interface_field_parse(&greater_equal_format); |
| 0 | 3706 } |
| 3707 else if ( strcmp(field,"less_equal") == 0 ) { | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3708 less_equal = interface_field_parse(&less_equal_format); |
| 0 | 3709 } |
| 3710 else if ( strcmp(field,"greater") == 0 ) { | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3711 greater = interface_field_parse(&greater_format); |
| 0 | 3712 } |
| 12323 | 3713 else if ( strcmp(field,"overflow") == 0 ) { |
| 3714 overflow = interface_field_parse(&overflow_format); | |
| 3715 } | |
| 3716 else if ( strcmp(field,"no_overflow") == 0 ) { | |
| 3717 no_overflow = interface_field_parse(&no_overflow_format); | |
| 3718 } | |
| 0 | 3719 else { |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
3720 parse_err(SYNERR, "Expected keyword, base|index|scale|disp, or '%%}' ending interface.\n"); |
| 0 | 3721 return NULL; |
| 3722 } | |
| 3723 } while( _curchar != '%' ); | |
| 3724 next_char(); // Skip '%' | |
| 3725 if ( _curchar != '}' ) { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
3726 parse_err(SYNERR, "Missing '%%}' for 'interface' block.\n"); |
| 0 | 3727 return NULL; |
| 3728 } | |
| 3729 next_char(); // Skip '}' | |
| 3730 | |
| 3731 // Construct desired object and return | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3732 Interface *inter = new CondInterface(equal, equal_format, |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3733 not_equal, not_equal_format, |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3734 less, less_format, |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3735 greater_equal, greater_equal_format, |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3736 less_equal, less_equal_format, |
| 12323 | 3737 greater, greater_format, |
| 3738 overflow, overflow_format, | |
| 3739 no_overflow, no_overflow_format); | |
| 0 | 3740 return inter; |
| 3741 } | |
| 3742 | |
| 3743 | |
| 3744 //------------------------------interface_field_parse-------------------------- | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3745 char *ADLParser::interface_field_parse(const char ** format) { |
| 0 | 3746 char *iface_field = NULL; |
| 3747 | |
| 3748 // Get interface field | |
| 3749 skipws(); // Skip whitespace | |
| 3750 if (_curchar != '(') { | |
| 3751 parse_err(SYNERR, "Missing '(' at start of interface field.\n"); | |
| 3752 return NULL; | |
| 3753 } | |
| 3754 next_char(); // move past '(' | |
| 3755 skipws(); | |
| 3756 if ( _curchar != '0' && _curchar != '$' ) { | |
| 3757 parse_err(SYNERR, "missing or invalid interface field contents.\n"); | |
| 3758 return NULL; | |
| 3759 } | |
| 3760 iface_field = get_rep_var_ident(); | |
| 3761 if (iface_field == NULL) { | |
| 3762 parse_err(SYNERR, "missing or invalid interface field contents.\n"); | |
| 3763 return NULL; | |
| 3764 } | |
| 3765 skipws(); | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3766 if (format != NULL && _curchar == ',') { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3767 next_char(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3768 skipws(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3769 if (_curchar != '"') { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3770 parse_err(SYNERR, "Missing '\"' in field format .\n"); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3771 return NULL; |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3772 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3773 next_char(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3774 char *start = _ptr; // Record start of the next string |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3775 while ((_curchar != '"') && (_curchar != '%') && (_curchar != '\n')) { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3776 if (_curchar == '\\') next_char(); // superquote |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3777 if (_curchar == '\n') parse_err(SYNERR, "newline in string"); // unimplemented! |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3778 next_char(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3779 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3780 if (_curchar != '"') { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3781 parse_err(SYNERR, "Missing '\"' at end of field format .\n"); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3782 return NULL; |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3783 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3784 // If a string was found, terminate it and record in FormatRule |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3785 if ( start != _ptr ) { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3786 *_ptr = '\0'; // Terminate the string |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3787 *format = start; |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3788 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3789 next_char(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3790 skipws(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3791 } |
| 0 | 3792 if (_curchar != ')') { |
| 3793 parse_err(SYNERR, "Missing ')' after interface field.\n"); | |
| 3794 return NULL; | |
| 3795 } | |
| 3796 next_char(); // move past ')' | |
| 3797 skipws(); | |
| 3798 if ( _curchar != ';' ) { | |
| 3799 parse_err(SYNERR, "Missing ';' at end of interface field.\n"); | |
| 3800 return NULL; | |
| 3801 } | |
| 3802 next_char(); // move past ';' | |
| 3803 skipws(); // be friendly to interface_parse() | |
| 3804 | |
| 3805 return iface_field; | |
| 3806 } | |
| 3807 | |
| 3808 | |
| 3809 //------------------------------match_parse------------------------------------ | |
| 3810 MatchRule *ADLParser::match_parse(FormDict &operands) { | |
| 3811 MatchRule *match; // Match Rule class for instruction/operand | |
| 3812 char *cnstr = NULL; // Code for constructor | |
| 3813 int depth = 0; // Counter for matching parentheses | |
| 3814 int numleaves = 0; // Counter for number of leaves in rule | |
| 3815 | |
| 3816 // Parse the match rule tree | |
| 3817 MatchNode *mnode = matchNode_parse(operands, depth, numleaves, true); | |
| 3818 | |
| 3819 // Either there is a block with a constructor, or a ';' here | |
| 3820 skipws(); // Skip whitespace | |
| 3821 if ( _curchar == ';' ) { // Semicolon is valid terminator | |
| 3822 cnstr = NULL; // no constructor for this form | |
| 3823 next_char(); // Move past the ';', replaced with '\0' | |
| 3824 } | |
| 3825 else if ((cnstr = find_cpp_block("match constructor")) == NULL ) { | |
| 3826 parse_err(SYNERR, "invalid construction of match rule\n" | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
3827 "Missing ';' or invalid '%%{' and '%%}' constructor\n"); |
| 0 | 3828 return NULL; // No MatchRule to return |
| 3829 } | |
| 3830 if (_AD._adl_debug > 1) | |
| 3831 if (cnstr) fprintf(stderr,"Match Constructor: %s\n", cnstr); | |
| 3832 // Build new MatchRule object | |
| 3833 match = new MatchRule(_AD, mnode, depth, cnstr, numleaves); | |
| 3834 skipws(); // Skip any trailing whitespace | |
| 3835 return match; // Return MatchRule object | |
| 3836 } | |
| 3837 | |
| 3838 //------------------------------format_parse----------------------------------- | |
| 3839 FormatRule* ADLParser::format_parse(void) { | |
| 3840 char *desc = NULL; | |
| 3841 FormatRule *format = (new FormatRule(desc)); | |
| 3842 | |
| 3843 // Without expression form, MUST have a code block; | |
| 3844 skipws(); // Skip whitespace | |
| 3845 if ( _curchar == ';' ) { // Semicolon is valid terminator | |
| 3846 desc = NULL; // no constructor for this form | |
| 3847 next_char(); // Move past the ';', replaced with '\0' | |
| 3848 } | |
| 3849 else if ( _curchar == '%' && *(_ptr+1) == '{') { | |
| 3850 next_char(); // Move past the '%' | |
| 3851 next_char(); // Move past the '{' | |
| 3852 | |
| 3853 skipws(); | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3854 if (_curchar == '$') { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3855 char* ident = get_rep_var_ident(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3856 if (strcmp(ident, "$$template") == 0) return template_parse(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3857 parse_err(SYNERR, "Unknown \"%s\" directive in format", ident); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3858 return NULL; |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3859 } |
| 0 | 3860 // Check for the opening '"' inside the format description |
| 3861 if ( _curchar == '"' ) { | |
| 3862 next_char(); // Move past the initial '"' | |
| 3863 if( _curchar == '"' ) { // Handle empty format string case | |
| 3864 *_ptr = '\0'; // Terminate empty string | |
| 3865 format->_strings.addName(_ptr); | |
| 3866 } | |
| 3867 | |
| 3868 // Collect the parts of the format description | |
| 3869 // (1) strings that are passed through to tty->print | |
| 3870 // (2) replacement/substitution variable, preceeded by a '$' | |
| 3871 // (3) multi-token ANSIY C style strings | |
| 3872 while ( true ) { | |
| 3873 if ( _curchar == '%' || _curchar == '\n' ) { | |
| 3874 if ( _curchar != '"' ) { | |
| 3875 parse_err(SYNERR, "missing '\"' at end of format block"); | |
| 3876 return NULL; | |
| 3877 } | |
| 3878 } | |
| 3879 | |
| 3880 // (1) | |
| 3881 // Check if there is a string to pass through to output | |
| 3882 char *start = _ptr; // Record start of the next string | |
| 3883 while ((_curchar != '$') && (_curchar != '"') && (_curchar != '%') && (_curchar != '\n')) { | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
3884 if (_curchar == '\\') { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
3885 next_char(); // superquote |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
3886 if ((_curchar == '$') || (_curchar == '%')) |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
3887 // hack to avoid % escapes and warnings about undefined \ escapes |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
3888 *(_ptr-1) = _curchar; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
3889 } |
| 0 | 3890 if (_curchar == '\n') parse_err(SYNERR, "newline in string"); // unimplemented! |
| 3891 next_char(); | |
| 3892 } | |
| 3893 // If a string was found, terminate it and record in FormatRule | |
| 3894 if ( start != _ptr ) { | |
| 3895 *_ptr = '\0'; // Terminate the string | |
| 3896 format->_strings.addName(start); | |
| 3897 } | |
| 3898 | |
| 3899 // (2) | |
| 3900 // If we are at a replacement variable, | |
| 3901 // copy it and record in FormatRule | |
| 3902 if ( _curchar == '$' ) { | |
| 3903 next_char(); // Move past the '$' | |
| 3904 char* rep_var = get_ident(); // Nil terminate the variable name | |
| 3905 rep_var = strdup(rep_var);// Copy the string | |
| 3906 *_ptr = _curchar; // and replace Nil with original character | |
| 3907 format->_rep_vars.addName(rep_var); | |
| 3908 // Add flag to _strings list indicating we should check _rep_vars | |
| 3909 format->_strings.addName(NameList::_signal); | |
| 3910 } | |
| 3911 | |
| 3912 // (3) | |
| 3913 // Allow very long strings to be broken up, | |
| 3914 // using the ANSI C syntax "foo\n" <newline> "bar" | |
| 3915 if ( _curchar == '"') { | |
| 3916 next_char(); // Move past the '"' | |
| 3917 skipws(); // Skip white space before next string token | |
| 3918 if ( _curchar != '"') { | |
| 3919 break; | |
| 3920 } else { | |
| 3921 // Found one. Skip both " and the whitespace in between. | |
| 3922 next_char(); | |
| 3923 } | |
| 3924 } | |
| 3925 } // end while part of format description | |
| 3926 | |
| 3927 // Check for closing '"' and '%}' in format description | |
| 3928 skipws(); // Move to closing '%}' | |
| 3929 if ( _curchar != '%' ) { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
3930 parse_err(SYNERR, "non-blank characters between closing '\"' and '%%' in format"); |
| 0 | 3931 return NULL; |
| 3932 } | |
| 3933 } // Done with format description inside | |
| 3934 | |
| 3935 skipws(); | |
| 3936 // Past format description, at '%' | |
| 3937 if ( _curchar != '%' || *(_ptr+1) != '}' ) { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
3938 parse_err(SYNERR, "missing '%%}' at end of format block"); |
| 0 | 3939 return NULL; |
| 3940 } | |
| 3941 next_char(); // Move past the '%' | |
| 3942 next_char(); // Move past the '}' | |
| 3943 } | |
| 3944 else { // parameter list alone must terminate with a ';' | |
| 3945 parse_err(SYNERR, "missing ';' after Format expression"); | |
| 3946 return NULL; | |
| 3947 } | |
| 3948 // Debug Stuff | |
| 3949 if (_AD._adl_debug > 1) fprintf(stderr,"Format Rule: %s\n", desc); | |
| 3950 | |
| 3951 skipws(); | |
| 3952 return format; | |
| 3953 } | |
| 3954 | |
| 3955 | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3956 //------------------------------template_parse----------------------------------- |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3957 FormatRule* ADLParser::template_parse(void) { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3958 char *desc = NULL; |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3959 FormatRule *format = (new FormatRule(desc)); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3960 |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3961 skipws(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3962 while ( (_curchar != '%') && (*(_ptr+1) != '}') ) { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3963 |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3964 // (1) |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3965 // Check if there is a string to pass through to output |
|
603
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3966 { |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3967 char *start = _ptr; // Record start of the next string |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3968 while ((_curchar != '$') && ((_curchar != '%') || (*(_ptr+1) != '}')) ) { |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3969 // If at the start of a comment, skip past it |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3970 if( (_curchar == '/') && ((*(_ptr+1) == '/') || (*(_ptr+1) == '*')) ) { |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3971 skipws_no_preproc(); |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3972 } else { |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3973 // ELSE advance to the next character, or start of the next line |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3974 next_char_or_line(); |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3975 } |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3976 } |
|
603
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3977 // If a string was found, terminate it and record in EncClass |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3978 if ( start != _ptr ) { |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3979 *_ptr = '\0'; // Terminate the string |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3980 // Add flag to _strings list indicating we should check _rep_vars |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3981 format->_strings.addName(NameList::_signal2); |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3982 format->_strings.addName(start); |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
3983 } |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3984 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3985 |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3986 // (2) |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3987 // If we are at a replacement variable, |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3988 // copy it and record in EncClass |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3989 if ( _curchar == '$' ) { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3990 // Found replacement Variable |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3991 char *rep_var = get_rep_var_ident_dup(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3992 if (strcmp(rep_var, "$emit") == 0) { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3993 // switch to normal format parsing |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3994 next_char(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3995 next_char(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3996 skipws(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3997 // Check for the opening '"' inside the format description |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3998 if ( _curchar == '"' ) { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
3999 next_char(); // Move past the initial '"' |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4000 if( _curchar == '"' ) { // Handle empty format string case |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4001 *_ptr = '\0'; // Terminate empty string |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4002 format->_strings.addName(_ptr); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4003 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4004 |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4005 // Collect the parts of the format description |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4006 // (1) strings that are passed through to tty->print |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4007 // (2) replacement/substitution variable, preceeded by a '$' |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4008 // (3) multi-token ANSIY C style strings |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4009 while ( true ) { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4010 if ( _curchar == '%' || _curchar == '\n' ) { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4011 parse_err(SYNERR, "missing '\"' at end of format block"); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4012 return NULL; |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4013 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4014 |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4015 // (1) |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4016 // Check if there is a string to pass through to output |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4017 char *start = _ptr; // Record start of the next string |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4018 while ((_curchar != '$') && (_curchar != '"') && (_curchar != '%') && (_curchar != '\n')) { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4019 if (_curchar == '\\') next_char(); // superquote |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4020 if (_curchar == '\n') parse_err(SYNERR, "newline in string"); // unimplemented! |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4021 next_char(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4022 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4023 // If a string was found, terminate it and record in FormatRule |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4024 if ( start != _ptr ) { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4025 *_ptr = '\0'; // Terminate the string |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4026 format->_strings.addName(start); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4027 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4028 |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4029 // (2) |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4030 // If we are at a replacement variable, |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4031 // copy it and record in FormatRule |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4032 if ( _curchar == '$' ) { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4033 next_char(); // Move past the '$' |
|
603
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
4034 char* next_rep_var = get_ident(); // Nil terminate the variable name |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
4035 next_rep_var = strdup(next_rep_var);// Copy the string |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4036 *_ptr = _curchar; // and replace Nil with original character |
|
603
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
4037 format->_rep_vars.addName(next_rep_var); |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4038 // Add flag to _strings list indicating we should check _rep_vars |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4039 format->_strings.addName(NameList::_signal); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4040 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4041 |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4042 // (3) |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4043 // Allow very long strings to be broken up, |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4044 // using the ANSI C syntax "foo\n" <newline> "bar" |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4045 if ( _curchar == '"') { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4046 next_char(); // Move past the '"' |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4047 skipws(); // Skip white space before next string token |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4048 if ( _curchar != '"') { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4049 break; |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4050 } else { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4051 // Found one. Skip both " and the whitespace in between. |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4052 next_char(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4053 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4054 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4055 } // end while part of format description |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4056 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4057 } else { |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4058 // Add flag to _strings list indicating we should check _rep_vars |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4059 format->_rep_vars.addName(rep_var); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4060 // Add flag to _strings list indicating we should check _rep_vars |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4061 format->_strings.addName(NameList::_signal3); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4062 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4063 } // end while part of format description |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4064 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4065 |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4066 skipws(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4067 // Past format description, at '%' |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4068 if ( _curchar != '%' || *(_ptr+1) != '}' ) { |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
4069 parse_err(SYNERR, "missing '%%}' at end of format block"); |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4070 return NULL; |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4071 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4072 next_char(); // Move past the '%' |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4073 next_char(); // Move past the '}' |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4074 |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4075 // Debug Stuff |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4076 if (_AD._adl_debug > 1) fprintf(stderr,"Format Rule: %s\n", desc); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4077 |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4078 skipws(); |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4079 return format; |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4080 } |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4081 |
|
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
4082 |
| 0 | 4083 //------------------------------effect_parse----------------------------------- |
| 4084 void ADLParser::effect_parse(InstructForm *instr) { | |
| 4085 char* desc = NULL; | |
| 4086 | |
| 4087 skipws(); // Skip whitespace | |
| 4088 if (_curchar != '(') { | |
| 4089 parse_err(SYNERR, "missing '(' in effect definition\n"); | |
| 4090 return; | |
| 4091 } | |
| 4092 // Get list of effect-operand pairs and insert into dictionary | |
|
4120
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4093 else get_effectlist(instr->_effects, instr->_localNames, instr->_has_call); |
| 0 | 4094 |
| 4095 // Debug Stuff | |
| 4096 if (_AD._adl_debug > 1) fprintf(stderr,"Effect description: %s\n", desc); | |
| 4097 if (_curchar != ';') { | |
| 4098 parse_err(SYNERR, "missing ';' in Effect definition\n"); | |
| 4099 } | |
| 4100 next_char(); // Skip ';' | |
| 4101 | |
| 4102 } | |
| 4103 | |
| 4104 //------------------------------expand_parse----------------------------------- | |
| 4105 ExpandRule* ADLParser::expand_parse(InstructForm *instr) { | |
| 4106 char *ident, *ident2; | |
| 4107 NameAndList *instr_and_operands = NULL; | |
| 4108 ExpandRule *exp = new ExpandRule(); | |
| 4109 | |
|
14431
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4110 // Expand is a block containing an ordered list of operands with initializers, |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4111 // or instructions, each of which has an ordered list of operands. |
| 0 | 4112 // Check for block delimiter |
| 4113 skipws(); // Skip leading whitespace | |
| 4114 if ((_curchar != '%') | |
| 4115 || (next_char(), (_curchar != '{')) ) { // If not open block | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
4116 parse_err(SYNERR, "missing '%%{' in expand definition\n"); |
| 0 | 4117 return(NULL); |
| 4118 } | |
| 4119 next_char(); // Maintain the invariant | |
| 4120 do { | |
| 4121 ident = get_ident(); // Grab next identifier | |
| 4122 if (ident == NULL) { | |
| 4123 parse_err(SYNERR, "identifier expected at %c\n", _curchar); | |
| 4124 continue; | |
|
14431
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4125 } |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4126 |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4127 // Check whether we should parse an instruction or operand. |
| 0 | 4128 const Form *form = _globalNames[ident]; |
|
14431
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4129 bool parse_oper = false; |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4130 bool parse_ins = false; |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4131 if (form == NULL) { |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4132 skipws(); |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4133 // Check whether this looks like an instruction specification. If so, |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4134 // just parse the instruction. The declaration of the instruction is |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4135 // not needed here. |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4136 if (_curchar == '(') parse_ins = true; |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4137 } else if (form->is_instruction()) { |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4138 parse_ins = true; |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4139 } else if (form->is_operand()) { |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4140 parse_oper = true; |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4141 } else { |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4142 parse_err(SYNERR, "instruction/operand name expected at %s\n", ident); |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4143 continue; |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4144 } |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4145 |
|
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4146 if (parse_oper) { |
| 0 | 4147 // This is a new operand |
|
14431
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4148 OperandForm *oper = form->is_operand(); |
| 0 | 4149 if (oper == NULL) { |
| 4150 parse_err(SYNERR, "instruction/operand name expected at %s\n", ident); | |
| 4151 continue; | |
| 4152 } | |
| 4153 // Throw the operand on the _newopers list | |
| 4154 skipws(); | |
| 4155 ident = get_unique_ident(instr->_localNames,"Operand"); | |
| 4156 if (ident == NULL) { | |
| 4157 parse_err(SYNERR, "identifier expected at %c\n", _curchar); | |
| 4158 continue; | |
| 4159 } | |
| 4160 exp->_newopers.addName(ident); | |
| 4161 // Add new operand to LocalNames | |
| 4162 instr->_localNames.Insert(ident, oper); | |
| 4163 // Grab any constructor code and save as a string | |
| 4164 char *c = NULL; | |
| 4165 skipws(); | |
| 4166 if (_curchar == '%') { // Need a constructor for the operand | |
| 4167 c = find_cpp_block("Operand Constructor"); | |
| 4168 if (c == NULL) { | |
| 4169 parse_err(SYNERR, "Invalid code block for operand constructor\n", _curchar); | |
| 4170 continue; | |
| 4171 } | |
| 4172 // Add constructor to _newopconst Dict | |
| 4173 exp->_newopconst.Insert(ident, c); | |
| 4174 } | |
| 4175 else if (_curchar != ';') { // If no constructor, need a ; | |
| 4176 parse_err(SYNERR, "Missing ; in expand rule operand declaration\n"); | |
| 4177 continue; | |
| 4178 } | |
| 4179 else next_char(); // Skip the ; | |
| 4180 skipws(); | |
| 4181 } | |
| 4182 else { | |
|
14431
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4183 assert(parse_ins, "sanity"); |
| 0 | 4184 // Add instruction to list |
| 4185 instr_and_operands = new NameAndList(ident); | |
| 4186 // Grab operands, build nameList of them, and then put into dictionary | |
| 4187 skipws(); | |
| 4188 if (_curchar != '(') { // Check for parenthesized operand list | |
| 4189 parse_err(SYNERR, "missing '(' in expand instruction declaration\n"); | |
| 4190 continue; | |
| 4191 } | |
| 4192 do { | |
| 4193 next_char(); // skip open paren & comma characters | |
| 4194 skipws(); | |
| 4195 if (_curchar == ')') break; | |
| 4196 ident2 = get_ident(); | |
| 4197 skipws(); | |
| 4198 if (ident2 == NULL) { | |
| 4199 parse_err(SYNERR, "identifier expected at %c\n", _curchar); | |
| 4200 continue; | |
| 4201 } // Check that you have a valid operand | |
|
603
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
4202 const Form *form2 = instr->_localNames[ident2]; |
|
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
4203 if (!form2) { |
| 0 | 4204 parse_err(SYNERR, "operand name expected at %s\n", ident2); |
| 4205 continue; | |
| 4206 } | |
|
14431
1410ad6b05f1
8028401: PPC (part 117): Improve usability of adlc and format() functionality.
goetz
parents:
14428
diff
changeset
|
4207 OperandForm *oper = form2->is_operand(); |
|
603
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
4208 if (oper == NULL && !form2->is_opclass()) { |
| 0 | 4209 parse_err(SYNERR, "operand name expected at %s\n", ident2); |
| 4210 continue; | |
| 4211 } // Add operand to list | |
| 4212 instr_and_operands->add_entry(ident2); | |
| 4213 } while(_curchar == ','); | |
| 4214 if (_curchar != ')') { | |
| 4215 parse_err(SYNERR, "missing ')'in expand instruction declaration\n"); | |
| 4216 continue; | |
| 4217 } | |
| 4218 next_char(); | |
| 4219 if (_curchar != ';') { | |
| 4220 parse_err(SYNERR, "missing ';'in expand instruction declaration\n"); | |
| 4221 continue; | |
| 4222 } | |
| 4223 next_char(); | |
| 4224 | |
| 4225 // Record both instruction name and its operand list | |
| 4226 exp->add_instruction(instr_and_operands); | |
| 4227 | |
| 4228 skipws(); | |
| 4229 } | |
| 4230 | |
| 4231 } while(_curchar != '%'); | |
| 4232 next_char(); | |
| 4233 if (_curchar != '}') { | |
|
7996
39901f2f1abe
8007403: Incorrect format arguments in adlparse.cpp
mikael
parents:
6850
diff
changeset
|
4234 parse_err(SYNERR, "missing '%%}' in expand rule definition\n"); |
| 0 | 4235 return(NULL); |
| 4236 } | |
| 4237 next_char(); | |
| 4238 | |
| 4239 // Debug Stuff | |
| 4240 if (_AD._adl_debug > 1) fprintf(stderr,"Expand Rule:\n"); | |
| 4241 | |
| 4242 skipws(); | |
| 4243 return (exp); | |
| 4244 } | |
| 4245 | |
| 4246 //------------------------------rewrite_parse---------------------------------- | |
| 4247 RewriteRule* ADLParser::rewrite_parse(void) { | |
| 4248 char* params = NULL; | |
| 4249 char* desc = NULL; | |
| 4250 | |
| 4251 | |
| 4252 // This feature targeted for second generation description language. | |
| 4253 | |
| 4254 skipws(); // Skip whitespace | |
| 4255 // Get parameters for rewrite | |
| 4256 if ((params = get_paren_expr("rewrite parameters")) == NULL) { | |
| 4257 parse_err(SYNERR, "missing '(' in rewrite rule\n"); | |
| 4258 return NULL; | |
| 4259 } | |
| 4260 // Debug Stuff | |
| 4261 if (_AD._adl_debug > 1) fprintf(stderr,"Rewrite parameters: %s\n", params); | |
| 4262 | |
| 4263 // For now, grab entire block; | |
| 4264 skipws(); | |
| 4265 if ( (desc = find_cpp_block("rewrite block")) == NULL ) { | |
| 4266 parse_err(SYNERR, "incorrect or missing block for 'rewrite'.\n"); | |
| 4267 return NULL; | |
| 4268 } | |
| 4269 // Debug Stuff | |
| 4270 if (_AD._adl_debug > 1) fprintf(stderr,"Rewrite Rule: %s\n", desc); | |
| 4271 | |
| 4272 skipws(); | |
| 4273 return (new RewriteRule(params,desc)); | |
| 4274 } | |
| 4275 | |
| 4276 //------------------------------attr_parse------------------------------------- | |
| 4277 Attribute *ADLParser::attr_parse(char* ident) { | |
| 4278 Attribute *attrib; // Attribute class | |
| 4279 char *cost = NULL; // String representation of cost attribute | |
| 4280 | |
| 4281 skipws(); // Skip leading whitespace | |
| 4282 if ( (cost = get_paren_expr("attribute")) == NULL ) { | |
| 4283 parse_err(SYNERR, "incorrect or missing expression for 'attribute'\n"); | |
| 4284 return NULL; | |
| 4285 } | |
| 4286 // Debug Stuff | |
| 4287 if (_AD._adl_debug > 1) fprintf(stderr,"Attribute: %s\n", cost); | |
| 4288 if (_curchar != ';') { | |
| 4289 parse_err(SYNERR, "missing ';' in attribute definition\n"); | |
| 4290 return NULL; | |
| 4291 } | |
| 4292 next_char(); // Point after the terminator | |
| 4293 | |
| 4294 skipws(); | |
| 4295 attrib = new Attribute(ident,cost,INS_ATTR); // Build new predicate object | |
| 4296 return attrib; | |
| 4297 } | |
| 4298 | |
| 4299 | |
| 4300 //------------------------------matchNode_parse-------------------------------- | |
| 4301 MatchNode *ADLParser::matchNode_parse(FormDict &operands, int &depth, int &numleaves, bool atroot) { | |
| 4302 // Count depth of parenthesis nesting for both left and right children | |
| 4303 int lParens = depth; | |
| 4304 int rParens = depth; | |
| 4305 | |
| 4306 // MatchNode objects for left, right, and root of subtree. | |
| 4307 MatchNode *lChild = NULL; | |
| 4308 MatchNode *rChild = NULL; | |
| 4309 char *token; // Identifier which may be opcode or operand | |
| 4310 | |
| 4311 // Match expression starts with a '(' | |
| 4312 if (cur_char() != '(') | |
| 4313 return NULL; | |
| 4314 | |
| 4315 next_char(); // advance past '(' | |
| 4316 | |
| 4317 // Parse the opcode | |
| 4318 token = get_ident(); // Get identifier, opcode | |
| 4319 if (token == NULL) { | |
| 4320 parse_err(SYNERR, "missing opcode in match expression\n"); | |
| 4321 return NULL; | |
| 4322 } | |
| 4323 | |
| 4324 // Take note if we see one of a few special operations - those that are | |
| 4325 // treated differently on different architectures in the sense that on | |
| 4326 // one architecture there is a match rule and on another there isn't (so | |
| 4327 // a call will eventually be generated). | |
| 4328 | |
| 4329 for (int i = _last_machine_leaf + 1; i < _last_opcode; i++) { | |
| 4330 if (strcmp(token, NodeClassNames[i]) == 0) { | |
| 4331 _AD.has_match_rule(i, true); | |
| 4332 } | |
| 4333 } | |
| 4334 | |
| 4335 // Lookup the root value in the operands dict to perform substitution | |
| 4336 const char *result = NULL; // Result type will be filled in later | |
| 4337 const char *name = token; // local name associated with this node | |
| 4338 const char *operation = token; // remember valid operation for later | |
| 4339 const Form *form = operands[token]; | |
| 4340 OpClassForm *opcForm = form ? form->is_opclass() : NULL; | |
| 4341 if (opcForm != NULL) { | |
| 4342 // If this token is an entry in the local names table, record its type | |
| 4343 if (!opcForm->ideal_only()) { | |
| 4344 operation = opcForm->_ident; | |
| 4345 result = operation; // Operands result in their own type | |
| 4346 } | |
| 4347 // Otherwise it is an ideal type, and so, has no local name | |
| 4348 else name = NULL; | |
| 4349 } | |
| 4350 | |
| 4351 // Parse the operands | |
| 4352 skipws(); | |
| 4353 if (cur_char() != ')') { | |
| 4354 | |
| 4355 // Parse the left child | |
| 4356 if (strcmp(operation,"Set")) | |
| 4357 lChild = matchChild_parse(operands, lParens, numleaves, false); | |
| 4358 else | |
| 4359 lChild = matchChild_parse(operands, lParens, numleaves, true); | |
| 4360 | |
| 4361 skipws(); | |
| 4362 if (cur_char() != ')' ) { | |
| 4363 if(strcmp(operation, "Set")) | |
| 4364 rChild = matchChild_parse(operands,rParens,numleaves,false); | |
| 4365 else | |
| 4366 rChild = matchChild_parse(operands,rParens,numleaves,true); | |
| 4367 } | |
| 4368 } | |
| 4369 | |
| 4370 // Check for required ')' | |
| 4371 skipws(); | |
| 4372 if (cur_char() != ')') { | |
| 4373 parse_err(SYNERR, "missing ')' in match expression\n"); | |
| 4374 return NULL; | |
| 4375 } | |
| 4376 next_char(); // skip the ')' | |
| 4377 | |
| 4378 MatchNode* mroot = new MatchNode(_AD,result,name,operation,lChild,rChild); | |
| 4379 | |
| 4380 // If not the root, reduce this subtree to an internal operand | |
| 4381 if (!atroot) { | |
| 4382 mroot->build_internalop(); | |
| 4383 } | |
| 4384 // depth is greater of left and right paths. | |
| 4385 depth = (lParens > rParens) ? lParens : rParens; | |
| 4386 | |
| 4387 return mroot; | |
| 4388 } | |
| 4389 | |
| 4390 | |
| 4391 //------------------------------matchChild_parse------------------------------- | |
| 4392 MatchNode *ADLParser::matchChild_parse(FormDict &operands, int &parens, int &numleaves, bool atroot) { | |
| 4393 MatchNode *child = NULL; | |
| 4394 const char *result = NULL; | |
| 4395 const char *token = NULL; | |
| 4396 const char *opType = NULL; | |
| 4397 | |
| 4398 if (cur_char() == '(') { // child is an operation | |
| 4399 ++parens; | |
| 4400 child = matchNode_parse(operands, parens, numleaves, atroot); | |
| 4401 } | |
| 4402 else { // child is an operand | |
| 4403 token = get_ident(); | |
| 4404 const Form *form = operands[token]; | |
| 4405 OpClassForm *opcForm = form ? form->is_opclass() : NULL; | |
| 4406 if (opcForm != NULL) { | |
| 4407 opType = opcForm->_ident; | |
| 4408 result = opcForm->_ident; // an operand's result matches its type | |
| 4409 } else { | |
| 4410 parse_err(SYNERR, "undefined operand %s in match rule\n", token); | |
| 4411 return NULL; | |
| 4412 } | |
| 4413 | |
| 4414 if (opType == NULL) { | |
| 4415 parse_err(SYNERR, "missing type for argument '%s'\n", token); | |
| 4416 } | |
| 4417 | |
| 4418 child = new MatchNode(_AD, result, token, opType); | |
| 4419 ++numleaves; | |
| 4420 } | |
| 4421 | |
| 4422 return child; | |
| 4423 } | |
| 4424 | |
| 4425 | |
| 4426 | |
| 4427 // ******************** Private Utility Functions ************************* | |
| 4428 | |
| 4429 | |
| 4430 char* ADLParser::find_cpp_block(const char* description) { | |
| 4431 char *next; // Pointer for finding block delimiters | |
| 4432 char* cppBlock = NULL; // Beginning of C++ code block | |
| 4433 | |
| 4434 if (_curchar == '%') { // Encoding is a C++ expression | |
| 4435 next_char(); | |
| 4436 if (_curchar != '{') { | |
| 4437 parse_err(SYNERR, "missing '{' in %s \n", description); | |
| 4438 return NULL; | |
| 4439 } | |
| 4440 next_char(); // Skip block delimiter | |
| 4441 skipws_no_preproc(); // Skip leading whitespace | |
| 4442 cppBlock = _ptr; // Point to start of expression | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4443 int line = linenum(); |
| 0 | 4444 next = _ptr + 1; |
| 4445 while(((_curchar != '%') || (*next != '}')) && (_curchar != '\0')) { | |
| 4446 next_char_or_line(); | |
| 4447 next = _ptr+1; // Maintain the next pointer | |
| 4448 } // Grab string | |
| 4449 if (_curchar == '\0') { | |
| 4450 parse_err(SYNERR, "invalid termination of %s \n", description); | |
| 4451 return NULL; | |
| 4452 } | |
| 4453 *_ptr = '\0'; // Terminate string | |
| 4454 _ptr += 2; // Skip block delimiter | |
| 4455 _curchar = *_ptr; // Maintain invariant | |
| 4456 | |
| 4457 // Prepend location descriptor, for debugging. | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4458 if (_AD._adlocation_debug) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4459 char* location = get_line_string(line); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4460 char* end_loc = end_line_marker(); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4461 char* result = (char *)malloc(strlen(location) + strlen(cppBlock) + strlen(end_loc) + 1); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4462 strcpy(result, location); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4463 strcat(result, cppBlock); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4464 strcat(result, end_loc); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4465 cppBlock = result; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4466 free(location); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4467 } |
| 0 | 4468 } |
| 4469 | |
| 4470 return cppBlock; | |
| 4471 } | |
| 4472 | |
| 4473 // Move to the closing token of the expression we are currently at, | |
| 4474 // as defined by stop_chars. Match parens and quotes. | |
| 4475 char* ADLParser::get_expr(const char *desc, const char *stop_chars) { | |
| 4476 char* expr = NULL; | |
| 4477 int paren = 0; | |
| 4478 | |
| 4479 expr = _ptr; | |
| 4480 while (paren > 0 || !strchr(stop_chars, _curchar)) { | |
| 4481 if (_curchar == '(') { // Down level of nesting | |
| 4482 paren++; // Bump the parenthesis counter | |
| 4483 next_char(); // maintain the invariant | |
| 4484 } | |
| 4485 else if (_curchar == ')') { // Up one level of nesting | |
| 4486 if (paren == 0) { | |
| 4487 // Paren underflow: We didn't encounter the required stop-char. | |
| 4488 parse_err(SYNERR, "too many )'s, did not find %s after %s\n", | |
| 4489 stop_chars, desc); | |
| 4490 return NULL; | |
| 4491 } | |
| 4492 paren--; // Drop the parenthesis counter | |
| 4493 next_char(); // Maintain the invariant | |
| 4494 } | |
| 4495 else if (_curchar == '"' || _curchar == '\'') { | |
| 4496 int qchar = _curchar; | |
| 4497 while (true) { | |
| 4498 next_char(); | |
| 4499 if (_curchar == qchar) { next_char(); break; } | |
| 4500 if (_curchar == '\\') next_char(); // superquote | |
| 4501 if (_curchar == '\n' || _curchar == '\0') { | |
| 4502 parse_err(SYNERR, "newline in string in %s\n", desc); | |
| 4503 return NULL; | |
| 4504 } | |
| 4505 } | |
| 4506 } | |
| 4507 else if (_curchar == '%' && (_ptr[1] == '{' || _ptr[1] == '}')) { | |
| 4508 // Make sure we do not stray into the next ADLC-level form. | |
| 4509 parse_err(SYNERR, "unexpected %%%c in %s\n", _ptr[1], desc); | |
| 4510 return NULL; | |
| 4511 } | |
| 4512 else if (_curchar == '\0') { | |
| 4513 parse_err(SYNERR, "unexpected EOF in %s\n", desc); | |
| 4514 return NULL; | |
| 4515 } | |
| 4516 else { | |
| 4517 // Always walk over whitespace, comments, preprocessor directives, etc. | |
| 4518 char* pre_skip_ptr = _ptr; | |
| 4519 skipws(); | |
| 4520 // If the parser declined to make progress on whitespace, | |
| 4521 // skip the next character, which is therefore NOT whitespace. | |
| 4522 if (pre_skip_ptr == _ptr) { | |
| 4523 next_char(); | |
| 4524 } else if (pre_skip_ptr+strlen(pre_skip_ptr) != _ptr+strlen(_ptr)) { | |
| 4525 parse_err(SYNERR, "unimplemented: preprocessor must not elide subexpression in %s", desc); | |
| 4526 } | |
| 4527 } | |
| 4528 } | |
| 4529 | |
| 4530 assert(strchr(stop_chars, _curchar), "non-null return must be at stop-char"); | |
| 4531 *_ptr = '\0'; // Replace ')' or other stop-char with '\0' | |
| 4532 return expr; | |
| 4533 } | |
| 4534 | |
| 4535 // Helper function around get_expr | |
| 4536 // Sets _curchar to '(' so that get_paren_expr will search for a matching ')' | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4537 char *ADLParser::get_paren_expr(const char *description, bool include_location) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4538 int line = linenum(); |
| 0 | 4539 if (_curchar != '(') // Escape if not valid starting position |
| 4540 return NULL; | |
| 4541 next_char(); // Skip the required initial paren. | |
| 4542 char *token2 = get_expr(description, ")"); | |
| 4543 if (_curchar == ')') | |
| 4544 next_char(); // Skip required final paren. | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4545 int junk = 0; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4546 if (include_location && _AD._adlocation_debug && !is_int_token(token2, junk)) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4547 // Prepend location descriptor, for debugging. |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4548 char* location = get_line_string(line); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4549 char* end_loc = end_line_marker(); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4550 char* result = (char *)malloc(strlen(location) + strlen(token2) + strlen(end_loc) + 1); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4551 strcpy(result, location); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4552 strcat(result, token2); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4553 strcat(result, end_loc); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4554 token2 = result; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4555 free(location); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4556 } |
| 0 | 4557 return token2; |
| 4558 } | |
| 4559 | |
| 4560 //------------------------------get_ident_common------------------------------- | |
| 4561 // Looks for an identifier in the buffer, and turns it into a null terminated | |
| 4562 // string(still inside the file buffer). Returns a pointer to the string or | |
| 4563 // NULL if some other token is found instead. | |
| 4564 char *ADLParser::get_ident_common(bool do_preproc) { | |
| 4565 register char c; | |
| 4566 char *start; // Pointer to start of token | |
| 4567 char *end; // Pointer to end of token | |
| 4568 | |
| 4569 if( _curline == NULL ) // Return NULL at EOF. | |
| 4570 return NULL; | |
| 4571 | |
| 4572 skipws_common(do_preproc); // Skip whitespace before identifier | |
| 4573 start = end = _ptr; // Start points at first character | |
| 4574 end--; // unwind end by one to prepare for loop | |
| 4575 do { | |
| 4576 end++; // Increment end pointer | |
| 4577 c = *end; // Grab character to test | |
| 4578 } while ( ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) | |
| 4579 || ((c >= '0') && (c <= '9')) | |
| 4580 || ((c == '_')) || ((c == ':')) || ((c == '#')) ); | |
| 4581 if (start == end) { // We popped out on the first try | |
| 6850 | 4582 // It can occur that `start' contains the rest of the input file. |
| 4583 // In this case the output should be truncated. | |
| 4584 if (strlen(start) > 24) { | |
| 4585 char buf[32]; | |
| 4586 strncpy(buf, start, 20); | |
| 4587 buf[20] = '\0'; | |
| 4588 strcat(buf, "[...]"); | |
| 4589 parse_err(SYNERR, "Identifier expected, but found '%s'.", buf); | |
| 4590 } else { | |
| 4591 parse_err(SYNERR, "Identifier expected, but found '%s'.", start); | |
| 4592 } | |
| 0 | 4593 start = NULL; |
| 4594 } | |
| 4595 else { | |
| 4596 _curchar = c; // Save the first character of next token | |
| 4597 *end = '\0'; // NULL terminate the string in place | |
| 4598 } | |
| 4599 _ptr = end; // Reset _ptr to point to next char after token | |
| 4600 | |
| 4601 // Make sure we do not try to use #defined identifiers. If start is | |
| 4602 // NULL an error was already reported. | |
| 4603 if (do_preproc && start != NULL) { | |
| 4604 const char* def = _AD.get_preproc_def(start); | |
| 4605 if (def != NULL && strcmp(def, start)) { | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4606 const char* def1 = def; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4607 const char* def2 = _AD.get_preproc_def(def1); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4608 // implement up to 2 levels of #define |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4609 if (def2 != NULL && strcmp(def2, def1)) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4610 def = def2; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4611 const char* def3 = _AD.get_preproc_def(def2); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4612 if (def3 != NULL && strcmp(def3, def2) && strcmp(def3, def1)) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4613 parse_err(SYNERR, "unimplemented: using %s defined as %s => %s => %s", |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4614 start, def1, def2, def3); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4615 } |
| 0 | 4616 } |
| 4617 start = strdup(def); | |
| 4618 } | |
| 4619 } | |
| 4620 | |
| 4621 return start; // Pointer to token in filebuf | |
| 4622 } | |
| 4623 | |
| 4624 //------------------------------get_ident_dup---------------------------------- | |
| 4625 // Looks for an identifier in the buffer, and returns a duplicate | |
| 4626 // or NULL if some other token is found instead. | |
| 4627 char *ADLParser::get_ident_dup(void) { | |
| 4628 char *ident = get_ident(); | |
| 4629 | |
| 4630 // Duplicate an identifier before returning and restore string. | |
| 4631 if( ident != NULL ) { | |
| 4632 ident = strdup(ident); // Copy the string | |
| 4633 *_ptr = _curchar; // and replace Nil with original character | |
| 4634 } | |
| 4635 | |
| 4636 return ident; | |
| 4637 } | |
| 4638 | |
| 4639 //----------------------get_ident_or_literal_constant-------------------------- | |
| 4640 // Looks for an identifier in the buffer, or a parenthesized expression. | |
| 4641 char *ADLParser::get_ident_or_literal_constant(const char* description) { | |
| 4642 char* param = NULL; | |
| 4643 skipws(); | |
| 4644 if (_curchar == '(') { | |
| 4645 // Grab a constant expression. | |
| 4646 param = get_paren_expr(description); | |
| 4647 if (param[0] != '(') { | |
| 4648 char* buf = (char*) malloc(strlen(param) + 3); | |
| 4649 sprintf(buf, "(%s)", param); | |
| 4650 param = buf; | |
| 4651 } | |
| 4652 assert(is_literal_constant(param), | |
| 4653 "expr must be recognizable as a constant"); | |
| 4654 } else { | |
| 4655 param = get_ident(); | |
| 4656 } | |
| 4657 return param; | |
| 4658 } | |
| 4659 | |
| 4660 //------------------------------get_rep_var_ident----------------------------- | |
| 4661 // Do NOT duplicate, | |
| 4662 // Leave nil terminator in buffer | |
| 4663 // Preserve initial '$'(s) in string | |
| 4664 char *ADLParser::get_rep_var_ident(void) { | |
| 4665 // Remember starting point | |
| 4666 char *rep_var = _ptr; | |
| 4667 | |
| 4668 // Check for replacement variable indicator '$' and pass if present | |
| 4669 if ( _curchar == '$' ) { | |
| 4670 next_char(); | |
| 4671 } | |
| 4672 // Check for a subfield indicator, a second '$', and pass if present | |
| 4673 if ( _curchar == '$' ) { | |
| 4674 next_char(); | |
| 4675 } | |
| 4676 | |
| 4677 // Check for a control indicator, a third '$': | |
| 4678 if ( _curchar == '$' ) { | |
| 4679 next_char(); | |
| 4680 } | |
| 4681 | |
| 4682 // Check for more than three '$'s in sequence, SYNERR | |
| 4683 if( _curchar == '$' ) { | |
| 4684 parse_err(SYNERR, "Replacement variables and field specifiers can not start with '$$$$'"); | |
| 4685 next_char(); | |
| 4686 return NULL; | |
| 4687 } | |
| 4688 | |
| 4689 // Nil terminate the variable name following the '$' | |
| 4690 char *rep_var_name = get_ident(); | |
| 4691 assert( rep_var_name != NULL, | |
| 4692 "Missing identifier after replacement variable indicator '$'"); | |
| 4693 | |
| 4694 return rep_var; | |
| 4695 } | |
| 4696 | |
| 4697 | |
| 4698 | |
| 4699 //------------------------------get_rep_var_ident_dup------------------------- | |
| 4700 // Return the next replacement variable identifier, skipping first '$' | |
| 4701 // given a pointer into a line of the buffer. | |
| 4702 // Null terminates string, still inside the file buffer, | |
| 4703 // Returns a pointer to a copy of the string, or NULL on failure | |
| 4704 char *ADLParser::get_rep_var_ident_dup(void) { | |
| 4705 if( _curchar != '$' ) return NULL; | |
| 4706 | |
| 4707 next_char(); // Move past the '$' | |
| 4708 char *rep_var = _ptr; // Remember starting point | |
| 4709 | |
| 4710 // Check for a subfield indicator, a second '$': | |
| 4711 if ( _curchar == '$' ) { | |
| 4712 next_char(); | |
| 4713 } | |
| 4714 | |
| 4715 // Check for a control indicator, a third '$': | |
| 4716 if ( _curchar == '$' ) { | |
| 4717 next_char(); | |
| 4718 } | |
| 4719 | |
| 4720 // Check for more than three '$'s in sequence, SYNERR | |
| 4721 if( _curchar == '$' ) { | |
| 4722 parse_err(SYNERR, "Replacement variables and field specifiers can not start with '$$$$'"); | |
| 4723 next_char(); | |
| 4724 return NULL; | |
| 4725 } | |
| 4726 | |
| 4727 // Nil terminate the variable name following the '$' | |
| 4728 char *rep_var_name = get_ident(); | |
| 4729 assert( rep_var_name != NULL, | |
| 4730 "Missing identifier after replacement variable indicator '$'"); | |
| 4731 rep_var = strdup(rep_var); // Copy the string | |
| 4732 *_ptr = _curchar; // and replace Nil with original character | |
| 4733 | |
| 4734 return rep_var; | |
| 4735 } | |
| 4736 | |
| 4737 | |
| 4738 //------------------------------get_unique_ident------------------------------ | |
| 4739 // Looks for an identifier in the buffer, terminates it with a NULL, | |
| 4740 // and checks that it is unique | |
| 4741 char *ADLParser::get_unique_ident(FormDict& dict, const char* nameDescription){ | |
| 4742 char* ident = get_ident(); | |
| 4743 | |
| 4744 if (ident == NULL) { | |
| 4745 parse_err(SYNERR, "missing %s identifier at %c\n", nameDescription, _curchar); | |
| 4746 } | |
| 4747 else { | |
| 4748 if (dict[ident] != NULL) { | |
| 4749 parse_err(SYNERR, "duplicate name %s for %s\n", ident, nameDescription); | |
| 4750 ident = NULL; | |
| 4751 } | |
| 4752 } | |
| 4753 | |
| 4754 return ident; | |
| 4755 } | |
| 4756 | |
| 4757 | |
| 4758 //------------------------------get_int---------------------------------------- | |
| 4759 // Looks for a character string integer in the buffer, and turns it into an int | |
| 4760 // invokes a parse_err if the next token is not an integer. | |
| 4761 // This routine does not leave the integer null-terminated. | |
| 4762 int ADLParser::get_int(void) { | |
| 4763 register char c; | |
| 4764 char *start; // Pointer to start of token | |
| 4765 char *end; // Pointer to end of token | |
| 4766 int result; // Storage for integer result | |
| 4767 | |
| 4768 if( _curline == NULL ) // Return NULL at EOF. | |
|
603
dbbe28fc66b5
6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents:
488
diff
changeset
|
4769 return 0; |
| 0 | 4770 |
| 4771 skipws(); // Skip whitespace before identifier | |
| 4772 start = end = _ptr; // Start points at first character | |
| 4773 c = *end; // Grab character to test | |
| 4774 while ((c >= '0') && (c <= '9') | |
| 4775 || ((c == '-') && (end == start))) { | |
| 4776 end++; // Increment end pointer | |
| 4777 c = *end; // Grab character to test | |
| 4778 } | |
| 4779 if (start == end) { // We popped out on the first try | |
| 4780 parse_err(SYNERR, "integer expected at %c\n", c); | |
| 4781 result = 0; | |
| 4782 } | |
| 4783 else { | |
| 4784 _curchar = c; // Save the first character of next token | |
| 4785 *end = '\0'; // NULL terminate the string in place | |
| 4786 result = atoi(start); // Convert the string to an integer | |
| 4787 *end = _curchar; // Restore buffer to original condition | |
| 4788 } | |
| 4789 | |
| 4790 // Reset _ptr to next char after token | |
| 4791 _ptr = end; | |
| 4792 | |
| 4793 return result; // integer | |
| 4794 } | |
| 4795 | |
| 4796 | |
| 4797 //------------------------------get_relation_dup------------------------------ | |
| 4798 // Looks for a relational operator in the buffer | |
| 4799 // invokes a parse_err if the next token is not a relation | |
| 4800 // This routine creates a duplicate of the string in the buffer. | |
| 4801 char *ADLParser::get_relation_dup(void) { | |
| 4802 char *result = NULL; // relational operator being returned | |
| 4803 | |
| 4804 if( _curline == NULL ) // Return NULL at EOF. | |
| 4805 return NULL; | |
| 4806 | |
| 4807 skipws(); // Skip whitespace before relation | |
| 4808 char *start = _ptr; // Store start of relational operator | |
| 4809 char first = *_ptr; // the first character | |
| 4810 if( (first == '=') || (first == '!') || (first == '<') || (first == '>') ) { | |
| 4811 next_char(); | |
| 4812 char second = *_ptr; // the second character | |
| 4813 if( (second == '=') ) { | |
| 4814 next_char(); | |
| 4815 char tmp = *_ptr; | |
| 4816 *_ptr = '\0'; // NULL terminate | |
| 4817 result = strdup(start); // Duplicate the string | |
| 4818 *_ptr = tmp; // restore buffer | |
| 4819 } else { | |
| 4820 parse_err(SYNERR, "relational operator expected at %s\n", _ptr); | |
| 4821 } | |
| 4822 } else { | |
| 4823 parse_err(SYNERR, "relational operator expected at %s\n", _ptr); | |
| 4824 } | |
| 4825 | |
| 4826 return result; | |
| 4827 } | |
| 4828 | |
| 4829 | |
| 4830 | |
| 4831 //------------------------------get_oplist------------------------------------- | |
| 4832 // Looks for identifier pairs where first must be the name of an operand, and | |
| 4833 // second must be a name unique in the scope of this instruction. Stores the | |
| 4834 // names with a pointer to the OpClassForm of their type in a local name table. | |
| 4835 void ADLParser::get_oplist(NameList ¶meters, FormDict &operands) { | |
| 4836 OpClassForm *opclass = NULL; | |
| 4837 char *ident = NULL; | |
| 4838 | |
| 4839 do { | |
| 4840 next_char(); // skip open paren & comma characters | |
| 4841 skipws(); | |
| 4842 if (_curchar == ')') break; | |
| 4843 | |
| 4844 // Get operand type, and check it against global name table | |
| 4845 ident = get_ident(); | |
| 4846 if (ident == NULL) { | |
| 4847 parse_err(SYNERR, "optype identifier expected at %c\n", _curchar); | |
| 4848 return; | |
| 4849 } | |
| 4850 else { | |
| 4851 const Form *form = _globalNames[ident]; | |
| 4852 if( form == NULL ) { | |
| 4853 parse_err(SYNERR, "undefined operand type %s\n", ident); | |
| 4854 return; | |
| 4855 } | |
| 4856 | |
| 4857 // Check for valid operand type | |
| 4858 OpClassForm *opc = form->is_opclass(); | |
| 4859 OperandForm *oper = form->is_operand(); | |
| 4860 if((oper == NULL) && (opc == NULL)) { | |
| 4861 parse_err(SYNERR, "identifier %s not operand type\n", ident); | |
| 4862 return; | |
| 4863 } | |
| 4864 opclass = opc; | |
| 4865 } | |
| 4866 // Debugging Stuff | |
| 4867 if (_AD._adl_debug > 1) fprintf(stderr, "\tOperand Type: %s\t", ident); | |
| 4868 | |
| 4869 // Get name of operand and add it to local name table | |
| 4870 if( (ident = get_unique_ident(operands, "operand")) == NULL) { | |
| 4871 return; | |
| 4872 } | |
| 4873 // Parameter names must not be global names. | |
| 4874 if( _globalNames[ident] != NULL ) { | |
| 4875 parse_err(SYNERR, "Reuse of global name %s as operand.\n",ident); | |
| 4876 return; | |
| 4877 } | |
| 4878 operands.Insert(ident, opclass); | |
| 4879 parameters.addName(ident); | |
| 4880 | |
| 4881 // Debugging Stuff | |
| 4882 if (_AD._adl_debug > 1) fprintf(stderr, "\tOperand Name: %s\n", ident); | |
| 4883 skipws(); | |
| 4884 } while(_curchar == ','); | |
| 4885 | |
| 4886 if (_curchar != ')') parse_err(SYNERR, "missing ')'\n"); | |
| 4887 else { | |
| 4888 next_char(); // set current character position past the close paren | |
| 4889 } | |
| 4890 } | |
| 4891 | |
| 4892 | |
| 4893 //------------------------------get_effectlist--------------------------------- | |
| 4894 // Looks for identifier pairs where first must be the name of a pre-defined, | |
| 4895 // effect, and the second must be the name of an operand defined in the | |
| 4896 // operand list of this instruction. Stores the names with a pointer to the | |
| 4897 // effect form in a local effects table. | |
|
4120
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4898 void ADLParser::get_effectlist(FormDict &effects, FormDict &operands, bool& has_call) { |
| 0 | 4899 OperandForm *opForm; |
| 4900 Effect *eForm; | |
| 4901 char *ident; | |
| 4902 | |
| 4903 do { | |
| 4904 next_char(); // skip open paren & comma characters | |
| 4905 skipws(); | |
| 4906 if (_curchar == ')') break; | |
| 4907 | |
| 4908 // Get effect type, and check it against global name table | |
| 4909 ident = get_ident(); | |
| 4910 if (ident == NULL) { | |
| 4911 parse_err(SYNERR, "effect type identifier expected at %c\n", _curchar); | |
| 4912 return; | |
| 4913 } | |
| 4914 else { | |
| 4915 // Check for valid effect type | |
| 4916 const Form *form = _globalNames[ident]; | |
| 4917 if( form == NULL ) { | |
| 4918 parse_err(SYNERR, "undefined effect type %s\n", ident); | |
| 4919 return; | |
| 4920 } | |
| 4921 else { | |
| 4922 if( (eForm = form->is_effect()) == NULL) { | |
| 4923 parse_err(SYNERR, "identifier %s not effect type\n", ident); | |
| 4924 return; | |
| 4925 } | |
| 4926 } | |
| 4927 } | |
| 4928 // Debugging Stuff | |
| 4929 if (_AD._adl_debug > 1) fprintf(stderr, "\tEffect Type: %s\t", ident); | |
| 4930 skipws(); | |
|
4120
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4931 if (eForm->is(Component::CALL)) { |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4932 if (_AD._adl_debug > 1) fprintf(stderr, "\n"); |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4933 has_call = true; |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4934 } else { |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4935 // Get name of operand and check that it is in the local name table |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4936 if( (ident = get_unique_ident(effects, "effect")) == NULL) { |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4937 parse_err(SYNERR, "missing operand identifier in effect list\n"); |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4938 return; |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4939 } |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4940 const Form *form = operands[ident]; |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4941 opForm = form ? form->is_operand() : NULL; |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4942 if( opForm == NULL ) { |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4943 if( form && form->is_opclass() ) { |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4944 const char* cname = form->is_opclass()->_ident; |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4945 parse_err(SYNERR, "operand classes are illegal in effect lists (found %s %s)\n", cname, ident); |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4946 } else { |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4947 parse_err(SYNERR, "undefined operand %s in effect list\n", ident); |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4948 } |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4949 return; |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4950 } |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4951 // Add the pair to the effects table |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4952 effects.Insert(ident, eForm); |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4953 // Debugging Stuff |
|
f03a3c8bd5e5
7077312: Provide a CALL effect for instruct declaration in the ad file
roland
parents:
4114
diff
changeset
|
4954 if (_AD._adl_debug > 1) fprintf(stderr, "\tOperand Name: %s\n", ident); |
| 0 | 4955 } |
| 4956 skipws(); | |
| 4957 } while(_curchar == ','); | |
| 4958 | |
| 4959 if (_curchar != ')') parse_err(SYNERR, "missing ')'\n"); | |
| 4960 else { | |
| 4961 next_char(); // set current character position past the close paren | |
| 4962 } | |
| 4963 } | |
| 4964 | |
| 4965 | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4966 //-------------------------------preproc_line---------------------------------- |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4967 // A "#line" keyword has been seen, so parse the rest of the line. |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4968 void ADLParser::preproc_line(void) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4969 int line = get_int(); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4970 skipws_no_preproc(); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4971 const char* file = NULL; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4972 if (_curchar == '"') { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4973 next_char(); // Move past the initial '"' |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4974 file = _ptr; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4975 while (true) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4976 if (_curchar == '\n') { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4977 parse_err(SYNERR, "missing '\"' at end of #line directive"); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4978 return; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4979 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4980 if (_curchar == '"') { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4981 *_ptr = '\0'; // Terminate the string |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4982 next_char(); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4983 skipws_no_preproc(); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4984 break; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4985 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4986 next_char(); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4987 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4988 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4989 ensure_end_of_line(); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4990 if (file != NULL) |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4991 _AD._ADL_file._name = file; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4992 _buf.set_linenum(line); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4993 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
4994 |
| 0 | 4995 //------------------------------preproc_define--------------------------------- |
| 4996 // A "#define" keyword has been seen, so parse the rest of the line. | |
| 4997 void ADLParser::preproc_define(void) { | |
| 4998 char* flag = get_ident_no_preproc(); | |
| 4999 skipws_no_preproc(); | |
| 5000 // only #define x y is supported for now | |
| 5001 char* def = get_ident_no_preproc(); | |
| 5002 _AD.set_preproc_def(flag, def); | |
| 5003 skipws_no_preproc(); | |
| 5004 if (_curchar != '\n') { | |
| 5005 parse_err(SYNERR, "non-identifier in preprocessor definition\n"); | |
| 5006 } | |
| 5007 } | |
| 5008 | |
| 5009 //------------------------------preproc_undef---------------------------------- | |
| 5010 // An "#undef" keyword has been seen, so parse the rest of the line. | |
| 5011 void ADLParser::preproc_undef(void) { | |
| 5012 char* flag = get_ident_no_preproc(); | |
| 5013 skipws_no_preproc(); | |
| 5014 ensure_end_of_line(); | |
| 5015 _AD.set_preproc_def(flag, NULL); | |
| 5016 } | |
| 5017 | |
| 5018 | |
| 5019 | |
| 5020 //------------------------------parse_err-------------------------------------- | |
| 5021 // Issue a parser error message, and skip to the end of the current line | |
| 5022 void ADLParser::parse_err(int flag, const char *fmt, ...) { | |
| 5023 va_list args; | |
| 5024 | |
| 5025 va_start(args, fmt); | |
| 5026 if (flag == 1) | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
5027 _AD._syntax_errs += _AD.emit_msg(0, flag, linenum(), fmt, args); |
| 0 | 5028 else if (flag == 2) |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
5029 _AD._semantic_errs += _AD.emit_msg(0, flag, linenum(), fmt, args); |
| 0 | 5030 else |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
5031 _AD._warnings += _AD.emit_msg(0, flag, linenum(), fmt, args); |
| 0 | 5032 |
| 5033 int error_char = _curchar; | |
| 5034 char* error_ptr = _ptr+1; | |
| 5035 for(;*_ptr != '\n'; _ptr++) ; // Skip to the end of the current line | |
| 5036 _curchar = '\n'; | |
| 5037 va_end(args); | |
| 5038 _AD._no_output = 1; | |
| 5039 | |
| 5040 if (flag == 1) { | |
| 5041 char* error_tail = strchr(error_ptr, '\n'); | |
| 5042 char tem = *error_ptr; | |
| 5043 error_ptr[-1] = '\0'; | |
| 5044 char* error_head = error_ptr-1; | |
| 5045 while (error_head > _curline && *error_head) --error_head; | |
| 5046 if (error_tail) *error_tail = '\0'; | |
| 5047 fprintf(stderr, "Error Context: %s>>>%c<<<%s\n", | |
| 5048 error_head, error_char, error_ptr); | |
| 5049 if (error_tail) *error_tail = '\n'; | |
| 5050 error_ptr[-1] = tem; | |
| 5051 } | |
| 5052 } | |
| 5053 | |
| 5054 //---------------------------ensure_start_of_line------------------------------ | |
| 5055 // A preprocessor directive has been encountered. Be sure it has fallen at | |
| 605 | 5056 // the beginning of a line, or else report an error. |
| 0 | 5057 void ADLParser::ensure_start_of_line(void) { |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5058 if (_curchar == '\n') { next_line(); return; } |
| 0 | 5059 assert( _ptr >= _curline && _ptr < _curline+strlen(_curline), |
| 5060 "Must be able to find which line we are in" ); | |
| 5061 | |
| 5062 for (char *s = _curline; s < _ptr; s++) { | |
| 5063 if (*s > ' ') { | |
| 5064 parse_err(SYNERR, "'%c' must be at beginning of line\n", _curchar); | |
| 5065 break; | |
| 5066 } | |
| 5067 } | |
| 5068 } | |
| 5069 | |
| 5070 //---------------------------ensure_end_of_line-------------------------------- | |
| 5071 // A preprocessor directive has been parsed. Be sure there is no trailing | |
| 5072 // garbage at the end of this line. Set the scan point to the beginning of | |
| 5073 // the next line. | |
| 5074 void ADLParser::ensure_end_of_line(void) { | |
| 5075 skipws_no_preproc(); | |
| 5076 if (_curchar != '\n' && _curchar != '\0') { | |
| 5077 parse_err(SYNERR, "garbage char '%c' at end of line\n", _curchar); | |
| 5078 } else { | |
| 5079 next_char_or_line(); | |
| 5080 } | |
| 5081 } | |
| 5082 | |
| 5083 //---------------------------handle_preproc------------------------------------ | |
| 5084 // The '#' character introducing a preprocessor directive has been found. | |
| 5085 // Parse the whole directive name (e.g., #define, #endif) and take appropriate | |
| 5086 // action. If we are in an "untaken" span of text, simply keep track of | |
| 5087 // #ifdef nesting structure, so we can find out when to start taking text | |
| 5088 // again. (In this state, we "sort of support" C's #if directives, enough | |
| 5089 // to disregard their associated #else and #endif lines.) If we are in a | |
| 5090 // "taken" span of text, there are two cases: "#define" and "#undef" | |
| 5091 // directives are preserved and passed up to the caller, which eventually | |
| 5092 // passes control to the top-level parser loop, which handles #define and | |
| 5093 // #undef directly. (This prevents these directives from occurring in | |
| 5094 // arbitrary positions in the AD file--we require better structure than C.) | |
| 5095 // In the other case, and #ifdef, #ifndef, #else, or #endif is silently | |
| 5096 // processed as whitespace, with the "taken" state of the text correctly | |
| 5097 // updated. This routine returns "false" exactly in the case of a "taken" | |
| 5098 // #define or #undef, which tells the caller that a preprocessor token | |
| 5099 // has appeared which must be handled explicitly by the parse loop. | |
| 5100 bool ADLParser::handle_preproc_token() { | |
| 5101 assert(*_ptr == '#', "must be at start of preproc"); | |
| 5102 ensure_start_of_line(); | |
| 5103 next_char(); | |
| 5104 skipws_no_preproc(); | |
| 5105 char* start_ident = _ptr; | |
| 5106 char* ident = (_curchar == '\n') ? NULL : get_ident_no_preproc(); | |
| 5107 if (ident == NULL) { | |
| 5108 parse_err(SYNERR, "expected preprocessor command, got end of line\n"); | |
| 5109 } else if (!strcmp(ident, "ifdef") || | |
| 5110 !strcmp(ident, "ifndef")) { | |
| 5111 char* flag = get_ident_no_preproc(); | |
| 5112 ensure_end_of_line(); | |
| 5113 // Test the identifier only if we are already in taken code: | |
| 5114 bool flag_def = preproc_taken() && (_AD.get_preproc_def(flag) != NULL); | |
| 5115 bool now_taken = !strcmp(ident, "ifdef") ? flag_def : !flag_def; | |
| 5116 begin_if_def(now_taken); | |
| 5117 } else if (!strcmp(ident, "if")) { | |
| 5118 if (preproc_taken()) | |
| 5119 parse_err(SYNERR, "unimplemented: #%s %s", ident, _ptr+1); | |
| 5120 next_line(); | |
| 5121 // Intelligently skip this nested C preprocessor directive: | |
| 5122 begin_if_def(true); | |
| 5123 } else if (!strcmp(ident, "else")) { | |
| 5124 ensure_end_of_line(); | |
| 5125 invert_if_def(); | |
| 5126 } else if (!strcmp(ident, "endif")) { | |
| 5127 ensure_end_of_line(); | |
| 5128 end_if_def(); | |
| 5129 } else if (preproc_taken()) { | |
| 5130 // pass this token up to the main parser as "#define" or "#undef" | |
| 5131 _ptr = start_ident; | |
| 5132 _curchar = *--_ptr; | |
| 5133 if( _curchar != '#' ) { | |
| 5134 parse_err(SYNERR, "no space allowed after # in #define or #undef"); | |
| 5135 assert(_curchar == '#', "no space allowed after # in #define or #undef"); | |
| 5136 } | |
| 5137 return false; | |
| 5138 } | |
| 5139 return true; | |
| 5140 } | |
| 5141 | |
| 5142 //---------------------------skipws_common------------------------------------- | |
| 5143 // Skip whitespace, including comments and newlines, while keeping an accurate | |
| 5144 // line count. | |
| 5145 // Maybe handle certain preprocessor constructs: #ifdef, #ifndef, #else, #endif | |
| 5146 void ADLParser::skipws_common(bool do_preproc) { | |
| 5147 char *start = _ptr; | |
| 5148 char *next = _ptr + 1; | |
| 5149 | |
| 5150 if (*_ptr == '\0') { | |
| 5151 // Check for string terminator | |
| 5152 if (_curchar > ' ') return; | |
| 5153 if (_curchar == '\n') { | |
| 5154 if (!do_preproc) return; // let caller handle the newline | |
| 5155 next_line(); | |
| 5156 _ptr = _curline; next = _ptr + 1; | |
| 5157 } | |
| 5158 else if (_curchar == '#' || | |
| 5159 (_curchar == '/' && (*next == '/' || *next == '*'))) { | |
| 5160 parse_err(SYNERR, "unimplemented: comment token in a funny place"); | |
| 5161 } | |
| 5162 } | |
| 5163 while(_curline != NULL) { // Check for end of file | |
| 5164 if (*_ptr == '\n') { // keep proper track of new lines | |
| 5165 if (!do_preproc) break; // let caller handle the newline | |
| 5166 next_line(); | |
| 5167 _ptr = _curline; next = _ptr + 1; | |
| 5168 } | |
| 5169 else if ((*_ptr == '/') && (*next == '/')) // C++ comment | |
| 5170 do { _ptr++; next++; } while(*_ptr != '\n'); // So go to end of line | |
| 5171 else if ((*_ptr == '/') && (*next == '*')) { // C comment | |
| 5172 _ptr++; next++; | |
| 5173 do { | |
| 5174 _ptr++; next++; | |
| 5175 if (*_ptr == '\n') { // keep proper track of new lines | |
| 5176 next_line(); // skip newlines within comments | |
| 5177 if (_curline == NULL) { // check for end of file | |
| 5178 parse_err(SYNERR, "end-of-file detected inside comment\n"); | |
| 5179 break; | |
| 5180 } | |
| 5181 _ptr = _curline; next = _ptr + 1; | |
| 5182 } | |
| 5183 } while(!((*_ptr == '*') && (*next == '/'))); // Go to end of comment | |
| 5184 _ptr = ++next; next++; // increment _ptr past comment end | |
| 5185 } | |
| 5186 else if (do_preproc && *_ptr == '#') { | |
| 5187 // Note that this calls skipws_common(false) recursively! | |
| 5188 bool preproc_handled = handle_preproc_token(); | |
| 5189 if (!preproc_handled) { | |
| 5190 if (preproc_taken()) { | |
| 5191 return; // short circuit | |
| 5192 } | |
| 5193 ++_ptr; // skip the preprocessor character | |
| 5194 } | |
| 5195 next = _ptr+1; | |
| 5196 } else if(*_ptr > ' ' && !(do_preproc && !preproc_taken())) { | |
| 5197 break; | |
| 5198 } | |
| 5199 else if (*_ptr == '"' || *_ptr == '\'') { | |
| 5200 assert(do_preproc, "only skip strings if doing preproc"); | |
| 5201 // skip untaken quoted string | |
| 5202 int qchar = *_ptr; | |
| 5203 while (true) { | |
| 5204 ++_ptr; | |
| 5205 if (*_ptr == qchar) { ++_ptr; break; } | |
| 5206 if (*_ptr == '\\') ++_ptr; | |
| 5207 if (*_ptr == '\n' || *_ptr == '\0') { | |
| 5208 parse_err(SYNERR, "newline in string"); | |
| 5209 break; | |
| 5210 } | |
| 5211 } | |
| 5212 next = _ptr + 1; | |
| 5213 } | |
| 5214 else { ++_ptr; ++next; } | |
| 5215 } | |
| 5216 if( _curline != NULL ) // at end of file _curchar isn't valid | |
| 5217 _curchar = *_ptr; // reset _curchar to maintain invariant | |
| 5218 } | |
| 5219 | |
| 5220 //---------------------------cur_char----------------------------------------- | |
| 5221 char ADLParser::cur_char() { | |
| 5222 return (_curchar); | |
| 5223 } | |
| 5224 | |
| 5225 //---------------------------next_char----------------------------------------- | |
| 5226 void ADLParser::next_char() { | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5227 if (_curchar == '\n') parse_err(WARN, "must call next_line!"); |
| 0 | 5228 _curchar = *++_ptr; |
| 5229 // if ( _curchar == '\n' ) { | |
| 5230 // next_line(); | |
| 5231 // } | |
| 5232 } | |
| 5233 | |
| 5234 //---------------------------next_char_or_line--------------------------------- | |
| 5235 void ADLParser::next_char_or_line() { | |
| 5236 if ( _curchar != '\n' ) { | |
| 5237 _curchar = *++_ptr; | |
| 5238 } else { | |
| 5239 next_line(); | |
| 5240 _ptr = _curline; | |
| 5241 _curchar = *_ptr; // maintain invariant | |
| 5242 } | |
| 5243 } | |
| 5244 | |
| 5245 //---------------------------next_line----------------------------------------- | |
| 5246 void ADLParser::next_line() { | |
|
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
5247 _curline = _buf.get_line(); |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5248 _curchar = ' '; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5249 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5250 |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5251 //------------------------get_line_string-------------------------------------- |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5252 // Prepended location descriptor, for debugging. |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5253 // Must return a malloced string (that can be freed if desired). |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5254 char* ADLParser::get_line_string(int linenum) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5255 const char* file = _AD._ADL_file._name; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5256 int line = linenum ? linenum : this->linenum(); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5257 char* location = (char *)malloc(strlen(file) + 100); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5258 sprintf(location, "\n#line %d \"%s\"\n", line, file); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5259 return location; |
| 0 | 5260 } |
| 5261 | |
| 5262 //-------------------------is_literal_constant--------------------------------- | |
| 5263 bool ADLParser::is_literal_constant(const char *param) { | |
| 5264 if (param[0] == 0) return false; // null string | |
| 5265 if (param[0] == '(') return true; // parenthesized expression | |
| 5266 if (param[0] == '0' && (param[1] == 'x' || param[1] == 'X')) { | |
| 5267 // Make sure it's a hex constant. | |
| 5268 int i = 2; | |
| 5269 do { | |
| 5270 if( !ADLParser::is_hex_digit(*(param+i)) ) return false; | |
| 5271 ++i; | |
| 5272 } while( *(param+i) != 0 ); | |
| 5273 return true; | |
| 5274 } | |
| 5275 return false; | |
| 5276 } | |
| 5277 | |
| 5278 //---------------------------is_hex_digit-------------------------------------- | |
| 5279 bool ADLParser::is_hex_digit(char digit) { | |
| 5280 return ((digit >= '0') && (digit <= '9')) | |
| 5281 ||((digit >= 'a') && (digit <= 'f')) | |
| 5282 ||((digit >= 'A') && (digit <= 'F')); | |
| 5283 } | |
| 5284 | |
| 5285 //---------------------------is_int_token-------------------------------------- | |
| 5286 bool ADLParser::is_int_token(const char* token, int& intval) { | |
| 5287 const char* cp = token; | |
| 5288 while (*cp != '\0' && *cp <= ' ') cp++; | |
| 5289 if (*cp == '-') cp++; | |
| 5290 int ndigit = 0; | |
| 5291 while (*cp >= '0' && *cp <= '9') { cp++; ndigit++; } | |
| 5292 while (*cp != '\0' && *cp <= ' ') cp++; | |
| 5293 if (ndigit == 0 || *cp != '\0') { | |
| 5294 return false; | |
| 5295 } | |
| 5296 intval = atoi(token); | |
| 5297 return true; | |
| 5298 } | |
| 5299 | |
|
475
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5300 static const char* skip_expr_ws(const char* str) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5301 const char * cp = str; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5302 while (cp[0]) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5303 if (cp[0] <= ' ') { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5304 ++cp; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5305 } else if (cp[0] == '#') { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5306 ++cp; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5307 while (cp[0] == ' ') ++cp; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5308 assert(0 == strncmp(cp, "line", 4), "must be a #line directive"); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5309 const char* eol = strchr(cp, '\n'); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5310 assert(eol != NULL, "must find end of line"); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5311 if (eol == NULL) eol = cp + strlen(cp); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5312 cp = eol; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5313 } else { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5314 break; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5315 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5316 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5317 return cp; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5318 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5319 |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5320 //-----------------------equivalent_expressions-------------------------------- |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5321 bool ADLParser::equivalent_expressions(const char* str1, const char* str2) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5322 if (str1 == str2) |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5323 return true; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5324 else if (str1 == NULL || str2 == NULL) |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5325 return false; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5326 const char* cp1 = str1; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5327 const char* cp2 = str2; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5328 char in_quote = '\0'; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5329 while (cp1[0] && cp2[0]) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5330 if (!in_quote) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5331 // skip spaces and/or cpp directives |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5332 const char* cp1a = skip_expr_ws(cp1); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5333 const char* cp2a = skip_expr_ws(cp2); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5334 if (cp1a > cp1 && cp2a > cp2) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5335 cp1 = cp1a; cp2 = cp2a; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5336 continue; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5337 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5338 if (cp1a > cp1 || cp2a > cp2) break; // fail |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5339 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5340 // match one non-space char |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5341 if (cp1[0] != cp2[0]) break; // fail |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5342 char ch = cp1[0]; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5343 cp1++; cp2++; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5344 // watch for quotes |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5345 if (in_quote && ch == '\\') { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5346 if (cp1[0] != cp2[0]) break; // fail |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5347 if (!cp1[0]) break; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5348 cp1++; cp2++; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5349 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5350 if (in_quote && ch == in_quote) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5351 in_quote = '\0'; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5352 } else if (!in_quote && (ch == '"' || ch == '\'')) { |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5353 in_quote = ch; |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5354 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5355 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5356 return (!cp1[0] && !cp2[0]); |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5357 } |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5358 |
|
284d0af00d53
6771309: debugging AD files is difficult without #line directives in generated code
jrose
parents:
415
diff
changeset
|
5359 |
| 0 | 5360 //-------------------------------trim------------------------------------------ |
| 5361 void ADLParser::trim(char* &token) { | |
| 5362 while (*token <= ' ') token++; | |
| 5363 char* end = token + strlen(token); | |
| 5364 while (end > token && *(end-1) <= ' ') --end; | |
| 5365 *end = '\0'; | |
| 5366 } |