Mercurial > hg > graal-compiler
view src/share/vm/adlc/adlparse.cpp @ 2149:7e37af9d69ef
7011379: G1: overly long concurrent marking cycles
Summary: This changeset introduces filtering of SATB buffers at the point when they are about to be enqueued. If this filtering clears enough entries on each buffer, the buffer can then be re-used and not enqueued. This cuts down the number of SATB buffers that need to be processed by the concurrent marking threads.
Reviewed-by: johnc, ysr
author | tonyp |
---|---|
date | Wed, 19 Jan 2011 09:35:17 -0500 |
parents | 2f644f85485d |
children | fe240d87c6ec |
line wrap: on
line source
/* * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ // ADLPARSE.CPP - Architecture Description Language Parser // Authors: Chris Vick and Mike Paleczny #include "adlc.hpp" //----------------------------ADLParser---------------------------------------- // Create a new ADL parser ADLParser::ADLParser(FileBuff& buffer, ArchDesc& archDesc) : _buf(buffer), _AD(archDesc), _globalNames(archDesc.globalNames()) { _AD._syntax_errs = _AD._semantic_errs = 0; // No errors so far this file _AD._warnings = 0; // No warnings either _curline = _ptr = NULL; // No pointers into buffer yet _preproc_depth = 0; _preproc_not_taken = 0; // Delimit command-line definitions from in-file definitions: _AD._preproc_list.add_signal(); } //------------------------------~ADLParser------------------------------------- // Delete an ADL parser. ADLParser::~ADLParser() { if (!_AD._quiet_mode) fprintf(stderr,"---------------------------- Errors and Warnings ----------------------------\n"); #ifndef ASSERT fprintf(stderr, "**************************************************************\n"); fprintf(stderr, "***** WARNING: ASSERT is undefined, assertions disabled. *****\n"); fprintf(stderr, "**************************************************************\n"); #endif if( _AD._syntax_errs + _AD._semantic_errs + _AD._warnings == 0 ) { if (!_AD._quiet_mode) fprintf(stderr,"No errors or warnings to report from phase-1 parse.\n" ); } else { if( _AD._syntax_errs ) { // Any syntax errors? fprintf(stderr,"%s: Found %d syntax error", _buf._fp->_name, _AD._syntax_errs); if( _AD._syntax_errs > 1 ) fprintf(stderr,"s.\n\n"); else fprintf(stderr,".\n\n"); } if( _AD._semantic_errs ) { // Any semantic errors? fprintf(stderr,"%s: Found %d semantic error", _buf._fp->_name, _AD._semantic_errs); if( _AD._semantic_errs > 1 ) fprintf(stderr,"s.\n\n"); else fprintf(stderr,".\n\n"); } if( _AD._warnings ) { // Any warnings? fprintf(stderr,"%s: Found %d warning", _buf._fp->_name, _AD._warnings); if( _AD._warnings > 1 ) fprintf(stderr,"s.\n\n"); else fprintf(stderr,".\n\n"); } } if (!_AD._quiet_mode) fprintf(stderr,"-----------------------------------------------------------------------------\n"); _AD._TotalLines += linenum()-1; // -1 for overshoot in "nextline" routine // Write out information we have stored // // UNIXism == fsync(stderr); } //------------------------------parse------------------------------------------ // Each top-level keyword should appear as the first non-whitespace on a line. // void ADLParser::parse() { char *ident; // Iterate over the lines in the file buffer parsing Level 1 objects for( next_line(); _curline != NULL; next_line()) { _ptr = _curline; // Reset ptr to start of new line skipws(); // Skip any leading whitespace ident = get_ident(); // Get first token if (ident == NULL) { // Empty line continue; // Get the next line } if (!strcmp(ident, "instruct")) instr_parse(); else if (!strcmp(ident, "operand")) oper_parse(); else if (!strcmp(ident, "opclass")) opclass_parse(); else if (!strcmp(ident, "ins_attrib")) ins_attr_parse(); else if (!strcmp(ident, "op_attrib")) op_attr_parse(); else if (!strcmp(ident, "source")) source_parse(); else if (!strcmp(ident, "source_hpp")) source_hpp_parse(); else if (!strcmp(ident, "register")) reg_parse(); else if (!strcmp(ident, "frame")) frame_parse(); else if (!strcmp(ident, "encode")) encode_parse(); else if (!strcmp(ident, "pipeline")) pipe_parse(); else if (!strcmp(ident, "definitions")) definitions_parse(); else if (!strcmp(ident, "peephole")) peep_parse(); else if (!strcmp(ident, "#line")) preproc_line(); else if (!strcmp(ident, "#define")) preproc_define(); else if (!strcmp(ident, "#undef")) preproc_undef(); else { parse_err(SYNERR, "expected one of - instruct, operand, ins_attrib, op_attrib, source, register, pipeline, encode\n Found %s",ident); } } // Done with parsing, check consistency. if (_preproc_depth != 0) { parse_err(SYNERR, "End of file inside #ifdef"); } // AttributeForms ins_cost and op_cost must be defined for default behaviour if (_globalNames[AttributeForm::_ins_cost] == NULL) { parse_err(SEMERR, "Did not declare 'ins_cost' attribute"); } if (_globalNames[AttributeForm::_ins_pc_relative] == NULL) { parse_err(SEMERR, "Did not declare 'ins_pc_relative' attribute"); } if (_globalNames[AttributeForm::_op_cost] == NULL) { parse_err(SEMERR, "Did not declare 'op_cost' attribute"); } } // ******************** Private Level 1 Parse Functions ******************** //------------------------------instr_parse------------------------------------ // Parse the contents of an instruction definition, build the InstructForm to // represent that instruction, and add it to the InstructForm list. void ADLParser::instr_parse(void) { char *ident; InstructForm *instr; MatchRule *rule; int match_rules_cnt = 0; // First get the name of the instruction if( (ident = get_unique_ident(_globalNames,"instruction")) == NULL ) return; instr = new InstructForm(ident); // Create new instruction form instr->_linenum = linenum(); _globalNames.Insert(ident, instr); // Add name to the name table // Debugging Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Parsing Instruction Form %s\n", ident); // Then get the operands skipws(); if (_curchar != '(') { parse_err(SYNERR, "missing '(' in instruct definition\n"); } // Parse the operand list else get_oplist(instr->_parameters, instr->_localNames); skipws(); // Skip leading whitespace // Check for block delimiter if ( (_curchar != '%') || ( next_char(), (_curchar != '{')) ) { parse_err(SYNERR, "missing '%{' in instruction definition\n"); return; } next_char(); // Maintain the invariant do { ident = get_ident(); // Grab next identifier if (ident == NULL) { parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar); continue; } if (!strcmp(ident, "predicate")) instr->_predicate = pred_parse(); else if (!strcmp(ident, "match")) { // Allow one instruction have several match rules. rule = instr->_matrule; if (rule == NULL) { // This is first match rule encountered rule = match_parse(instr->_localNames); if (rule) { instr->_matrule = rule; // Special case the treatment of Control instructions. if( instr->is_ideal_control() ) { // Control instructions return a special result, 'Universe' rule->_result = "Universe"; } // Check for commutative operations with tree operands. matchrule_clone_and_swap(rule, instr->_ident, match_rules_cnt); } } else { // Find the end of the match rule list while (rule->_next != NULL) rule = rule->_next; // Add the new match rule to the list rule->_next = match_parse(instr->_localNames); if (rule->_next) { rule = rule->_next; if( instr->is_ideal_control() ) { parse_err(SYNERR, "unique match rule expected for %s\n", rule->_name); return; } assert(match_rules_cnt < 100," too many match rule clones"); char* buf = (char*) malloc(strlen(instr->_ident) + 4); sprintf(buf, "%s_%d", instr->_ident, match_rules_cnt++); rule->_result = buf; // Check for commutative operations with tree operands. matchrule_clone_and_swap(rule, instr->_ident, match_rules_cnt); } } } else if (!strcmp(ident, "encode")) { parse_err(SYNERR, "Instructions specify ins_encode, not encode\n"); } else if (!strcmp(ident, "ins_encode")) ins_encode_parse(*instr); else if (!strcmp(ident, "opcode")) instr->_opcode = opcode_parse(instr); else if (!strcmp(ident, "size")) instr->_size = size_parse(instr); else if (!strcmp(ident, "effect")) effect_parse(instr); else if (!strcmp(ident, "expand")) instr->_exprule = expand_parse(instr); else if (!strcmp(ident, "rewrite")) instr->_rewrule = rewrite_parse(); else if (!strcmp(ident, "constraint")) { parse_err(SYNERR, "Instructions do not specify a constraint\n"); } else if (!strcmp(ident, "construct")) { parse_err(SYNERR, "Instructions do not specify a construct\n"); } else if (!strcmp(ident, "format")) instr->_format = format_parse(); else if (!strcmp(ident, "interface")) { parse_err(SYNERR, "Instructions do not specify an interface\n"); } else if (!strcmp(ident, "ins_pipe")) ins_pipe_parse(*instr); else { // Done with staticly defined parts of instruction definition // Check identifier to see if it is the name of an attribute const Form *form = _globalNames[ident]; AttributeForm *attr = form ? form->is_attribute() : NULL; if( attr && (attr->_atype == INS_ATTR) ) { // Insert the new attribute into the linked list. Attribute *temp = attr_parse(ident); temp->_next = instr->_attribs; instr->_attribs = temp; } else { parse_err(SYNERR, "expected one of:\n predicate, match, encode, or the name of an instruction attribute at %s\n", ident); } } skipws(); } while(_curchar != '%'); next_char(); if (_curchar != '}') { parse_err(SYNERR, "missing '%}' in instruction definition\n"); return; } // Check for "Set" form of chain rule adjust_set_rule(instr); if (_AD._pipeline ) { if( instr->expands() ) { if( instr->_ins_pipe ) parse_err(WARN, "ins_pipe and expand rule both specified for instruction \"%s\"; ins_pipe will be unused\n", instr->_ident); } else { if( !instr->_ins_pipe ) parse_err(WARN, "No ins_pipe specified for instruction \"%s\"\n", instr->_ident); } } // Add instruction to tail of instruction list _AD.addForm(instr); // Create instruction form for each additional match rule rule = instr->_matrule; if (rule != NULL) { rule = rule->_next; while (rule != NULL) { ident = (char*)rule->_result; InstructForm *clone = new InstructForm(ident, instr, rule); // Create new instruction form _globalNames.Insert(ident, clone); // Add name to the name table // Debugging Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Parsing Instruction Form %s\n", ident); // Check for "Set" form of chain rule adjust_set_rule(clone); // Add instruction to tail of instruction list _AD.addForm(clone); rule = rule->_next; clone->_matrule->_next = NULL; // One match rule per clone } } } //------------------------------matchrule_clone_and_swap----------------------- // Check for commutative operations with subtree operands, // create clones and swap operands. void ADLParser::matchrule_clone_and_swap(MatchRule* rule, const char* instr_ident, int& match_rules_cnt) { // Check for commutative operations with tree operands. int count = 0; rule->count_commutative_op(count); if (count > 0) { // Clone match rule and swap commutative operation's operands. rule->matchrule_swap_commutative_op(instr_ident, count, match_rules_cnt); } } //------------------------------adjust_set_rule-------------------------------- // Check for "Set" form of chain rule void ADLParser::adjust_set_rule(InstructForm *instr) { if (instr->_matrule == NULL || instr->_matrule->_rChild == NULL) return; const char *rch = instr->_matrule->_rChild->_opType; const Form *frm = _globalNames[rch]; if( (! strcmp(instr->_matrule->_opType,"Set")) && frm && frm->is_operand() && (! frm->ideal_only()) ) { // Previous implementation, which missed leaP*, but worked for loadCon* unsigned position = 0; const char *result = NULL; const char *name = NULL; const char *optype = NULL; MatchNode *right = instr->_matrule->_rChild; if (right->base_operand(position, _globalNames, result, name, optype)) { position = 1; const char *result2 = NULL; const char *name2 = NULL; const char *optype2 = NULL; // Can not have additional base operands in right side of match! if ( ! right->base_operand( position, _globalNames, result2, name2, optype2) ) { if (instr->_predicate != NULL) parse_err(SYNERR, "ADLC does not support instruction chain rules with predicates"); // Chain from input _ideal_operand_type_, // Needed for shared roots of match-trees ChainList *lst = (ChainList *)_AD._chainRules[optype]; if (lst == NULL) { lst = new ChainList(); _AD._chainRules.Insert(optype, lst); } if (!lst->search(instr->_matrule->_lChild->_opType)) { const char *cost = instr->cost(); if (cost == NULL) { cost = ((AttributeForm*)_globalNames[AttributeForm::_ins_cost])->_attrdef; } // The ADLC does not support chaining from the ideal operand type // of a predicated user-defined operand if( frm->is_operand() == NULL || frm->is_operand()->_predicate == NULL ) { lst->insert(instr->_matrule->_lChild->_opType,cost,instr->_ident); } } // Chain from input _user_defined_operand_type_, lst = (ChainList *)_AD._chainRules[result]; if (lst == NULL) { lst = new ChainList(); _AD._chainRules.Insert(result, lst); } if (!lst->search(instr->_matrule->_lChild->_opType)) { const char *cost = instr->cost(); if (cost == NULL) { cost = ((AttributeForm*)_globalNames[AttributeForm::_ins_cost])->_attrdef; } // It is safe to chain from the top-level user-defined operand even // if it has a predicate, since the predicate is checked before // the user-defined type is available. lst->insert(instr->_matrule->_lChild->_opType,cost,instr->_ident); } } else { // May have instruction chain rule if root of right-tree is an ideal OperandForm *rightOp = _globalNames[right->_opType]->is_operand(); if( rightOp ) { const Form *rightRoot = _globalNames[rightOp->_matrule->_opType]; if( rightRoot && rightRoot->ideal_only() ) { const char *chain_op = NULL; if( rightRoot->is_instruction() ) chain_op = rightOp->_ident; if( chain_op ) { // Look-up the operation in chain rule table ChainList *lst = (ChainList *)_AD._chainRules[chain_op]; if (lst == NULL) { lst = new ChainList(); _AD._chainRules.Insert(chain_op, lst); } // if (!lst->search(instr->_matrule->_lChild->_opType)) { const char *cost = instr->cost(); if (cost == NULL) { cost = ((AttributeForm*)_globalNames[AttributeForm::_ins_cost])->_attrdef; } // This chains from a top-level operand whose predicate, if any, // has been checked. lst->insert(instr->_matrule->_lChild->_opType,cost,instr->_ident); // } } } } } // end chain rule from right-tree's ideal root } } } //------------------------------oper_parse------------------------------------- void ADLParser::oper_parse(void) { char *ident; OperandForm *oper; AttributeForm *attr; MatchRule *rule; // First get the name of the operand skipws(); if( (ident = get_unique_ident(_globalNames,"operand")) == NULL ) return; oper = new OperandForm(ident); // Create new operand form oper->_linenum = linenum(); _globalNames.Insert(ident, oper); // Add name to the name table // Debugging Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Parsing Operand Form %s\n", ident); // Get the component operands skipws(); if (_curchar != '(') { parse_err(SYNERR, "missing '(' in operand definition\n"); return; } else get_oplist(oper->_parameters, oper->_localNames); // Parse the component operand list skipws(); // Check for block delimiter if ((_curchar != '%') || (*(_ptr+1) != '{')) { // If not open block parse_err(SYNERR, "missing '%c{' in operand definition\n","%"); return; } next_char(); next_char(); // Skip over "%{" symbol do { ident = get_ident(); // Grab next identifier if (ident == NULL) { parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar); continue; } if (!strcmp(ident, "predicate")) oper->_predicate = pred_parse(); else if (!strcmp(ident, "match")) { // Find the end of the match rule list rule = oper->_matrule; if (rule) { while (rule->_next) rule = rule->_next; // Add the new match rule to the list rule->_next = match_parse(oper->_localNames); if (rule->_next) { rule->_next->_result = oper->_ident; } } else { // This is first match rule encountered oper->_matrule = match_parse(oper->_localNames); if (oper->_matrule) { oper->_matrule->_result = oper->_ident; } } } else if (!strcmp(ident, "encode")) oper->_interface = interface_parse(); else if (!strcmp(ident, "ins_encode")) { parse_err(SYNERR, "Operands specify 'encode', not 'ins_encode'\n"); } else if (!strcmp(ident, "opcode")) { parse_err(SYNERR, "Operands do not specify an opcode\n"); } else if (!strcmp(ident, "effect")) { parse_err(SYNERR, "Operands do not specify an effect\n"); } else if (!strcmp(ident, "expand")) { parse_err(SYNERR, "Operands do not specify an expand\n"); } else if (!strcmp(ident, "rewrite")) { parse_err(SYNERR, "Operands do not specify a rewrite\n"); } else if (!strcmp(ident, "constraint"))oper->_constraint= constraint_parse(); else if (!strcmp(ident, "construct")) oper->_construct = construct_parse(); else if (!strcmp(ident, "format")) oper->_format = format_parse(); else if (!strcmp(ident, "interface")) oper->_interface = interface_parse(); // Check identifier to see if it is the name of an attribute else if (((attr = _globalNames[ident]->is_attribute()) != NULL) && (attr->_atype == OP_ATTR)) oper->_attribs = attr_parse(ident); else { parse_err(SYNERR, "expected one of - constraint, predicate, match, encode, format, construct, or the name of a defined operand attribute at %s\n", ident); } skipws(); } while(_curchar != '%'); next_char(); if (_curchar != '}') { parse_err(SYNERR, "missing '%}' in operand definition\n"); return; } // Add operand to tail of operand list _AD.addForm(oper); } //------------------------------opclass_parse---------------------------------- // Operand Classes are a block with a comma delimited list of operand names void ADLParser::opclass_parse(void) { char *ident; OpClassForm *opc; OperandForm *opForm; // First get the name of the operand class skipws(); if( (ident = get_unique_ident(_globalNames,"opclass")) == NULL ) return; opc = new OpClassForm(ident); // Create new operand class form _globalNames.Insert(ident, opc); // Add name to the name table // Debugging Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Parsing Operand Class Form %s\n", ident); // Get the list of operands skipws(); if (_curchar != '(') { parse_err(SYNERR, "missing '(' in operand definition\n"); return; } do { next_char(); // Skip past open paren or comma ident = get_ident(); // Grab next identifier if (ident == NULL) { parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar); continue; } // Check identifier to see if it is the name of an operand const Form *form = _globalNames[ident]; opForm = form ? form->is_operand() : NULL; if ( opForm ) { opc->_oplst.addName(ident); // Add operand to opclass list opForm->_classes.addName(opc->_ident);// Add opclass to operand list } else { parse_err(SYNERR, "expected name of a defined operand at %s\n", ident); } skipws(); // skip trailing whitespace } while (_curchar == ','); // Check for the comma // Check for closing ')' if (_curchar != ')') { parse_err(SYNERR, "missing ')' or ',' in opclass definition\n"); return; } next_char(); // Consume the ')' skipws(); // Check for closing ';' if (_curchar != ';') { parse_err(SYNERR, "missing ';' in opclass definition\n"); return; } next_char(); // Consume the ';' // Add operand to tail of operand list _AD.addForm(opc); } //------------------------------ins_attr_parse--------------------------------- void ADLParser::ins_attr_parse(void) { char *ident; char *aexpr; AttributeForm *attrib; // get name for the instruction attribute skipws(); // Skip leading whitespace if( (ident = get_unique_ident(_globalNames,"inst_attrib")) == NULL ) return; // Debugging Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Parsing Ins_Attribute Form %s\n", ident); // Get default value of the instruction attribute skipws(); // Skip whitespace if ((aexpr = get_paren_expr("attribute default expression string")) == NULL) { parse_err(SYNERR, "missing '(' in ins_attrib definition\n"); return; } // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Attribute Expression: %s\n", aexpr); // Check for terminator if (_curchar != ';') { parse_err(SYNERR, "missing ';' in ins_attrib definition\n"); return; } next_char(); // Advance past the ';' // Construct the attribute, record global name, and store in ArchDesc attrib = new AttributeForm(ident, INS_ATTR, aexpr); _globalNames.Insert(ident, attrib); // Add name to the name table _AD.addForm(attrib); } //------------------------------op_attr_parse---------------------------------- void ADLParser::op_attr_parse(void) { char *ident; char *aexpr; AttributeForm *attrib; // get name for the operand attribute skipws(); // Skip leading whitespace if( (ident = get_unique_ident(_globalNames,"op_attrib")) == NULL ) return; // Debugging Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Parsing Op_Attribute Form %s\n", ident); // Get default value of the instruction attribute skipws(); // Skip whitespace if ((aexpr = get_paren_expr("attribute default expression string")) == NULL) { parse_err(SYNERR, "missing '(' in op_attrib definition\n"); return; } // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Attribute Expression: %s\n", aexpr); // Check for terminator if (_curchar != ';') { parse_err(SYNERR, "missing ';' in op_attrib definition\n"); return; } next_char(); // Advance past the ';' // Construct the attribute, record global name, and store in ArchDesc attrib = new AttributeForm(ident, OP_ATTR, aexpr); _globalNames.Insert(ident, attrib); _AD.addForm(attrib); } //------------------------------definitions_parse----------------------------------- void ADLParser::definitions_parse(void) { skipws(); // Skip leading whitespace if (_curchar == '%' && *(_ptr+1) == '{') { next_char(); next_char(); // Skip "%{" skipws(); while (_curchar != '%' && *(_ptr+1) != '}') { // Process each definition until finding closing string "%}" char *token = get_ident(); if (token == NULL) { parse_err(SYNERR, "missing identifier inside definitions block.\n"); return; } if (strcmp(token,"int_def")==0) { int_def_parse(); } // if (strcmp(token,"str_def")==0) { str_def_parse(); } skipws(); } } else { parse_err(SYNERR, "Missing %%{ ... %%} block after definitions keyword.\n"); return; } } //------------------------------int_def_parse---------------------------------- // Parse Example: // int_def MEMORY_REF_COST ( 200, DEFAULT_COST * 2); // <keyword> <name> ( <int_value>, <description> ); // void ADLParser::int_def_parse(void) { char *name = NULL; // Name of definition char *value = NULL; // its value, int int_value = -1; // positive values only char *description = NULL; // textual description // Get definition name skipws(); // Skip whitespace name = get_ident(); if (name == NULL) { parse_err(SYNERR, "missing definition name after int_def\n"); return; } // Check for value of int_def dname( integer_value [, string_expression ] ) skipws(); if (_curchar == '(') { // Parse the integer value. next_char(); value = get_ident(); if (value == NULL) { parse_err(SYNERR, "missing value in int_def\n"); return; } if( !is_int_token(value, int_value) ) { parse_err(SYNERR, "value in int_def is not recognized as integer\n"); return; } skipws(); // Check for description if (_curchar == ',') { next_char(); // skip ',' description = get_expr("int_def description", ")"); if (description == NULL) { parse_err(SYNERR, "invalid or missing description in int_def\n"); return; } trim(description); } if (_curchar != ')') { parse_err(SYNERR, "missing ')' in register definition statement\n"); return; } next_char(); } // Check for closing ';' skipws(); if (_curchar != ';') { parse_err(SYNERR, "missing ';' after int_def\n"); return; } next_char(); // move past ';' // Debug Stuff if (_AD._adl_debug > 1) { fprintf(stderr,"int_def: %s ( %s, %s )\n", name, (value), (description ? description : "")); } // Record new definition. Expr *expr = new Expr(name, description, int_value, int_value); const Expr *old_expr = _AD.globalDefs().define(name, expr); if (old_expr != NULL) { parse_err(SYNERR, "Duplicate definition\n"); return; } return; } //------------------------------source_parse----------------------------------- void ADLParser::source_parse(void) { SourceForm *source; // Encode class for instruction/operand char *rule = NULL; // String representation of encode rule skipws(); // Skip leading whitespace if ( (rule = find_cpp_block("source block")) == NULL ) { parse_err(SYNERR, "incorrect or missing block for 'source'.\n"); return; } // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Source Form: %s\n", rule); source = new SourceForm(rule); // Build new Source object _AD.addForm(source); // skipws(); } //------------------------------source_hpp_parse------------------------------- // Parse a source_hpp %{ ... %} block. // The code gets stuck into the ad_<arch>.hpp file. // If the source_hpp block appears before the register block in the AD // file, it goes up at the very top of the ad_<arch>.hpp file, so that // it can be used by register encodings, etc. Otherwise, it goes towards // the bottom, where it's useful as a global definition to *.cpp files. void ADLParser::source_hpp_parse(void) { char *rule = NULL; // String representation of encode rule skipws(); // Skip leading whitespace if ( (rule = find_cpp_block("source_hpp block")) == NULL ) { parse_err(SYNERR, "incorrect or missing block for 'source_hpp'.\n"); return; } // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Header Form: %s\n", rule); if (_AD.get_registers() == NULL) { // Very early in the file, before reg_defs, we collect pre-headers. PreHeaderForm* pre_header = new PreHeaderForm(rule); _AD.addForm(pre_header); } else { // Normally, we collect header info, placed at the bottom of the hpp file. HeaderForm* header = new HeaderForm(rule); _AD.addForm(header); } } //------------------------------reg_parse-------------------------------------- void ADLParser::reg_parse(void) { // Create the RegisterForm for the architecture description. RegisterForm *regBlock = new RegisterForm(); // Build new Source object regBlock->_linenum = linenum(); _AD.addForm(regBlock); skipws(); // Skip leading whitespace if (_curchar == '%' && *(_ptr+1) == '{') { next_char(); next_char(); // Skip "%{" skipws(); while (_curchar != '%' && *(_ptr+1) != '}') { char *token = get_ident(); if (token == NULL) { parse_err(SYNERR, "missing identifier inside register block.\n"); return; } if (strcmp(token,"reg_def")==0) { reg_def_parse(); } else if (strcmp(token,"reg_class")==0) { reg_class_parse(); } else if (strcmp(token,"alloc_class")==0) { alloc_class_parse(); } else if (strcmp(token,"#define")==0) { preproc_define(); } else { parse_err(SYNERR, "bad token %s inside register block.\n", token); break; } skipws(); } } else { parse_err(SYNERR, "Missing %c{ ... %c} block after register keyword.\n",'%','%'); return; } // Add reg_class spill_regs regBlock->addSpillRegClass(); } //------------------------------encode_parse----------------------------------- void ADLParser::encode_parse(void) { EncodeForm *encBlock; // Information about instruction/operand encoding char *desc = NULL; // String representation of encode rule _AD.getForm(&encBlock); if ( encBlock == NULL) { // Create the EncodeForm for the architecture description. encBlock = new EncodeForm(); // Build new Source object _AD.addForm(encBlock); } skipws(); // Skip leading whitespace if (_curchar == '%' && *(_ptr+1) == '{') { next_char(); next_char(); // Skip "%{" skipws(); while (_curchar != '%' && *(_ptr+1) != '}') { char *token = get_ident(); if (token == NULL) { parse_err(SYNERR, "missing identifier inside encoding block.\n"); return; } if (strcmp(token,"enc_class")==0) { enc_class_parse(); } skipws(); } } else { parse_err(SYNERR, "Missing %c{ ... %c} block after encode keyword.\n",'%','%'); return; } } //------------------------------enc_class_parse-------------------------------- void ADLParser::enc_class_parse(void) { char *ec_name; // Name of encoding class being defined // Get encoding class name skipws(); // Skip whitespace ec_name = get_ident(); if (ec_name == NULL) { parse_err(SYNERR, "missing encoding class name after encode.\n"); return; } EncClass *encoding = _AD._encode->add_EncClass(ec_name); encoding->_linenum = linenum(); skipws(); // Skip leading whitespace // Check for optional parameter list if (_curchar == '(') { do { char *pType = NULL; // parameter type char *pName = NULL; // parameter name next_char(); // skip open paren & comma characters skipws(); if (_curchar == ')') break; // Get parameter type pType = get_ident(); if (pType == NULL) { parse_err(SYNERR, "parameter type expected at %c\n", _curchar); return; } skipws(); // Get parameter name pName = get_ident(); if (pName == NULL) { parse_err(SYNERR, "parameter name expected at %c\n", _curchar); return; } // Record parameter type and name encoding->add_parameter( pType, pName ); skipws(); } while(_curchar == ','); if (_curchar != ')') parse_err(SYNERR, "missing ')'\n"); else { next_char(); // Skip ')' } } // Done with parameter list skipws(); // Check for block starting delimiters if ((_curchar != '%') || (*(_ptr+1) != '{')) { // If not open block parse_err(SYNERR, "missing '%c{' in enc_class definition\n", '%'); return; } next_char(); // Skip '%' next_char(); // Skip '{' enc_class_parse_block(encoding, ec_name); } void ADLParser::enc_class_parse_block(EncClass* encoding, char* ec_name) { skipws_no_preproc(); // Skip leading whitespace // Prepend location descriptor, for debugging; cf. ADLParser::find_cpp_block if (_AD._adlocation_debug) { encoding->add_code(get_line_string()); } // Collect the parts of the encode description // (1) strings that are passed through to output // (2) replacement/substitution variable, preceeded by a '$' while ( (_curchar != '%') && (*(_ptr+1) != '}') ) { // (1) // Check if there is a string to pass through to output char *start = _ptr; // Record start of the next string while ((_curchar != '$') && ((_curchar != '%') || (*(_ptr+1) != '}')) ) { // If at the start of a comment, skip past it if( (_curchar == '/') && ((*(_ptr+1) == '/') || (*(_ptr+1) == '*')) ) { skipws_no_preproc(); } else { // ELSE advance to the next character, or start of the next line next_char_or_line(); } } // If a string was found, terminate it and record in EncClass if ( start != _ptr ) { *_ptr = '\0'; // Terminate the string encoding->add_code(start); } // (2) // If we are at a replacement variable, // copy it and record in EncClass if (_curchar == '$') { // Found replacement Variable char* rep_var = get_rep_var_ident_dup(); // Add flag to _strings list indicating we should check _rep_vars encoding->add_rep_var(rep_var); } } // end while part of format description next_char(); // Skip '%' next_char(); // Skip '}' skipws(); if (_AD._adlocation_debug) { encoding->add_code(end_line_marker()); } // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"EncodingClass Form: %s\n", ec_name); } //------------------------------frame_parse----------------------------------- void ADLParser::frame_parse(void) { FrameForm *frame; // Information about stack-frame layout char *desc = NULL; // String representation of frame skipws(); // Skip leading whitespace frame = new FrameForm(); // Build new Frame object // Check for open block sequence skipws(); // Skip leading whitespace if (_curchar == '%' && *(_ptr+1) == '{') { next_char(); next_char(); // Skip "%{" skipws(); while (_curchar != '%' && *(_ptr+1) != '}') { char *token = get_ident(); if (token == NULL) { parse_err(SYNERR, "missing identifier inside frame block.\n"); return; } if (strcmp(token,"stack_direction")==0) { stack_dir_parse(frame); } if (strcmp(token,"sync_stack_slots")==0) { sync_stack_slots_parse(frame); } if (strcmp(token,"frame_pointer")==0) { frame_pointer_parse(frame, false); } if (strcmp(token,"interpreter_frame_pointer")==0) { interpreter_frame_pointer_parse(frame, false); // Add reg_class interpreter_frame_pointer_reg if( _AD._register != NULL ) { RegClass *reg_class = _AD._register->addRegClass("interpreter_frame_pointer_reg"); char *interpreter_frame_pointer_reg = frame->_interpreter_frame_pointer_reg; if( interpreter_frame_pointer_reg != NULL ) { RegDef *regDef = _AD._register->getRegDef(interpreter_frame_pointer_reg); reg_class->addReg(regDef); // add regDef to regClass } } } if (strcmp(token,"inline_cache_reg")==0) { inline_cache_parse(frame, false); // Add reg_class inline_cache_reg if( _AD._register != NULL ) { RegClass *reg_class = _AD._register->addRegClass("inline_cache_reg"); char *inline_cache_reg = frame->_inline_cache_reg; if( inline_cache_reg != NULL ) { RegDef *regDef = _AD._register->getRegDef(inline_cache_reg); reg_class->addReg(regDef); // add regDef to regClass } } } if (strcmp(token,"compiler_method_oop_reg")==0) { parse_err(WARN, "Using obsolete Token, compiler_method_oop_reg"); skipws(); } if (strcmp(token,"interpreter_method_oop_reg")==0) { interpreter_method_oop_parse(frame, false); // Add reg_class interpreter_method_oop_reg if( _AD._register != NULL ) { RegClass *reg_class = _AD._register->addRegClass("interpreter_method_oop_reg"); char *method_oop_reg = frame->_interpreter_method_oop_reg; if( method_oop_reg != NULL ) { RegDef *regDef = _AD._register->getRegDef(method_oop_reg); reg_class->addReg(regDef); // add regDef to regClass } } } if (strcmp(token,"cisc_spilling_operand_name")==0) { cisc_spilling_operand_name_parse(frame, false); } if (strcmp(token,"stack_alignment")==0) { stack_alignment_parse(frame); } if (strcmp(token,"return_addr")==0) { return_addr_parse(frame, false); } if (strcmp(token,"in_preserve_stack_slots")==0) { preserve_stack_parse(frame); } if (strcmp(token,"out_preserve_stack_slots")==0) { parse_err(WARN, "Using obsolete token, out_preserve_stack_slots"); skipws(); } if (strcmp(token,"varargs_C_out_slots_killed")==0) { frame->_varargs_C_out_slots_killed = parse_one_arg("varargs C out slots killed"); } if (strcmp(token,"calling_convention")==0) { frame->_calling_convention = calling_convention_parse(); } if (strcmp(token,"return_value")==0) { frame->_return_value = return_value_parse(); } if (strcmp(token,"c_frame_pointer")==0) { frame_pointer_parse(frame, true); } if (strcmp(token,"c_return_addr")==0) { return_addr_parse(frame, true); } if (strcmp(token,"c_calling_convention")==0) { frame->_c_calling_convention = calling_convention_parse(); } if (strcmp(token,"c_return_value")==0) { frame->_c_return_value = return_value_parse(); } skipws(); } } else { parse_err(SYNERR, "Missing %c{ ... %c} block after encode keyword.\n",'%','%'); return; } // All Java versions are required, native versions are optional if(frame->_frame_pointer == NULL) { parse_err(SYNERR, "missing frame pointer definition in frame section.\n"); return; } // !!!!! !!!!! // if(frame->_interpreter_frame_ptr_reg == NULL) { // parse_err(SYNERR, "missing interpreter frame pointer definition in frame section.\n"); // return; // } if(frame->_alignment == NULL) { parse_err(SYNERR, "missing alignment definition in frame section.\n"); return; } if(frame->_return_addr == NULL) { parse_err(SYNERR, "missing return address location in frame section.\n"); return; } if(frame->_in_preserve_slots == NULL) { parse_err(SYNERR, "missing stack slot preservation definition in frame section.\n"); return; } if(frame->_varargs_C_out_slots_killed == NULL) { parse_err(SYNERR, "missing varargs C out slots killed definition in frame section.\n"); return; } if(frame->_calling_convention == NULL) { parse_err(SYNERR, "missing calling convention definition in frame section.\n"); return; } if(frame->_return_value == NULL) { parse_err(SYNERR, "missing return value definition in frame section.\n"); return; } // Fill natives in identically with the Java versions if not present. if(frame->_c_frame_pointer == NULL) { frame->_c_frame_pointer = frame->_frame_pointer; } if(frame->_c_return_addr == NULL) { frame->_c_return_addr = frame->_return_addr; frame->_c_return_addr_loc = frame->_return_addr_loc; } if(frame->_c_calling_convention == NULL) { frame->_c_calling_convention = frame->_calling_convention; } if(frame->_c_return_value == NULL) { frame->_c_return_value = frame->_return_value; } // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Frame Form: %s\n", desc); // Create the EncodeForm for the architecture description. _AD.addForm(frame); // skipws(); } //------------------------------stack_dir_parse-------------------------------- void ADLParser::stack_dir_parse(FrameForm *frame) { char *direction = parse_one_arg("stack direction entry"); if (strcmp(direction, "TOWARDS_LOW") == 0) { frame->_direction = false; } else if (strcmp(direction, "TOWARDS_HIGH") == 0) { frame->_direction = true; } else { parse_err(SYNERR, "invalid value inside stack direction entry.\n"); return; } } //------------------------------sync_stack_slots_parse------------------------- void ADLParser::sync_stack_slots_parse(FrameForm *frame) { // Assign value into frame form frame->_sync_stack_slots = parse_one_arg("sync stack slots entry"); } //------------------------------frame_pointer_parse---------------------------- void ADLParser::frame_pointer_parse(FrameForm *frame, bool native) { char *frame_pointer = parse_one_arg("frame pointer entry"); // Assign value into frame form if (native) { frame->_c_frame_pointer = frame_pointer; } else { frame->_frame_pointer = frame_pointer; } } //------------------------------interpreter_frame_pointer_parse---------------------------- void ADLParser::interpreter_frame_pointer_parse(FrameForm *frame, bool native) { frame->_interpreter_frame_pointer_reg = parse_one_arg("interpreter frame pointer entry"); } //------------------------------inline_cache_parse----------------------------- void ADLParser::inline_cache_parse(FrameForm *frame, bool native) { frame->_inline_cache_reg = parse_one_arg("inline cache reg entry"); } //------------------------------interpreter_method_oop_parse------------------ void ADLParser::interpreter_method_oop_parse(FrameForm *frame, bool native) { frame->_interpreter_method_oop_reg = parse_one_arg("method oop reg entry"); } //------------------------------cisc_spilling_operand_parse--------------------- void ADLParser::cisc_spilling_operand_name_parse(FrameForm *frame, bool native) { frame->_cisc_spilling_operand_name = parse_one_arg("cisc spilling operand name"); } //------------------------------stack_alignment_parse-------------------------- void ADLParser::stack_alignment_parse(FrameForm *frame) { char *alignment = parse_one_arg("stack alignment entry"); // Assign value into frame frame->_alignment = alignment; } //------------------------------parse_one_arg------------------------------- char *ADLParser::parse_one_arg(const char *description) { char *token = NULL; if(_curchar == '(') { next_char(); skipws(); token = get_expr(description, ")"); if (token == NULL) { parse_err(SYNERR, "missing value inside %s.\n", description); return NULL; } next_char(); // skip the close paren if(_curchar != ';') { // check for semi-colon parse_err(SYNERR, "missing %c in.\n", ';', description); return NULL; } next_char(); // skip the semi-colon } else { parse_err(SYNERR, "Missing %c in.\n", '(', description); return NULL; } trim(token); return token; } //------------------------------return_addr_parse------------------------------ void ADLParser::return_addr_parse(FrameForm *frame, bool native) { bool in_register = true; if(_curchar == '(') { next_char(); skipws(); char *token = get_ident(); if (token == NULL) { parse_err(SYNERR, "missing value inside return address entry.\n"); return; } // check for valid values for stack/register if (strcmp(token, "REG") == 0) { in_register = true; } else if (strcmp(token, "STACK") == 0) { in_register = false; } else { parse_err(SYNERR, "invalid value inside return_address entry.\n"); return; } if (native) { frame->_c_return_addr_loc = in_register; } else { frame->_return_addr_loc = in_register; } // Parse expression that specifies register or stack position skipws(); char *token2 = get_expr("return address entry", ")"); if (token2 == NULL) { parse_err(SYNERR, "missing value inside return address entry.\n"); return; } next_char(); // skip the close paren if (native) { frame->_c_return_addr = token2; } else { frame->_return_addr = token2; } if(_curchar != ';') { // check for semi-colon parse_err(SYNERR, "missing %c in return address entry.\n", ';'); return; } next_char(); // skip the semi-colon } else { parse_err(SYNERR, "Missing %c in return_address entry.\n", '('); } } //------------------------------preserve_stack_parse--------------------------- void ADLParser::preserve_stack_parse(FrameForm *frame) { if(_curchar == '(') { char *token = get_paren_expr("preserve_stack_slots"); frame->_in_preserve_slots = token; if(_curchar != ';') { // check for semi-colon parse_err(SYNERR, "missing %c in preserve stack slot entry.\n", ';'); return; } next_char(); // skip the semi-colon } else { parse_err(SYNERR, "Missing %c in preserve stack slot entry.\n", '('); } } //------------------------------calling_convention_parse----------------------- char *ADLParser::calling_convention_parse() { char *desc = NULL; // String representation of calling_convention skipws(); // Skip leading whitespace if ( (desc = find_cpp_block("calling convention block")) == NULL ) { parse_err(SYNERR, "incorrect or missing block for 'calling_convention'.\n"); } return desc; } //------------------------------return_value_parse----------------------------- char *ADLParser::return_value_parse() { char *desc = NULL; // String representation of calling_convention skipws(); // Skip leading whitespace if ( (desc = find_cpp_block("return value block")) == NULL ) { parse_err(SYNERR, "incorrect or missing block for 'return_value'.\n"); } return desc; } //------------------------------ins_pipe_parse--------------------------------- void ADLParser::ins_pipe_parse(InstructForm &instr) { char * ident; skipws(); if ( _curchar != '(' ) { // Check for delimiter parse_err(SYNERR, "missing \"(\" in ins_pipe definition\n"); return; } next_char(); ident = get_ident(); // Grab next identifier if (ident == NULL) { parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar); return; } skipws(); if ( _curchar != ')' ) { // Check for delimiter parse_err(SYNERR, "missing \")\" in ins_pipe definition\n"); return; } next_char(); // skip the close paren if(_curchar != ';') { // check for semi-colon parse_err(SYNERR, "missing %c in return value entry.\n", ';'); return; } next_char(); // skip the semi-colon // Check ident for validity if (_AD._pipeline && !_AD._pipeline->_classlist.search(ident)) { parse_err(SYNERR, "\"%s\" is not a valid pipeline class\n", ident); return; } // Add this instruction to the list in the pipeline class _AD._pipeline->_classdict[ident]->is_pipeclass()->_instructs.addName(instr._ident); // Set the name of the pipeline class in the instruction instr._ins_pipe = ident; return; } //------------------------------pipe_parse------------------------------------- void ADLParser::pipe_parse(void) { PipelineForm *pipeline; // Encode class for instruction/operand char * ident; pipeline = new PipelineForm(); // Build new Source object _AD.addForm(pipeline); skipws(); // Skip leading whitespace // Check for block delimiter if ( (_curchar != '%') || ( next_char(), (_curchar != '{')) ) { parse_err(SYNERR, "missing '%{' in pipeline definition\n"); return; } next_char(); // Maintain the invariant do { ident = get_ident(); // Grab next identifier if (ident == NULL) { parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar); continue; } if (!strcmp(ident, "resources" )) resource_parse(*pipeline); else if (!strcmp(ident, "pipe_desc" )) pipe_desc_parse(*pipeline); else if (!strcmp(ident, "pipe_class")) pipe_class_parse(*pipeline); else if (!strcmp(ident, "define")) { skipws(); if ( (_curchar != '%') || ( next_char(), (_curchar != '{')) ) { parse_err(SYNERR, "expected '%{'\n"); return; } next_char(); skipws(); char *node_class = get_ident(); if (node_class == NULL) { parse_err(SYNERR, "expected identifier, found \"%c\"\n", _curchar); return; } skipws(); if (_curchar != ',' && _curchar != '=') { parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar); break; } next_char(); skipws(); char *pipe_class = get_ident(); if (pipe_class == NULL) { parse_err(SYNERR, "expected identifier, found \"%c\"\n", _curchar); return; } if (_curchar != ';' ) { parse_err(SYNERR, "expected `;`, found '%c'\n", _curchar); break; } next_char(); // Skip over semi-colon skipws(); if ( (_curchar != '%') || ( next_char(), (_curchar != '}')) ) { parse_err(SYNERR, "expected '%%}', found \"%c\"\n", _curchar); } next_char(); // Check ident for validity if (_AD._pipeline && !_AD._pipeline->_classlist.search(pipe_class)) { parse_err(SYNERR, "\"%s\" is not a valid pipeline class\n", pipe_class); return; } // Add this machine node to the list in the pipeline class _AD._pipeline->_classdict[pipe_class]->is_pipeclass()->_instructs.addName(node_class); MachNodeForm *machnode = new MachNodeForm(node_class); // Create new machnode form machnode->_machnode_pipe = pipe_class; _AD.addForm(machnode); } else if (!strcmp(ident, "attributes")) { bool vsi_seen = false, bhds_seen = false; skipws(); if ( (_curchar != '%') || ( next_char(), (_curchar != '{')) ) { parse_err(SYNERR, "expected '%{'\n"); return; } next_char(); skipws(); while (_curchar != '%') { ident = get_ident(); if (ident == NULL) break; if (!strcmp(ident, "variable_size_instructions")) { skipws(); if (_curchar == ';') { next_char(); skipws(); } pipeline->_variableSizeInstrs = true; vsi_seen = true; continue; } if (!strcmp(ident, "fixed_size_instructions")) { skipws(); if (_curchar == ';') { next_char(); skipws(); } pipeline->_variableSizeInstrs = false; vsi_seen = true; continue; } if (!strcmp(ident, "branch_has_delay_slot")) { skipws(); if (_curchar == ';') { next_char(); skipws(); } pipeline->_branchHasDelaySlot = true; bhds_seen = true; continue; } if (!strcmp(ident, "max_instructions_per_bundle")) { skipws(); if (_curchar != '=') { parse_err(SYNERR, "expected `=`\n"); break; } next_char(); skipws(); pipeline->_maxInstrsPerBundle = get_int(); skipws(); if (_curchar == ';') { next_char(); skipws(); } continue; } if (!strcmp(ident, "max_bundles_per_cycle")) { skipws(); if (_curchar != '=') { parse_err(SYNERR, "expected `=`\n"); break; } next_char(); skipws(); pipeline->_maxBundlesPerCycle = get_int(); skipws(); if (_curchar == ';') { next_char(); skipws(); } continue; } if (!strcmp(ident, "instruction_unit_size")) { skipws(); if (_curchar != '=') { parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar); break; } next_char(); skipws(); pipeline->_instrUnitSize = get_int(); skipws(); if (_curchar == ';') { next_char(); skipws(); } continue; } if (!strcmp(ident, "bundle_unit_size")) { skipws(); if (_curchar != '=') { parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar); break; } next_char(); skipws(); pipeline->_bundleUnitSize = get_int(); skipws(); if (_curchar == ';') { next_char(); skipws(); } continue; } if (!strcmp(ident, "instruction_fetch_unit_size")) { skipws(); if (_curchar != '=') { parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar); break; } next_char(); skipws(); pipeline->_instrFetchUnitSize = get_int(); skipws(); if (_curchar == ';') { next_char(); skipws(); } continue; } if (!strcmp(ident, "instruction_fetch_units")) { skipws(); if (_curchar != '=') { parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar); break; } next_char(); skipws(); pipeline->_instrFetchUnits = get_int(); skipws(); if (_curchar == ';') { next_char(); skipws(); } continue; } if (!strcmp(ident, "nops")) { skipws(); if (_curchar != '(') { parse_err(SYNERR, "expected `(`, found '%c'\n", _curchar); break; } next_char(); skipws(); while (_curchar != ')') { ident = get_ident(); if (ident == NULL) { parse_err(SYNERR, "expected identifier for nop instruction, found '%c'\n", _curchar); break; } pipeline->_noplist.addName(ident); pipeline->_nopcnt++; skipws(); if (_curchar == ',') { next_char(); skipws(); } } next_char(); skipws(); if (_curchar == ';') { next_char(); skipws(); } continue; } parse_err(SYNERR, "unknown specifier \"%s\"\n", ident); } if ( (_curchar != '%') || ( next_char(), (_curchar != '}')) ) { parse_err(SYNERR, "expected '%}', found \"%c\"\n", _curchar); } next_char(); skipws(); if (pipeline->_maxInstrsPerBundle == 0) parse_err(SYNERR, "\"max_instructions_per_bundle\" unspecified\n"); if (pipeline->_instrUnitSize == 0 && pipeline->_bundleUnitSize == 0) parse_err(SYNERR, "\"instruction_unit_size\" and \"bundle_unit_size\" unspecified\n"); if (pipeline->_instrFetchUnitSize == 0) parse_err(SYNERR, "\"instruction_fetch_unit_size\" unspecified\n"); if (pipeline->_instrFetchUnits == 0) parse_err(SYNERR, "\"instruction_fetch_units\" unspecified\n"); if (!vsi_seen) parse_err(SYNERR, "\"variable_size_instruction\" or \"fixed_size_instruction\" unspecified\n"); } else { // Done with staticly defined parts of instruction definition parse_err(SYNERR, "expected one of \"resources\", \"pipe_desc\", \"pipe_class\", found \"%s\"\n", ident); return; } skipws(); if (_curchar == ';') skipws(); } while(_curchar != '%'); next_char(); if (_curchar != '}') { parse_err(SYNERR, "missing \"%}\" in pipeline definition\n"); return; } next_char(); } //------------------------------resource_parse---------------------------- void ADLParser::resource_parse(PipelineForm &pipeline) { ResourceForm *resource; char * ident; char * expr; unsigned mask; pipeline._rescount = 0; skipws(); // Skip leading whitespace if (_curchar != '(') { parse_err(SYNERR, "missing \"(\" in resource definition\n"); return; } do { next_char(); // Skip "(" or "," ident = get_ident(); // Grab next identifier if (ident == NULL) { parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar); return; } skipws(); if (_curchar != '=') { mask = (1 << pipeline._rescount++); } else { next_char(); skipws(); expr = get_ident(); // Grab next identifier if (expr == NULL) { parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar); return; } resource = (ResourceForm *) pipeline._resdict[expr]; if (resource == NULL) { parse_err(SYNERR, "resource \"%s\" is not defined\n", expr); return; } mask = resource->mask(); skipws(); while (_curchar == '|') { next_char(); skipws(); expr = get_ident(); // Grab next identifier if (expr == NULL) { parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar); return; } resource = (ResourceForm *) pipeline._resdict[expr]; // Look up the value if (resource == NULL) { parse_err(SYNERR, "resource \"%s\" is not defined\n", expr); return; } mask |= resource->mask(); skipws(); } } resource = new ResourceForm(mask); pipeline._resdict.Insert(ident, resource); pipeline._reslist.addName(ident); } while (_curchar == ','); if (_curchar != ')') { parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar); return; } next_char(); // Skip ")" if (_curchar == ';') next_char(); // Skip ";" } //------------------------------resource_parse---------------------------- void ADLParser::pipe_desc_parse(PipelineForm &pipeline) { char * ident; skipws(); // Skip leading whitespace if (_curchar != '(') { parse_err(SYNERR, "missing \"(\" in pipe_desc definition\n"); return; } do { next_char(); // Skip "(" or "," ident = get_ident(); // Grab next identifier if (ident == NULL) { parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar); return; } // Add the name to the list pipeline._stages.addName(ident); pipeline._stagecnt++; skipws(); } while (_curchar == ','); if (_curchar != ')') { parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar); return; } next_char(); // Skip ")" if (_curchar == ';') next_char(); // Skip ";" } //------------------------------pipe_class_parse-------------------------- void ADLParser::pipe_class_parse(PipelineForm &pipeline) { PipeClassForm *pipe_class; char * ident; char * stage; char * read_or_write; int is_write; int is_read; OperandForm *oper; skipws(); // Skip leading whitespace ident = get_ident(); // Grab next identifier if (ident == NULL) { parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar); return; } // Create a record for the pipe_class pipe_class = new PipeClassForm(ident, ++pipeline._classcnt); pipeline._classdict.Insert(ident, pipe_class); pipeline._classlist.addName(ident); // Then get the operands skipws(); if (_curchar != '(') { parse_err(SYNERR, "missing \"(\" in pipe_class definition\n"); } // Parse the operand list else get_oplist(pipe_class->_parameters, pipe_class->_localNames); skipws(); // Skip leading whitespace // Check for block delimiter if ( (_curchar != '%') || ( next_char(), (_curchar != '{')) ) { parse_err(SYNERR, "missing \"%{\" in pipe_class definition\n"); return; } next_char(); do { ident = get_ident(); // Grab next identifier if (ident == NULL) { parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar); continue; } skipws(); if (!strcmp(ident, "fixed_latency")) { skipws(); if (_curchar != '(') { parse_err(SYNERR, "missing \"(\" in latency definition\n"); return; } next_char(); skipws(); if( !isdigit(_curchar) ) { parse_err(SYNERR, "number expected for \"%c\" in latency definition\n", _curchar); return; } int fixed_latency = get_int(); skipws(); if (_curchar != ')') { parse_err(SYNERR, "missing \")\" in latency definition\n"); return; } next_char(); skipws(); if (_curchar != ';') { parse_err(SYNERR, "missing \";\" in latency definition\n"); return; } pipe_class->setFixedLatency(fixed_latency); next_char(); skipws(); continue; } if (!strcmp(ident, "zero_instructions") || !strcmp(ident, "no_instructions")) { skipws(); if (_curchar != ';') { parse_err(SYNERR, "missing \";\" in latency definition\n"); return; } pipe_class->setInstructionCount(0); next_char(); skipws(); continue; } if (!strcmp(ident, "one_instruction_with_delay_slot") || !strcmp(ident, "single_instruction_with_delay_slot")) { skipws(); if (_curchar != ';') { parse_err(SYNERR, "missing \";\" in latency definition\n"); return; } pipe_class->setInstructionCount(1); pipe_class->setBranchDelay(true); next_char(); skipws(); continue; } if (!strcmp(ident, "one_instruction") || !strcmp(ident, "single_instruction")) { skipws(); if (_curchar != ';') { parse_err(SYNERR, "missing \";\" in latency definition\n"); return; } pipe_class->setInstructionCount(1); next_char(); skipws(); continue; } if (!strcmp(ident, "instructions_in_first_bundle") || !strcmp(ident, "instruction_count")) { skipws(); int number_of_instructions = 1; if (_curchar != '(') { parse_err(SYNERR, "\"(\" expected at \"%c\"\n", _curchar); continue; } next_char(); skipws(); number_of_instructions = get_int(); skipws(); if (_curchar != ')') { parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar); continue; } next_char(); skipws(); if (_curchar != ';') { parse_err(SYNERR, "missing \";\" in latency definition\n"); return; } pipe_class->setInstructionCount(number_of_instructions); next_char(); skipws(); continue; } if (!strcmp(ident, "multiple_bundles")) { skipws(); if (_curchar != ';') { parse_err(SYNERR, "missing \";\" after multiple bundles\n"); return; } pipe_class->setMultipleBundles(true); next_char(); skipws(); continue; } if (!strcmp(ident, "has_delay_slot")) { skipws(); if (_curchar != ';') { parse_err(SYNERR, "missing \";\" after \"has_delay_slot\"\n"); return; } pipe_class->setBranchDelay(true); next_char(); skipws(); continue; } if (!strcmp(ident, "force_serialization")) { skipws(); if (_curchar != ';') { parse_err(SYNERR, "missing \";\" after \"force_serialization\"\n"); return; } pipe_class->setForceSerialization(true); next_char(); skipws(); continue; } if (!strcmp(ident, "may_have_no_code")) { skipws(); if (_curchar != ';') { parse_err(SYNERR, "missing \";\" after \"may_have_no_code\"\n"); return; } pipe_class->setMayHaveNoCode(true); next_char(); skipws(); continue; } const Form *parm = pipe_class->_localNames[ident]; if (parm != NULL) { oper = parm->is_operand(); if (oper == NULL && !parm->is_opclass()) { parse_err(SYNERR, "operand name expected at %s\n", ident); continue; } if (_curchar != ':') { parse_err(SYNERR, "\":\" expected at \"%c\"\n", _curchar); continue; } next_char(); skipws(); stage = get_ident(); if (stage == NULL) { parse_err(SYNERR, "pipeline stage identifier expected at \"%c\"\n", _curchar); continue; } skipws(); if (_curchar != '(') { parse_err(SYNERR, "\"(\" expected at \"%c\"\n", _curchar); continue; } next_char(); read_or_write = get_ident(); if (read_or_write == NULL) { parse_err(SYNERR, "\"read\" or \"write\" expected at \"%c\"\n", _curchar); continue; } is_read = strcmp(read_or_write, "read") == 0; is_write = strcmp(read_or_write, "write") == 0; if (!is_read && !is_write) { parse_err(SYNERR, "\"read\" or \"write\" expected at \"%c\"\n", _curchar); continue; } skipws(); if (_curchar != ')') { parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar); continue; } next_char(); skipws(); int more_instrs = 0; if (_curchar == '+') { next_char(); skipws(); if (_curchar < '0' || _curchar > '9') { parse_err(SYNERR, "<number> expected at \"%c\"\n", _curchar); continue; } while (_curchar >= '0' && _curchar <= '9') { more_instrs *= 10; more_instrs += _curchar - '0'; next_char(); } skipws(); } PipeClassOperandForm *pipe_operand = new PipeClassOperandForm(stage, is_write, more_instrs); pipe_class->_localUsage.Insert(ident, pipe_operand); if (_curchar == '%') continue; if (_curchar != ';') { parse_err(SYNERR, "\";\" expected at \"%c\"\n", _curchar); continue; } next_char(); skipws(); continue; } // Scan for Resource Specifier const Form *res = pipeline._resdict[ident]; if (res != NULL) { int cyclecnt = 1; if (_curchar != ':') { parse_err(SYNERR, "\":\" expected at \"%c\"\n", _curchar); continue; } next_char(); skipws(); stage = get_ident(); if (stage == NULL) { parse_err(SYNERR, "pipeline stage identifier expected at \"%c\"\n", _curchar); continue; } skipws(); if (_curchar == '(') { next_char(); cyclecnt = get_int(); skipws(); if (_curchar != ')') { parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar); continue; } next_char(); skipws(); } PipeClassResourceForm *resource = new PipeClassResourceForm(ident, stage, cyclecnt); int stagenum = pipeline._stages.index(stage); if (pipeline._maxcycleused < (stagenum+cyclecnt)) pipeline._maxcycleused = (stagenum+cyclecnt); pipe_class->_resUsage.addForm(resource); if (_curchar == '%') continue; if (_curchar != ';') { parse_err(SYNERR, "\";\" expected at \"%c\"\n", _curchar); continue; } next_char(); skipws(); continue; } parse_err(SYNERR, "resource expected at \"%s\"\n", ident); return; } while(_curchar != '%'); next_char(); if (_curchar != '}') { parse_err(SYNERR, "missing \"%}\" in pipe_class definition\n"); return; } next_char(); } //------------------------------peep_parse------------------------------------- void ADLParser::peep_parse(void) { Peephole *peep; // Pointer to current peephole rule form char *desc = NULL; // String representation of rule skipws(); // Skip leading whitespace peep = new Peephole(); // Build new Peephole object // Check for open block sequence skipws(); // Skip leading whitespace if (_curchar == '%' && *(_ptr+1) == '{') { next_char(); next_char(); // Skip "%{" skipws(); while (_curchar != '%' && *(_ptr+1) != '}') { char *token = get_ident(); if (token == NULL) { parse_err(SYNERR, "missing identifier inside peephole rule.\n"); return; } // check for legal subsections of peephole rule if (strcmp(token,"peepmatch")==0) { peep_match_parse(*peep); } else if (strcmp(token,"peepconstraint")==0) { peep_constraint_parse(*peep); } else if (strcmp(token,"peepreplace")==0) { peep_replace_parse(*peep); } else { parse_err(SYNERR, "expected peepmatch, peepconstraint, or peepreplace for identifier %s.\n", token); } skipws(); } } else { parse_err(SYNERR, "Missing %%{ ... %%} block after peephole keyword.\n"); return; } next_char(); // Skip past '%' next_char(); // Skip past '}' } // ******************** Private Level 2 Parse Functions ******************** //------------------------------constraint_parse------------------------------ Constraint *ADLParser::constraint_parse(void) { char *func; char *arg; // Check for constraint expression skipws(); if (_curchar != '(') { parse_err(SYNERR, "missing constraint expression, (...)\n"); return NULL; } next_char(); // Skip past '(' // Get constraint function skipws(); func = get_ident(); if (func == NULL) { parse_err(SYNERR, "missing function in constraint expression.\n"); return NULL; } if (strcmp(func,"ALLOC_IN_RC")==0 || strcmp(func,"IS_R_CLASS")==0) { // Check for '(' before argument skipws(); if (_curchar != '(') { parse_err(SYNERR, "missing '(' for constraint function's argument.\n"); return NULL; } next_char(); // Get it's argument skipws(); arg = get_ident(); if (arg == NULL) { parse_err(SYNERR, "missing argument for constraint function %s\n",func); return NULL; } // Check for ')' after argument skipws(); if (_curchar != ')') { parse_err(SYNERR, "missing ')' after constraint function argument %s\n",arg); return NULL; } next_char(); } else { parse_err(SYNERR, "Invalid constraint function %s\n",func); return NULL; } // Check for closing paren and ';' skipws(); if (_curchar != ')') { parse_err(SYNERR, "Missing ')' for constraint function %s\n",func); return NULL; } next_char(); skipws(); if (_curchar != ';') { parse_err(SYNERR, "Missing ';' after constraint.\n"); return NULL; } next_char(); // Create new "Constraint" Constraint *constraint = new Constraint(func,arg); return constraint; } //------------------------------constr_parse----------------------------------- ConstructRule *ADLParser::construct_parse(void) { return NULL; } //------------------------------reg_def_parse---------------------------------- void ADLParser::reg_def_parse(void) { char *rname; // Name of register being defined // Get register name skipws(); // Skip whitespace rname = get_ident(); if (rname == NULL) { parse_err(SYNERR, "missing register name after reg_def\n"); return; } // Check for definition of register calling convention (save on call, ...), // register save type, and register encoding value. skipws(); char *callconv = NULL; char *c_conv = NULL; char *idealtype = NULL; char *encoding = NULL; char *concrete = NULL; if (_curchar == '(') { next_char(); callconv = get_ident(); // Parse the internal calling convention, must be NS, SOC, SOE, or AS. if (callconv == NULL) { parse_err(SYNERR, "missing register calling convention value\n"); return; } if(strcmp(callconv, "SOC") && strcmp(callconv,"SOE") && strcmp(callconv, "NS") && strcmp(callconv, "AS")) { parse_err(SYNERR, "invalid value for register calling convention\n"); } skipws(); if (_curchar != ',') { parse_err(SYNERR, "missing comma in register definition statement\n"); return; } next_char(); // Parse the native calling convention, must be NS, SOC, SOE, AS c_conv = get_ident(); if (c_conv == NULL) { parse_err(SYNERR, "missing register native calling convention value\n"); return; } if(strcmp(c_conv, "SOC") && strcmp(c_conv,"SOE") && strcmp(c_conv, "NS") && strcmp(c_conv, "AS")) { parse_err(SYNERR, "invalid value for register calling convention\n"); } skipws(); if (_curchar != ',') { parse_err(SYNERR, "missing comma in register definition statement\n"); return; } next_char(); skipws(); // Parse the ideal save type idealtype = get_ident(); if (idealtype == NULL) { parse_err(SYNERR, "missing register save type value\n"); return; } skipws(); if (_curchar != ',') { parse_err(SYNERR, "missing comma in register definition statement\n"); return; } next_char(); skipws(); // Parse the encoding value encoding = get_expr("encoding", ","); if (encoding == NULL) { parse_err(SYNERR, "missing register encoding value\n"); return; } trim(encoding); if (_curchar != ',') { parse_err(SYNERR, "missing comma in register definition statement\n"); return; } next_char(); skipws(); // Parse the concrete name type // concrete = get_ident(); concrete = get_expr("concrete", ")"); if (concrete == NULL) { parse_err(SYNERR, "missing vm register name value\n"); return; } if (_curchar != ')') { parse_err(SYNERR, "missing ')' in register definition statement\n"); return; } next_char(); } // Check for closing ';' skipws(); if (_curchar != ';') { parse_err(SYNERR, "missing ';' after reg_def\n"); return; } next_char(); // move past ';' // Debug Stuff if (_AD._adl_debug > 1) { fprintf(stderr,"Register Definition: %s ( %s, %s %s )\n", rname, (callconv ? callconv : ""), (c_conv ? c_conv : ""), concrete); } // Record new register definition. _AD._register->addRegDef(rname, callconv, c_conv, idealtype, encoding, concrete); return; } //------------------------------reg_class_parse-------------------------------- void ADLParser::reg_class_parse(void) { char *cname; // Name of register class being defined // Get register class name skipws(); // Skip leading whitespace cname = get_ident(); if (cname == NULL) { parse_err(SYNERR, "missing register class name after 'reg_class'\n"); return; } // Debug Stuff if (_AD._adl_debug >1) fprintf(stderr,"Register Class: %s\n", cname); RegClass *reg_class = _AD._register->addRegClass(cname); // Collect registers in class skipws(); if (_curchar == '(') { next_char(); // Skip '(' skipws(); while (_curchar != ')') { char *rname = get_ident(); if (rname==NULL) { parse_err(SYNERR, "missing identifier inside reg_class list.\n"); return; } RegDef *regDef = _AD._register->getRegDef(rname); if (!regDef) { parse_err(SEMERR, "unknown identifier %s inside reg_class list.\n", rname); } else { reg_class->addReg(regDef); // add regDef to regClass } // Check for ',' and position to next token. skipws(); if (_curchar == ',') { next_char(); // Skip trailing ',' skipws(); } } next_char(); // Skip closing ')' } // Check for terminating ';' skipws(); if (_curchar != ';') { parse_err(SYNERR, "missing ';' at end of reg_class definition.\n"); return; } next_char(); // Skip trailing ';' // Check RegClass size, must be <= 32 registers in class. return; } //------------------------------alloc_class_parse------------------------------ void ADLParser::alloc_class_parse(void) { char *name; // Name of allocation class being defined // Get allocation class name skipws(); // Skip leading whitespace name = get_ident(); if (name == NULL) { parse_err(SYNERR, "missing allocation class name after 'reg_class'\n"); return; } // Debug Stuff if (_AD._adl_debug >1) fprintf(stderr,"Allocation Class: %s\n", name); AllocClass *alloc_class = _AD._register->addAllocClass(name); // Collect registers in class skipws(); if (_curchar == '(') { next_char(); // Skip '(' skipws(); while (_curchar != ')') { char *rname = get_ident(); if (rname==NULL) { parse_err(SYNERR, "missing identifier inside reg_class list.\n"); return; } // Check if name is a RegDef RegDef *regDef = _AD._register->getRegDef(rname); if (regDef) { alloc_class->addReg(regDef); // add regDef to allocClass } else { // name must be a RegDef or a RegClass parse_err(SYNERR, "name %s should be a previously defined reg_def.\n", rname); return; } // Check for ',' and position to next token. skipws(); if (_curchar == ',') { next_char(); // Skip trailing ',' skipws(); } } next_char(); // Skip closing ')' } // Check for terminating ';' skipws(); if (_curchar != ';') { parse_err(SYNERR, "missing ';' at end of reg_class definition.\n"); return; } next_char(); // Skip trailing ';' return; } //------------------------------peep_match_child_parse------------------------- InstructForm *ADLParser::peep_match_child_parse(PeepMatch &match, int parent, int &position, int input){ char *token = NULL; int lparen = 0; // keep track of parenthesis nesting depth int rparen = 0; // position of instruction at this depth InstructForm *inst_seen = NULL; InstructForm *child_seen = NULL; // Walk the match tree, // Record <parent, position, instruction name, input position> while ( lparen >= rparen ) { skipws(); // Left paren signals start of an input, collect with recursive call if (_curchar == '(') { ++lparen; next_char(); child_seen = peep_match_child_parse(match, parent, position, rparen); } // Right paren signals end of an input, may be more else if (_curchar == ')') { ++rparen; if( rparen == lparen ) { // IF rparen matches an lparen I've seen next_char(); // move past ')' } else { // ELSE leave ')' for parent assert( rparen == lparen + 1, "Should only see one extra ')'"); // if an instruction was not specified for this paren-pair if( ! inst_seen ) { // record signal entry match.add_instruction( parent, position, NameList::_signal, input ); ++position; } // ++input; // TEMPORARY return inst_seen; } } // if no parens, then check for instruction name // This instruction is the parent of a sub-tree else if ((token = get_ident_dup()) != NULL) { const Form *form = _AD._globalNames[token]; if (form) { InstructForm *inst = form->is_instruction(); // Record the first instruction at this level if( inst_seen == NULL ) { inst_seen = inst; } if (inst) { match.add_instruction( parent, position, token, input ); parent = position; ++position; } else { parse_err(SYNERR, "instruction name expected at identifier %s.\n", token); return inst_seen; } } else { parse_err(SYNERR, "missing identifier in peepmatch rule.\n"); return NULL; } } else { parse_err(SYNERR, "missing identifier in peepmatch rule.\n"); return NULL; } } // end while assert( false, "ShouldNotReachHere();"); return NULL; } //------------------------------peep_match_parse------------------------------- // Syntax for a peepmatch rule // // peepmatch ( root_instr_name [(instruction subtree)] [,(instruction subtree)]* ); // void ADLParser::peep_match_parse(Peephole &peep) { skipws(); // Check the structure of the rule // Check for open paren if (_curchar != '(') { parse_err(SYNERR, "missing '(' at start of peepmatch rule.\n"); return; } next_char(); // skip '(' // Construct PeepMatch and parse the peepmatch rule. PeepMatch *match = new PeepMatch(_ptr); int parent = -1; // parent of root int position = 0; // zero-based positions int input = 0; // input position in parent's operands InstructForm *root= peep_match_child_parse( *match, parent, position, input); if( root == NULL ) { parse_err(SYNERR, "missing instruction-name at start of peepmatch.\n"); return; } if( _curchar != ')' ) { parse_err(SYNERR, "missing ')' at end of peepmatch.\n"); return; } next_char(); // skip ')' // Check for closing semicolon skipws(); if( _curchar != ';' ) { parse_err(SYNERR, "missing ';' at end of peepmatch.\n"); return; } next_char(); // skip ';' // Store match into peep, and store peep into instruction peep.add_match(match); root->append_peephole(&peep); } //------------------------------peep_constraint_parse-------------------------- // Syntax for a peepconstraint rule // A parenthesized list of relations between operands in peepmatch subtree // // peepconstraint %{ // (instruction_number.operand_name // relational_op // instruction_number.operand_name OR register_name // [, ...] ); // // // instruction numbers are zero-based using topological order in peepmatch // void ADLParser::peep_constraint_parse(Peephole &peep) { skipws(); // Check the structure of the rule // Check for open paren if (_curchar != '(') { parse_err(SYNERR, "missing '(' at start of peepconstraint rule.\n"); return; } else { next_char(); // Skip '(' } // Check for a constraint skipws(); while( _curchar != ')' ) { // Get information on the left instruction and its operand // left-instructions's number int left_inst = get_int(); // Left-instruction's operand skipws(); if( _curchar != '.' ) { parse_err(SYNERR, "missing '.' in peepconstraint after instruction number.\n"); return; } next_char(); // Skip '.' char *left_op = get_ident_dup(); skipws(); // Collect relational operator char *relation = get_relation_dup(); skipws(); // Get information on the right instruction and its operand int right_inst; // Right-instructions's number if( isdigit(_curchar) ) { right_inst = get_int(); // Right-instruction's operand skipws(); if( _curchar != '.' ) { parse_err(SYNERR, "missing '.' in peepconstraint after instruction number.\n"); return; } next_char(); // Skip '.' } else { right_inst = -1; // Flag as being a register constraint } char *right_op = get_ident_dup(); // Construct the next PeepConstraint PeepConstraint *constraint = new PeepConstraint( left_inst, left_op, relation, right_inst, right_op ); // And append it to the list for this peephole rule peep.append_constraint( constraint ); // Check for another constraint, or end of rule skipws(); if( _curchar == ',' ) { next_char(); // Skip ',' skipws(); } else if( _curchar != ')' ) { parse_err(SYNERR, "expected ',' or ')' after peephole constraint.\n"); return; } } // end while( processing constraints ) next_char(); // Skip ')' // Check for terminating ';' skipws(); if (_curchar != ';') { parse_err(SYNERR, "missing ';' at end of peepconstraint.\n"); return; } next_char(); // Skip trailing ';' } //------------------------------peep_replace_parse----------------------------- // Syntax for a peepreplace rule // root instruction name followed by a // parenthesized list of whitespace separated instruction.operand specifiers // // peepreplace ( instr_name ( [instruction_number.operand_name]* ) ); // // void ADLParser::peep_replace_parse(Peephole &peep) { int lparen = 0; // keep track of parenthesis nesting depth int rparen = 0; // keep track of parenthesis nesting depth int icount = 0; // count of instructions in rule for naming char *str = NULL; char *token = NULL; skipws(); // Check for open paren if (_curchar != '(') { parse_err(SYNERR, "missing '(' at start of peepreplace rule.\n"); return; } else { lparen++; next_char(); } // Check for root instruction char *inst = get_ident_dup(); const Form *form = _AD._globalNames[inst]; if( form == NULL || form->is_instruction() == NULL ) { parse_err(SYNERR, "Instruction name expected at start of peepreplace.\n"); return; } // Store string representation of rule into replace PeepReplace *replace = new PeepReplace(str); replace->add_instruction( inst ); skipws(); // Start of root's operand-list if (_curchar != '(') { parse_err(SYNERR, "missing '(' at peepreplace root's operand-list.\n"); return; } else { lparen++; next_char(); } skipws(); // Get the list of operands while( _curchar != ')' ) { // Get information on an instruction and its operand // instructions's number int inst_num = get_int(); // Left-instruction's operand skipws(); if( _curchar != '.' ) { parse_err(SYNERR, "missing '.' in peepreplace after instruction number.\n"); return; } next_char(); // Skip '.' char *inst_op = get_ident_dup(); if( inst_op == NULL ) { parse_err(SYNERR, "missing operand identifier in peepreplace.\n"); return; } // Record this operand's position in peepmatch replace->add_operand( inst_num, inst_op ); skipws(); } // Check for the end of operands list skipws(); assert( _curchar == ')', "While loop should have advanced to ')'."); next_char(); // Skip ')' skipws(); // Check for end of peepreplace if( _curchar != ')' ) { parse_err(SYNERR, "missing ')' at end of peepmatch.\n"); parse_err(SYNERR, "Support one replacement instruction.\n"); return; } next_char(); // Skip ')' // Check for closing semicolon skipws(); if( _curchar != ';' ) { parse_err(SYNERR, "missing ';' at end of peepreplace.\n"); return; } next_char(); // skip ';' // Store replace into peep peep.add_replace( replace ); } //------------------------------pred_parse------------------------------------- Predicate *ADLParser::pred_parse(void) { Predicate *predicate; // Predicate class for operand char *rule = NULL; // String representation of predicate skipws(); // Skip leading whitespace int line = linenum(); if ( (rule = get_paren_expr("pred expression", true)) == NULL ) { parse_err(SYNERR, "incorrect or missing expression for 'predicate'\n"); return NULL; } // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Predicate: %s\n", rule); if (_curchar != ';') { parse_err(SYNERR, "missing ';' in predicate definition\n"); return NULL; } next_char(); // Point after the terminator predicate = new Predicate(rule); // Build new predicate object skipws(); return predicate; } //------------------------------ins_encode_parse_block------------------------- // Parse the block form of ins_encode. See ins_encode_parse for more details void ADLParser::ins_encode_parse_block(InstructForm& inst) { // Create a new encoding name based on the name of the instruction // definition, which should be unique. const char* prefix = "__ins_encode_"; char* ec_name = (char*) malloc(strlen(inst._ident) + strlen(prefix) + 1); sprintf(ec_name, "%s%s", prefix, inst._ident); assert(_AD._encode->encClass(ec_name) == NULL, "shouldn't already exist"); EncClass* encoding = _AD._encode->add_EncClass(ec_name); encoding->_linenum = linenum(); // synthesize the arguments list for the enc_class from the // arguments to the instruct definition. const char* param = NULL; inst._parameters.reset(); while ((param = inst._parameters.iter()) != NULL) { OperandForm* opForm = (OperandForm*) inst._localNames[param]; encoding->add_parameter(opForm->_ident, param); } // Define a MacroAssembler instance for use by the encoding. The // name is chosen to match the __ idiom used for assembly in other // parts of hotspot and assumes the existence of the standard // #define __ _masm. encoding->add_code(" MacroAssembler _masm(&cbuf);\n"); // Parse the following %{ }% block ins_encode_parse_block_impl(inst, encoding, ec_name); // Build an encoding rule which invokes the encoding rule we just // created, passing all arguments that we received. InsEncode* encrule = new InsEncode(); // Encode class for instruction NameAndList* params = encrule->add_encode(ec_name); inst._parameters.reset(); while ((param = inst._parameters.iter()) != NULL) { params->add_entry(param); } // Set encode class of this instruction. inst._insencode = encrule; } void ADLParser::ins_encode_parse_block_impl(InstructForm& inst, EncClass* encoding, char* ec_name) { skipws_no_preproc(); // Skip leading whitespace // Prepend location descriptor, for debugging; cf. ADLParser::find_cpp_block if (_AD._adlocation_debug) { encoding->add_code(get_line_string()); } // Collect the parts of the encode description // (1) strings that are passed through to output // (2) replacement/substitution variable, preceeded by a '$' while ((_curchar != '%') && (*(_ptr+1) != '}')) { // (1) // Check if there is a string to pass through to output char *start = _ptr; // Record start of the next string while ((_curchar != '$') && ((_curchar != '%') || (*(_ptr+1) != '}')) ) { // If at the start of a comment, skip past it if( (_curchar == '/') && ((*(_ptr+1) == '/') || (*(_ptr+1) == '*')) ) { skipws_no_preproc(); } else { // ELSE advance to the next character, or start of the next line next_char_or_line(); } } // If a string was found, terminate it and record in EncClass if (start != _ptr) { *_ptr = '\0'; // Terminate the string encoding->add_code(start); } // (2) // If we are at a replacement variable, // copy it and record in EncClass if (_curchar == '$') { // Found replacement Variable char* rep_var = get_rep_var_ident_dup(); // Add flag to _strings list indicating we should check _rep_vars encoding->add_rep_var(rep_var); skipws(); // Check if this instruct is a MachConstantNode. if (strcmp(rep_var, "constanttablebase") == 0) { // This instruct is a MachConstantNode. inst.set_is_mach_constant(true); if (_curchar == '(') { parse_err(SYNERR, "constanttablebase in instruct %s cannot have an argument (only constantaddress and constantoffset)", ec_name); return; } } else if ((strcmp(rep_var, "constantaddress") == 0) || (strcmp(rep_var, "constantoffset") == 0)) { // This instruct is a MachConstantNode. inst.set_is_mach_constant(true); // If the constant keyword has an argument, parse it. if (_curchar == '(') constant_parse(inst); } } } // end while part of format description next_char(); // Skip '%' next_char(); // Skip '}' skipws(); if (_AD._adlocation_debug) { encoding->add_code(end_line_marker()); } // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr, "EncodingClass Form: %s\n", ec_name); } //------------------------------ins_encode_parse------------------------------- // Encode rules have the form // ins_encode( encode_class_name(parameter_list), ... ); // // The "encode_class_name" must be defined in the encode section // The parameter list contains $names that are locals. // // Alternatively it can be written like this: // // ins_encode %{ // ... // body // %} // // which synthesizes a new encoding class taking the same arguments as // the InstructForm, and automatically prefixes the definition with: // // MacroAssembler masm(&cbuf);\n"); // // making it more compact to take advantage of the MacroAssembler and // placing the assembly closer to it's use by instructions. void ADLParser::ins_encode_parse(InstructForm& inst) { // Parse encode class name skipws(); // Skip whitespace if (_curchar != '(') { // Check for ins_encode %{ form if ((_curchar == '%') && (*(_ptr+1) == '{')) { next_char(); // Skip '%' next_char(); // Skip '{' // Parse the block form of ins_encode ins_encode_parse_block(inst); return; } parse_err(SYNERR, "missing '%%{' or '(' in ins_encode definition\n"); return; } next_char(); // move past '(' skipws(); InsEncode *encrule = new InsEncode(); // Encode class for instruction encrule->_linenum = linenum(); char *ec_name = NULL; // String representation of encode rule // identifier is optional. while (_curchar != ')') { ec_name = get_ident(); if (ec_name == NULL) { parse_err(SYNERR, "Invalid encode class name after 'ins_encode('.\n"); return; } // Check that encoding is defined in the encode section EncClass *encode_class = _AD._encode->encClass(ec_name); if (encode_class == NULL) { // Like to defer checking these till later... // parse_err(WARN, "Using an undefined encode class '%s' in 'ins_encode'.\n", ec_name); } // Get list for encode method's parameters NameAndList *params = encrule->add_encode(ec_name); // Parse the parameters to this encode method. skipws(); if ( _curchar == '(' ) { next_char(); // move past '(' for parameters // Parse the encode method's parameters while (_curchar != ')') { char *param = get_ident_or_literal_constant("encoding operand"); if ( param != NULL ) { // Found a parameter: // Check it is a local name, add it to the list, then check for more // New: allow hex constants as parameters to an encode method. // New: allow parenthesized expressions as parameters. // New: allow "primary", "secondary", "tertiary" as parameters. // New: allow user-defined register name as parameter if ( (inst._localNames[param] == NULL) && !ADLParser::is_literal_constant(param) && (Opcode::as_opcode_type(param) == Opcode::NOT_AN_OPCODE) && ((_AD._register == NULL ) || (_AD._register->getRegDef(param) == NULL)) ) { parse_err(SYNERR, "Using non-locally defined parameter %s for encoding %s.\n", param, ec_name); return; } params->add_entry(param); skipws(); if (_curchar == ',' ) { // More parameters to come next_char(); // move past ',' between parameters skipws(); // Skip to next parameter } else if (_curchar == ')') { // Done with parameter list } else { // Only ',' or ')' are valid after a parameter name parse_err(SYNERR, "expected ',' or ')' after parameter %s.\n", ec_name); return; } } else { skipws(); // Did not find a parameter if (_curchar == ',') { parse_err(SYNERR, "Expected encode parameter before ',' in encoding %s.\n", ec_name); return; } if (_curchar != ')') { parse_err(SYNERR, "Expected ')' after encode parameters.\n"); return; } } } // WHILE loop collecting parameters next_char(); // move past ')' at end of parameters } // done with parameter list for encoding // Check for ',' or ')' after encoding skipws(); // move to character after parameters if ( _curchar == ',' ) { // Found a ',' next_char(); // move past ',' between encode methods skipws(); } else if ( _curchar != ')' ) { // If not a ',' then only a ')' is allowed parse_err(SYNERR, "Expected ')' after encoding %s.\n", ec_name); return; } // Check for ',' separating parameters // if ( _curchar != ',' && _curchar != ')' ) { // parse_err(SYNERR, "expected ',' or ')' after encode method inside ins_encode.\n"); // return NULL; // } } // done parsing ins_encode methods and their parameters if (_curchar != ')') { parse_err(SYNERR, "Missing ')' at end of ins_encode description.\n"); return; } next_char(); // move past ')' skipws(); // Skip leading whitespace if ( _curchar != ';' ) { parse_err(SYNERR, "Missing ';' at end of ins_encode.\n"); return; } next_char(); // move past ';' skipws(); // be friendly to oper_parse() // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Instruction Encode: %s\n", ec_name); // Set encode class of this instruction. inst._insencode = encrule; } //------------------------------constant_parse--------------------------------- // Parse a constant expression. void ADLParser::constant_parse(InstructForm& inst) { // Create a new encoding name based on the name of the instruction // definition, which should be unique. const char* prefix = "__constant_"; char* ec_name = (char*) malloc(strlen(inst._ident) + strlen(prefix) + 1); sprintf(ec_name, "%s%s", prefix, inst._ident); assert(_AD._encode->encClass(ec_name) == NULL, "shouldn't already exist"); EncClass* encoding = _AD._encode->add_EncClass(ec_name); encoding->_linenum = linenum(); // synthesize the arguments list for the enc_class from the // arguments to the instruct definition. const char* param = NULL; inst._parameters.reset(); while ((param = inst._parameters.iter()) != NULL) { OperandForm* opForm = (OperandForm*) inst._localNames[param]; encoding->add_parameter(opForm->_ident, param); } // Parse the following ( ) expression. constant_parse_expression(encoding, ec_name); // Build an encoding rule which invokes the encoding rule we just // created, passing all arguments that we received. InsEncode* encrule = new InsEncode(); // Encode class for instruction NameAndList* params = encrule->add_encode(ec_name); inst._parameters.reset(); while ((param = inst._parameters.iter()) != NULL) { params->add_entry(param); } // Set encode class of this instruction. inst._constant = encrule; } //------------------------------constant_parse_expression---------------------- void ADLParser::constant_parse_expression(EncClass* encoding, char* ec_name) { skipws(); // Prepend location descriptor, for debugging; cf. ADLParser::find_cpp_block if (_AD._adlocation_debug) { encoding->add_code(get_line_string()); } // Start code line. encoding->add_code(" _constant = C->constant_table().add"); // Parse everything in ( ) expression. encoding->add_code("("); next_char(); // Skip '(' int parens_depth = 1; // Collect the parts of the constant expression. // (1) strings that are passed through to output // (2) replacement/substitution variable, preceeded by a '$' while (parens_depth > 0) { if (_curchar == '(') { parens_depth++; encoding->add_code("("); next_char(); } else if (_curchar == ')') { parens_depth--; encoding->add_code(")"); next_char(); } else { // (1) // Check if there is a string to pass through to output char *start = _ptr; // Record start of the next string while ((_curchar != '$') && (_curchar != '(') && (_curchar != ')')) { next_char(); } // If a string was found, terminate it and record in EncClass if (start != _ptr) { *_ptr = '\0'; // Terminate the string encoding->add_code(start); } // (2) // If we are at a replacement variable, copy it and record in EncClass. if (_curchar == '$') { // Found replacement Variable char* rep_var = get_rep_var_ident_dup(); encoding->add_rep_var(rep_var); } } } // Finish code line. encoding->add_code(";"); if (_AD._adlocation_debug) { encoding->add_code(end_line_marker()); } // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr, "EncodingClass Form: %s\n", ec_name); } //------------------------------size_parse----------------------------------- char* ADLParser::size_parse(InstructForm *instr) { char* sizeOfInstr = NULL; // Get value of the instruction's size skipws(); // Parse size sizeOfInstr = get_paren_expr("size expression"); if (sizeOfInstr == NULL) { parse_err(SYNERR, "size of opcode expected at %c\n", _curchar); return NULL; } skipws(); // Check for terminator if (_curchar != ';') { parse_err(SYNERR, "missing ';' in ins_attrib definition\n"); return NULL; } next_char(); // Advance past the ';' skipws(); // necessary for instr_parse() // Debug Stuff if (_AD._adl_debug > 1) { if (sizeOfInstr != NULL) { fprintf(stderr,"size of opcode: %s\n", sizeOfInstr); } } return sizeOfInstr; } //------------------------------opcode_parse----------------------------------- Opcode * ADLParser::opcode_parse(InstructForm *instr) { char *primary = NULL; char *secondary = NULL; char *tertiary = NULL; char *val = NULL; Opcode *opcode = NULL; // Get value of the instruction's opcode skipws(); if (_curchar != '(') { // Check for parenthesized operand list parse_err(SYNERR, "missing '(' in expand instruction declaration\n"); return NULL; } next_char(); // skip open paren skipws(); if (_curchar != ')') { // Parse primary, secondary, and tertiary opcodes, if provided. if ( ((primary = get_ident_or_literal_constant("primary opcode")) == NULL) ) { parse_err(SYNERR, "primary hex opcode expected at %c\n", _curchar); return NULL; } skipws(); if (_curchar == ',') { next_char(); skipws(); // Parse secondary opcode if ( ((secondary = get_ident_or_literal_constant("secondary opcode")) == NULL) ) { parse_err(SYNERR, "secondary hex opcode expected at %c\n", _curchar); return NULL; } skipws(); if (_curchar == ',') { next_char(); skipws(); // Parse tertiary opcode if ( ((tertiary = get_ident_or_literal_constant("tertiary opcode")) == NULL) ) { parse_err(SYNERR,"tertiary hex opcode expected at %c\n", _curchar); return NULL; } skipws(); } } skipws(); if (_curchar != ')') { parse_err(SYNERR, "Missing ')' in opcode description\n"); return NULL; } } next_char(); // Skip ')' skipws(); // Check for terminator if (_curchar != ';') { parse_err(SYNERR, "missing ';' in ins_attrib definition\n"); return NULL; } next_char(); // Advance past the ';' skipws(); // necessary for instr_parse() // Debug Stuff if (_AD._adl_debug > 1) { if (primary != NULL) fprintf(stderr,"primary opcode: %s\n", primary); if (secondary != NULL) fprintf(stderr,"secondary opcode: %s\n", secondary); if (tertiary != NULL) fprintf(stderr,"tertiary opcode: %s\n", tertiary); } // Generate new object and return opcode = new Opcode(primary, secondary, tertiary); return opcode; } //------------------------------interface_parse-------------------------------- Interface *ADLParser::interface_parse(void) { char *iface_name = NULL; // Name of interface class being used char *iface_code = NULL; // Describe components of this class // Get interface class name skipws(); // Skip whitespace if (_curchar != '(') { parse_err(SYNERR, "Missing '(' at start of interface description.\n"); return NULL; } next_char(); // move past '(' skipws(); iface_name = get_ident(); if (iface_name == NULL) { parse_err(SYNERR, "missing interface name after 'interface'.\n"); return NULL; } skipws(); if (_curchar != ')') { parse_err(SYNERR, "Missing ')' after name of interface.\n"); return NULL; } next_char(); // move past ')' // Get details of the interface, // for the type of interface indicated by iface_name. Interface *inter = NULL; skipws(); if ( _curchar != ';' ) { if ( strcmp(iface_name,"MEMORY_INTER") == 0 ) { inter = mem_interface_parse(); } else if ( strcmp(iface_name,"COND_INTER") == 0 ) { inter = cond_interface_parse(); } // The parse routines consume the "%}" // Check for probable extra ';' after defining block. if ( _curchar == ';' ) { parse_err(SYNERR, "Extra ';' after defining interface block.\n"); next_char(); // Skip ';' return NULL; } } else { next_char(); // move past ';' // Create appropriate interface object if ( strcmp(iface_name,"REG_INTER") == 0 ) { inter = new RegInterface(); } else if ( strcmp(iface_name,"CONST_INTER") == 0 ) { inter = new ConstInterface(); } } skipws(); // be friendly to oper_parse() // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Interface Form: %s\n", iface_name); // Create appropriate interface object and return. return inter; } //------------------------------mem_interface_parse---------------------------- Interface *ADLParser::mem_interface_parse(void) { // Fields for MemInterface char *base = NULL; char *index = NULL; char *scale = NULL; char *disp = NULL; if (_curchar != '%') { parse_err(SYNERR, "Missing '%{' for 'interface' block.\n"); return NULL; } next_char(); // Skip '%' if (_curchar != '{') { parse_err(SYNERR, "Missing '%{' for 'interface' block.\n"); return NULL; } next_char(); // Skip '{' skipws(); do { char *field = get_ident(); if (field == NULL) { parse_err(SYNERR, "Expected keyword, base|index|scale|disp, or '%}' ending interface.\n"); return NULL; } if ( strcmp(field,"base") == 0 ) { base = interface_field_parse(); } else if ( strcmp(field,"index") == 0 ) { index = interface_field_parse(); } else if ( strcmp(field,"scale") == 0 ) { scale = interface_field_parse(); } else if ( strcmp(field,"disp") == 0 ) { disp = interface_field_parse(); } else { parse_err(SYNERR, "Expected keyword, base|index|scale|disp, or '%}' ending interface.\n"); return NULL; } } while( _curchar != '%' ); next_char(); // Skip '%' if ( _curchar != '}' ) { parse_err(SYNERR, "Missing '%}' for 'interface' block.\n"); return NULL; } next_char(); // Skip '}' // Construct desired object and return Interface *inter = new MemInterface(base, index, scale, disp); return inter; } //------------------------------cond_interface_parse--------------------------- Interface *ADLParser::cond_interface_parse(void) { char *equal; char *not_equal; char *less; char *greater_equal; char *less_equal; char *greater; const char *equal_format = "eq"; const char *not_equal_format = "ne"; const char *less_format = "lt"; const char *greater_equal_format = "ge"; const char *less_equal_format = "le"; const char *greater_format = "gt"; if (_curchar != '%') { parse_err(SYNERR, "Missing '%{' for 'cond_interface' block.\n"); return NULL; } next_char(); // Skip '%' if (_curchar != '{') { parse_err(SYNERR, "Missing '%{' for 'cond_interface' block.\n"); return NULL; } next_char(); // Skip '{' skipws(); do { char *field = get_ident(); if (field == NULL) { parse_err(SYNERR, "Expected keyword, base|index|scale|disp, or '%}' ending interface.\n"); return NULL; } if ( strcmp(field,"equal") == 0 ) { equal = interface_field_parse(&equal_format); } else if ( strcmp(field,"not_equal") == 0 ) { not_equal = interface_field_parse(¬_equal_format); } else if ( strcmp(field,"less") == 0 ) { less = interface_field_parse(&less_format); } else if ( strcmp(field,"greater_equal") == 0 ) { greater_equal = interface_field_parse(&greater_equal_format); } else if ( strcmp(field,"less_equal") == 0 ) { less_equal = interface_field_parse(&less_equal_format); } else if ( strcmp(field,"greater") == 0 ) { greater = interface_field_parse(&greater_format); } else { parse_err(SYNERR, "Expected keyword, base|index|scale|disp, or '%}' ending interface.\n"); return NULL; } } while( _curchar != '%' ); next_char(); // Skip '%' if ( _curchar != '}' ) { parse_err(SYNERR, "Missing '%}' for 'interface' block.\n"); return NULL; } next_char(); // Skip '}' // Construct desired object and return Interface *inter = new CondInterface(equal, equal_format, not_equal, not_equal_format, less, less_format, greater_equal, greater_equal_format, less_equal, less_equal_format, greater, greater_format); return inter; } //------------------------------interface_field_parse-------------------------- char *ADLParser::interface_field_parse(const char ** format) { char *iface_field = NULL; // Get interface field skipws(); // Skip whitespace if (_curchar != '(') { parse_err(SYNERR, "Missing '(' at start of interface field.\n"); return NULL; } next_char(); // move past '(' skipws(); if ( _curchar != '0' && _curchar != '$' ) { parse_err(SYNERR, "missing or invalid interface field contents.\n"); return NULL; } iface_field = get_rep_var_ident(); if (iface_field == NULL) { parse_err(SYNERR, "missing or invalid interface field contents.\n"); return NULL; } skipws(); if (format != NULL && _curchar == ',') { next_char(); skipws(); if (_curchar != '"') { parse_err(SYNERR, "Missing '\"' in field format .\n"); return NULL; } next_char(); char *start = _ptr; // Record start of the next string while ((_curchar != '"') && (_curchar != '%') && (_curchar != '\n')) { if (_curchar == '\\') next_char(); // superquote if (_curchar == '\n') parse_err(SYNERR, "newline in string"); // unimplemented! next_char(); } if (_curchar != '"') { parse_err(SYNERR, "Missing '\"' at end of field format .\n"); return NULL; } // If a string was found, terminate it and record in FormatRule if ( start != _ptr ) { *_ptr = '\0'; // Terminate the string *format = start; } next_char(); skipws(); } if (_curchar != ')') { parse_err(SYNERR, "Missing ')' after interface field.\n"); return NULL; } next_char(); // move past ')' skipws(); if ( _curchar != ';' ) { parse_err(SYNERR, "Missing ';' at end of interface field.\n"); return NULL; } next_char(); // move past ';' skipws(); // be friendly to interface_parse() return iface_field; } //------------------------------match_parse------------------------------------ MatchRule *ADLParser::match_parse(FormDict &operands) { MatchRule *match; // Match Rule class for instruction/operand char *cnstr = NULL; // Code for constructor int depth = 0; // Counter for matching parentheses int numleaves = 0; // Counter for number of leaves in rule // Parse the match rule tree MatchNode *mnode = matchNode_parse(operands, depth, numleaves, true); // Either there is a block with a constructor, or a ';' here skipws(); // Skip whitespace if ( _curchar == ';' ) { // Semicolon is valid terminator cnstr = NULL; // no constructor for this form next_char(); // Move past the ';', replaced with '\0' } else if ((cnstr = find_cpp_block("match constructor")) == NULL ) { parse_err(SYNERR, "invalid construction of match rule\n" "Missing ';' or invalid '%{' and '%}' constructor\n"); return NULL; // No MatchRule to return } if (_AD._adl_debug > 1) if (cnstr) fprintf(stderr,"Match Constructor: %s\n", cnstr); // Build new MatchRule object match = new MatchRule(_AD, mnode, depth, cnstr, numleaves); skipws(); // Skip any trailing whitespace return match; // Return MatchRule object } //------------------------------format_parse----------------------------------- FormatRule* ADLParser::format_parse(void) { char *desc = NULL; FormatRule *format = (new FormatRule(desc)); // Without expression form, MUST have a code block; skipws(); // Skip whitespace if ( _curchar == ';' ) { // Semicolon is valid terminator desc = NULL; // no constructor for this form next_char(); // Move past the ';', replaced with '\0' } else if ( _curchar == '%' && *(_ptr+1) == '{') { next_char(); // Move past the '%' next_char(); // Move past the '{' skipws(); if (_curchar == '$') { char* ident = get_rep_var_ident(); if (strcmp(ident, "$$template") == 0) return template_parse(); parse_err(SYNERR, "Unknown \"%s\" directive in format", ident); return NULL; } // Check for the opening '"' inside the format description if ( _curchar == '"' ) { next_char(); // Move past the initial '"' if( _curchar == '"' ) { // Handle empty format string case *_ptr = '\0'; // Terminate empty string format->_strings.addName(_ptr); } // Collect the parts of the format description // (1) strings that are passed through to tty->print // (2) replacement/substitution variable, preceeded by a '$' // (3) multi-token ANSIY C style strings while ( true ) { if ( _curchar == '%' || _curchar == '\n' ) { if ( _curchar != '"' ) { parse_err(SYNERR, "missing '\"' at end of format block"); return NULL; } } // (1) // Check if there is a string to pass through to output char *start = _ptr; // Record start of the next string while ((_curchar != '$') && (_curchar != '"') && (_curchar != '%') && (_curchar != '\n')) { if (_curchar == '\\') { next_char(); // superquote if ((_curchar == '$') || (_curchar == '%')) // hack to avoid % escapes and warnings about undefined \ escapes *(_ptr-1) = _curchar; } if (_curchar == '\n') parse_err(SYNERR, "newline in string"); // unimplemented! next_char(); } // If a string was found, terminate it and record in FormatRule if ( start != _ptr ) { *_ptr = '\0'; // Terminate the string format->_strings.addName(start); } // (2) // If we are at a replacement variable, // copy it and record in FormatRule if ( _curchar == '$' ) { next_char(); // Move past the '$' char* rep_var = get_ident(); // Nil terminate the variable name rep_var = strdup(rep_var);// Copy the string *_ptr = _curchar; // and replace Nil with original character format->_rep_vars.addName(rep_var); // Add flag to _strings list indicating we should check _rep_vars format->_strings.addName(NameList::_signal); } // (3) // Allow very long strings to be broken up, // using the ANSI C syntax "foo\n" <newline> "bar" if ( _curchar == '"') { next_char(); // Move past the '"' skipws(); // Skip white space before next string token if ( _curchar != '"') { break; } else { // Found one. Skip both " and the whitespace in between. next_char(); } } } // end while part of format description // Check for closing '"' and '%}' in format description skipws(); // Move to closing '%}' if ( _curchar != '%' ) { parse_err(SYNERR, "non-blank characters between closing '\"' and '%' in format"); return NULL; } } // Done with format description inside skipws(); // Past format description, at '%' if ( _curchar != '%' || *(_ptr+1) != '}' ) { parse_err(SYNERR, "missing '%}' at end of format block"); return NULL; } next_char(); // Move past the '%' next_char(); // Move past the '}' } else { // parameter list alone must terminate with a ';' parse_err(SYNERR, "missing ';' after Format expression"); return NULL; } // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Format Rule: %s\n", desc); skipws(); return format; } //------------------------------template_parse----------------------------------- FormatRule* ADLParser::template_parse(void) { char *desc = NULL; FormatRule *format = (new FormatRule(desc)); skipws(); while ( (_curchar != '%') && (*(_ptr+1) != '}') ) { // (1) // Check if there is a string to pass through to output { char *start = _ptr; // Record start of the next string while ((_curchar != '$') && ((_curchar != '%') || (*(_ptr+1) != '}')) ) { // If at the start of a comment, skip past it if( (_curchar == '/') && ((*(_ptr+1) == '/') || (*(_ptr+1) == '*')) ) { skipws_no_preproc(); } else { // ELSE advance to the next character, or start of the next line next_char_or_line(); } } // If a string was found, terminate it and record in EncClass if ( start != _ptr ) { *_ptr = '\0'; // Terminate the string // Add flag to _strings list indicating we should check _rep_vars format->_strings.addName(NameList::_signal2); format->_strings.addName(start); } } // (2) // If we are at a replacement variable, // copy it and record in EncClass if ( _curchar == '$' ) { // Found replacement Variable char *rep_var = get_rep_var_ident_dup(); if (strcmp(rep_var, "$emit") == 0) { // switch to normal format parsing next_char(); next_char(); skipws(); // Check for the opening '"' inside the format description if ( _curchar == '"' ) { next_char(); // Move past the initial '"' if( _curchar == '"' ) { // Handle empty format string case *_ptr = '\0'; // Terminate empty string format->_strings.addName(_ptr); } // Collect the parts of the format description // (1) strings that are passed through to tty->print // (2) replacement/substitution variable, preceeded by a '$' // (3) multi-token ANSIY C style strings while ( true ) { if ( _curchar == '%' || _curchar == '\n' ) { parse_err(SYNERR, "missing '\"' at end of format block"); return NULL; } // (1) // Check if there is a string to pass through to output char *start = _ptr; // Record start of the next string while ((_curchar != '$') && (_curchar != '"') && (_curchar != '%') && (_curchar != '\n')) { if (_curchar == '\\') next_char(); // superquote if (_curchar == '\n') parse_err(SYNERR, "newline in string"); // unimplemented! next_char(); } // If a string was found, terminate it and record in FormatRule if ( start != _ptr ) { *_ptr = '\0'; // Terminate the string format->_strings.addName(start); } // (2) // If we are at a replacement variable, // copy it and record in FormatRule if ( _curchar == '$' ) { next_char(); // Move past the '$' char* next_rep_var = get_ident(); // Nil terminate the variable name next_rep_var = strdup(next_rep_var);// Copy the string *_ptr = _curchar; // and replace Nil with original character format->_rep_vars.addName(next_rep_var); // Add flag to _strings list indicating we should check _rep_vars format->_strings.addName(NameList::_signal); } // (3) // Allow very long strings to be broken up, // using the ANSI C syntax "foo\n" <newline> "bar" if ( _curchar == '"') { next_char(); // Move past the '"' skipws(); // Skip white space before next string token if ( _curchar != '"') { break; } else { // Found one. Skip both " and the whitespace in between. next_char(); } } } // end while part of format description } } else { // Add flag to _strings list indicating we should check _rep_vars format->_rep_vars.addName(rep_var); // Add flag to _strings list indicating we should check _rep_vars format->_strings.addName(NameList::_signal3); } } // end while part of format description } skipws(); // Past format description, at '%' if ( _curchar != '%' || *(_ptr+1) != '}' ) { parse_err(SYNERR, "missing '%}' at end of format block"); return NULL; } next_char(); // Move past the '%' next_char(); // Move past the '}' // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Format Rule: %s\n", desc); skipws(); return format; } //------------------------------effect_parse----------------------------------- void ADLParser::effect_parse(InstructForm *instr) { char* desc = NULL; skipws(); // Skip whitespace if (_curchar != '(') { parse_err(SYNERR, "missing '(' in effect definition\n"); return; } // Get list of effect-operand pairs and insert into dictionary else get_effectlist(instr->_effects, instr->_localNames); // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Effect description: %s\n", desc); if (_curchar != ';') { parse_err(SYNERR, "missing ';' in Effect definition\n"); } next_char(); // Skip ';' } //------------------------------expand_parse----------------------------------- ExpandRule* ADLParser::expand_parse(InstructForm *instr) { char *ident, *ident2; OperandForm *oper; InstructForm *ins; NameAndList *instr_and_operands = NULL; ExpandRule *exp = new ExpandRule(); // Expand is a block containing an ordered list of instructions, each of // which has an ordered list of operands. // Check for block delimiter skipws(); // Skip leading whitespace if ((_curchar != '%') || (next_char(), (_curchar != '{')) ) { // If not open block parse_err(SYNERR, "missing '%{' in expand definition\n"); return(NULL); } next_char(); // Maintain the invariant do { ident = get_ident(); // Grab next identifier if (ident == NULL) { parse_err(SYNERR, "identifier expected at %c\n", _curchar); continue; } // Check that you have a valid instruction const Form *form = _globalNames[ident]; ins = form ? form->is_instruction() : NULL; if (ins == NULL) { // This is a new operand oper = form ? form->is_operand() : NULL; if (oper == NULL) { parse_err(SYNERR, "instruction/operand name expected at %s\n", ident); continue; } // Throw the operand on the _newopers list skipws(); ident = get_unique_ident(instr->_localNames,"Operand"); if (ident == NULL) { parse_err(SYNERR, "identifier expected at %c\n", _curchar); continue; } exp->_newopers.addName(ident); // Add new operand to LocalNames instr->_localNames.Insert(ident, oper); // Grab any constructor code and save as a string char *c = NULL; skipws(); if (_curchar == '%') { // Need a constructor for the operand c = find_cpp_block("Operand Constructor"); if (c == NULL) { parse_err(SYNERR, "Invalid code block for operand constructor\n", _curchar); continue; } // Add constructor to _newopconst Dict exp->_newopconst.Insert(ident, c); } else if (_curchar != ';') { // If no constructor, need a ; parse_err(SYNERR, "Missing ; in expand rule operand declaration\n"); continue; } else next_char(); // Skip the ; skipws(); } else { // Add instruction to list instr_and_operands = new NameAndList(ident); // Grab operands, build nameList of them, and then put into dictionary skipws(); if (_curchar != '(') { // Check for parenthesized operand list parse_err(SYNERR, "missing '(' in expand instruction declaration\n"); continue; } do { next_char(); // skip open paren & comma characters skipws(); if (_curchar == ')') break; ident2 = get_ident(); skipws(); if (ident2 == NULL) { parse_err(SYNERR, "identifier expected at %c\n", _curchar); continue; } // Check that you have a valid operand const Form *form2 = instr->_localNames[ident2]; if (!form2) { parse_err(SYNERR, "operand name expected at %s\n", ident2); continue; } oper = form2->is_operand(); if (oper == NULL && !form2->is_opclass()) { parse_err(SYNERR, "operand name expected at %s\n", ident2); continue; } // Add operand to list instr_and_operands->add_entry(ident2); } while(_curchar == ','); if (_curchar != ')') { parse_err(SYNERR, "missing ')'in expand instruction declaration\n"); continue; } next_char(); if (_curchar != ';') { parse_err(SYNERR, "missing ';'in expand instruction declaration\n"); continue; } next_char(); // Record both instruction name and its operand list exp->add_instruction(instr_and_operands); skipws(); } } while(_curchar != '%'); next_char(); if (_curchar != '}') { parse_err(SYNERR, "missing '%}' in expand rule definition\n"); return(NULL); } next_char(); // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Expand Rule:\n"); skipws(); return (exp); } //------------------------------rewrite_parse---------------------------------- RewriteRule* ADLParser::rewrite_parse(void) { char* params = NULL; char* desc = NULL; // This feature targeted for second generation description language. skipws(); // Skip whitespace // Get parameters for rewrite if ((params = get_paren_expr("rewrite parameters")) == NULL) { parse_err(SYNERR, "missing '(' in rewrite rule\n"); return NULL; } // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Rewrite parameters: %s\n", params); // For now, grab entire block; skipws(); if ( (desc = find_cpp_block("rewrite block")) == NULL ) { parse_err(SYNERR, "incorrect or missing block for 'rewrite'.\n"); return NULL; } // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Rewrite Rule: %s\n", desc); skipws(); return (new RewriteRule(params,desc)); } //------------------------------attr_parse------------------------------------- Attribute *ADLParser::attr_parse(char* ident) { Attribute *attrib; // Attribute class char *cost = NULL; // String representation of cost attribute skipws(); // Skip leading whitespace if ( (cost = get_paren_expr("attribute")) == NULL ) { parse_err(SYNERR, "incorrect or missing expression for 'attribute'\n"); return NULL; } // Debug Stuff if (_AD._adl_debug > 1) fprintf(stderr,"Attribute: %s\n", cost); if (_curchar != ';') { parse_err(SYNERR, "missing ';' in attribute definition\n"); return NULL; } next_char(); // Point after the terminator skipws(); attrib = new Attribute(ident,cost,INS_ATTR); // Build new predicate object return attrib; } //------------------------------matchNode_parse-------------------------------- MatchNode *ADLParser::matchNode_parse(FormDict &operands, int &depth, int &numleaves, bool atroot) { // Count depth of parenthesis nesting for both left and right children int lParens = depth; int rParens = depth; // MatchNode objects for left, right, and root of subtree. MatchNode *lChild = NULL; MatchNode *rChild = NULL; char *token; // Identifier which may be opcode or operand // Match expression starts with a '(' if (cur_char() != '(') return NULL; next_char(); // advance past '(' // Parse the opcode token = get_ident(); // Get identifier, opcode if (token == NULL) { parse_err(SYNERR, "missing opcode in match expression\n"); return NULL; } // Take note if we see one of a few special operations - those that are // treated differently on different architectures in the sense that on // one architecture there is a match rule and on another there isn't (so // a call will eventually be generated). for (int i = _last_machine_leaf + 1; i < _last_opcode; i++) { if (strcmp(token, NodeClassNames[i]) == 0) { _AD.has_match_rule(i, true); } } // Lookup the root value in the operands dict to perform substitution const char *result = NULL; // Result type will be filled in later const char *name = token; // local name associated with this node const char *operation = token; // remember valid operation for later const Form *form = operands[token]; OpClassForm *opcForm = form ? form->is_opclass() : NULL; if (opcForm != NULL) { // If this token is an entry in the local names table, record its type if (!opcForm->ideal_only()) { operation = opcForm->_ident; result = operation; // Operands result in their own type } // Otherwise it is an ideal type, and so, has no local name else name = NULL; } // Parse the operands skipws(); if (cur_char() != ')') { // Parse the left child if (strcmp(operation,"Set")) lChild = matchChild_parse(operands, lParens, numleaves, false); else lChild = matchChild_parse(operands, lParens, numleaves, true); skipws(); if (cur_char() != ')' ) { if(strcmp(operation, "Set")) rChild = matchChild_parse(operands,rParens,numleaves,false); else rChild = matchChild_parse(operands,rParens,numleaves,true); } } // Check for required ')' skipws(); if (cur_char() != ')') { parse_err(SYNERR, "missing ')' in match expression\n"); return NULL; } next_char(); // skip the ')' MatchNode* mroot = new MatchNode(_AD,result,name,operation,lChild,rChild); // If not the root, reduce this subtree to an internal operand if (!atroot) { mroot->build_internalop(); } // depth is greater of left and right paths. depth = (lParens > rParens) ? lParens : rParens; return mroot; } //------------------------------matchChild_parse------------------------------- MatchNode *ADLParser::matchChild_parse(FormDict &operands, int &parens, int &numleaves, bool atroot) { MatchNode *child = NULL; const char *result = NULL; const char *token = NULL; const char *opType = NULL; if (cur_char() == '(') { // child is an operation ++parens; child = matchNode_parse(operands, parens, numleaves, atroot); } else { // child is an operand token = get_ident(); const Form *form = operands[token]; OpClassForm *opcForm = form ? form->is_opclass() : NULL; if (opcForm != NULL) { opType = opcForm->_ident; result = opcForm->_ident; // an operand's result matches its type } else { parse_err(SYNERR, "undefined operand %s in match rule\n", token); return NULL; } if (opType == NULL) { parse_err(SYNERR, "missing type for argument '%s'\n", token); } child = new MatchNode(_AD, result, token, opType); ++numleaves; } return child; } // ******************** Private Utility Functions ************************* char* ADLParser::find_cpp_block(const char* description) { char *next; // Pointer for finding block delimiters char* cppBlock = NULL; // Beginning of C++ code block if (_curchar == '%') { // Encoding is a C++ expression next_char(); if (_curchar != '{') { parse_err(SYNERR, "missing '{' in %s \n", description); return NULL; } next_char(); // Skip block delimiter skipws_no_preproc(); // Skip leading whitespace cppBlock = _ptr; // Point to start of expression int line = linenum(); next = _ptr + 1; while(((_curchar != '%') || (*next != '}')) && (_curchar != '\0')) { next_char_or_line(); next = _ptr+1; // Maintain the next pointer } // Grab string if (_curchar == '\0') { parse_err(SYNERR, "invalid termination of %s \n", description); return NULL; } *_ptr = '\0'; // Terminate string _ptr += 2; // Skip block delimiter _curchar = *_ptr; // Maintain invariant // Prepend location descriptor, for debugging. if (_AD._adlocation_debug) { char* location = get_line_string(line); char* end_loc = end_line_marker(); char* result = (char *)malloc(strlen(location) + strlen(cppBlock) + strlen(end_loc) + 1); strcpy(result, location); strcat(result, cppBlock); strcat(result, end_loc); cppBlock = result; free(location); } } return cppBlock; } // Move to the closing token of the expression we are currently at, // as defined by stop_chars. Match parens and quotes. char* ADLParser::get_expr(const char *desc, const char *stop_chars) { char* expr = NULL; int paren = 0; expr = _ptr; while (paren > 0 || !strchr(stop_chars, _curchar)) { if (_curchar == '(') { // Down level of nesting paren++; // Bump the parenthesis counter next_char(); // maintain the invariant } else if (_curchar == ')') { // Up one level of nesting if (paren == 0) { // Paren underflow: We didn't encounter the required stop-char. parse_err(SYNERR, "too many )'s, did not find %s after %s\n", stop_chars, desc); return NULL; } paren--; // Drop the parenthesis counter next_char(); // Maintain the invariant } else if (_curchar == '"' || _curchar == '\'') { int qchar = _curchar; while (true) { next_char(); if (_curchar == qchar) { next_char(); break; } if (_curchar == '\\') next_char(); // superquote if (_curchar == '\n' || _curchar == '\0') { parse_err(SYNERR, "newline in string in %s\n", desc); return NULL; } } } else if (_curchar == '%' && (_ptr[1] == '{' || _ptr[1] == '}')) { // Make sure we do not stray into the next ADLC-level form. parse_err(SYNERR, "unexpected %%%c in %s\n", _ptr[1], desc); return NULL; } else if (_curchar == '\0') { parse_err(SYNERR, "unexpected EOF in %s\n", desc); return NULL; } else { // Always walk over whitespace, comments, preprocessor directives, etc. char* pre_skip_ptr = _ptr; skipws(); // If the parser declined to make progress on whitespace, // skip the next character, which is therefore NOT whitespace. if (pre_skip_ptr == _ptr) { next_char(); } else if (pre_skip_ptr+strlen(pre_skip_ptr) != _ptr+strlen(_ptr)) { parse_err(SYNERR, "unimplemented: preprocessor must not elide subexpression in %s", desc); } } } assert(strchr(stop_chars, _curchar), "non-null return must be at stop-char"); *_ptr = '\0'; // Replace ')' or other stop-char with '\0' return expr; } // Helper function around get_expr // Sets _curchar to '(' so that get_paren_expr will search for a matching ')' char *ADLParser::get_paren_expr(const char *description, bool include_location) { int line = linenum(); if (_curchar != '(') // Escape if not valid starting position return NULL; next_char(); // Skip the required initial paren. char *token2 = get_expr(description, ")"); if (_curchar == ')') next_char(); // Skip required final paren. int junk = 0; if (include_location && _AD._adlocation_debug && !is_int_token(token2, junk)) { // Prepend location descriptor, for debugging. char* location = get_line_string(line); char* end_loc = end_line_marker(); char* result = (char *)malloc(strlen(location) + strlen(token2) + strlen(end_loc) + 1); strcpy(result, location); strcat(result, token2); strcat(result, end_loc); token2 = result; free(location); } return token2; } //------------------------------get_ident_common------------------------------- // Looks for an identifier in the buffer, and turns it into a null terminated // string(still inside the file buffer). Returns a pointer to the string or // NULL if some other token is found instead. char *ADLParser::get_ident_common(bool do_preproc) { register char c; char *start; // Pointer to start of token char *end; // Pointer to end of token if( _curline == NULL ) // Return NULL at EOF. return NULL; skipws_common(do_preproc); // Skip whitespace before identifier start = end = _ptr; // Start points at first character end--; // unwind end by one to prepare for loop do { end++; // Increment end pointer c = *end; // Grab character to test } while ( ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) || ((c >= '0') && (c <= '9')) || ((c == '_')) || ((c == ':')) || ((c == '#')) ); if (start == end) { // We popped out on the first try parse_err(SYNERR, "identifier expected at %c\n", c); start = NULL; } else { _curchar = c; // Save the first character of next token *end = '\0'; // NULL terminate the string in place } _ptr = end; // Reset _ptr to point to next char after token // Make sure we do not try to use #defined identifiers. If start is // NULL an error was already reported. if (do_preproc && start != NULL) { const char* def = _AD.get_preproc_def(start); if (def != NULL && strcmp(def, start)) { const char* def1 = def; const char* def2 = _AD.get_preproc_def(def1); // implement up to 2 levels of #define if (def2 != NULL && strcmp(def2, def1)) { def = def2; const char* def3 = _AD.get_preproc_def(def2); if (def3 != NULL && strcmp(def3, def2) && strcmp(def3, def1)) { parse_err(SYNERR, "unimplemented: using %s defined as %s => %s => %s", start, def1, def2, def3); } } start = strdup(def); } } return start; // Pointer to token in filebuf } //------------------------------get_ident_dup---------------------------------- // Looks for an identifier in the buffer, and returns a duplicate // or NULL if some other token is found instead. char *ADLParser::get_ident_dup(void) { char *ident = get_ident(); // Duplicate an identifier before returning and restore string. if( ident != NULL ) { ident = strdup(ident); // Copy the string *_ptr = _curchar; // and replace Nil with original character } return ident; } //----------------------get_ident_or_literal_constant-------------------------- // Looks for an identifier in the buffer, or a parenthesized expression. char *ADLParser::get_ident_or_literal_constant(const char* description) { char* param = NULL; skipws(); if (_curchar == '(') { // Grab a constant expression. param = get_paren_expr(description); if (param[0] != '(') { char* buf = (char*) malloc(strlen(param) + 3); sprintf(buf, "(%s)", param); param = buf; } assert(is_literal_constant(param), "expr must be recognizable as a constant"); } else { param = get_ident(); } return param; } //------------------------------get_rep_var_ident----------------------------- // Do NOT duplicate, // Leave nil terminator in buffer // Preserve initial '$'(s) in string char *ADLParser::get_rep_var_ident(void) { // Remember starting point char *rep_var = _ptr; // Check for replacement variable indicator '$' and pass if present if ( _curchar == '$' ) { next_char(); } // Check for a subfield indicator, a second '$', and pass if present if ( _curchar == '$' ) { next_char(); } // Check for a control indicator, a third '$': if ( _curchar == '$' ) { next_char(); } // Check for more than three '$'s in sequence, SYNERR if( _curchar == '$' ) { parse_err(SYNERR, "Replacement variables and field specifiers can not start with '$$$$'"); next_char(); return NULL; } // Nil terminate the variable name following the '$' char *rep_var_name = get_ident(); assert( rep_var_name != NULL, "Missing identifier after replacement variable indicator '$'"); return rep_var; } //------------------------------get_rep_var_ident_dup------------------------- // Return the next replacement variable identifier, skipping first '$' // given a pointer into a line of the buffer. // Null terminates string, still inside the file buffer, // Returns a pointer to a copy of the string, or NULL on failure char *ADLParser::get_rep_var_ident_dup(void) { if( _curchar != '$' ) return NULL; next_char(); // Move past the '$' char *rep_var = _ptr; // Remember starting point // Check for a subfield indicator, a second '$': if ( _curchar == '$' ) { next_char(); } // Check for a control indicator, a third '$': if ( _curchar == '$' ) { next_char(); } // Check for more than three '$'s in sequence, SYNERR if( _curchar == '$' ) { parse_err(SYNERR, "Replacement variables and field specifiers can not start with '$$$$'"); next_char(); return NULL; } // Nil terminate the variable name following the '$' char *rep_var_name = get_ident(); assert( rep_var_name != NULL, "Missing identifier after replacement variable indicator '$'"); rep_var = strdup(rep_var); // Copy the string *_ptr = _curchar; // and replace Nil with original character return rep_var; } //------------------------------get_unique_ident------------------------------ // Looks for an identifier in the buffer, terminates it with a NULL, // and checks that it is unique char *ADLParser::get_unique_ident(FormDict& dict, const char* nameDescription){ char* ident = get_ident(); if (ident == NULL) { parse_err(SYNERR, "missing %s identifier at %c\n", nameDescription, _curchar); } else { if (dict[ident] != NULL) { parse_err(SYNERR, "duplicate name %s for %s\n", ident, nameDescription); ident = NULL; } } return ident; } //------------------------------get_int---------------------------------------- // Looks for a character string integer in the buffer, and turns it into an int // invokes a parse_err if the next token is not an integer. // This routine does not leave the integer null-terminated. int ADLParser::get_int(void) { register char c; char *start; // Pointer to start of token char *end; // Pointer to end of token int result; // Storage for integer result if( _curline == NULL ) // Return NULL at EOF. return 0; skipws(); // Skip whitespace before identifier start = end = _ptr; // Start points at first character c = *end; // Grab character to test while ((c >= '0') && (c <= '9') || ((c == '-') && (end == start))) { end++; // Increment end pointer c = *end; // Grab character to test } if (start == end) { // We popped out on the first try parse_err(SYNERR, "integer expected at %c\n", c); result = 0; } else { _curchar = c; // Save the first character of next token *end = '\0'; // NULL terminate the string in place result = atoi(start); // Convert the string to an integer *end = _curchar; // Restore buffer to original condition } // Reset _ptr to next char after token _ptr = end; return result; // integer } //------------------------------get_relation_dup------------------------------ // Looks for a relational operator in the buffer // invokes a parse_err if the next token is not a relation // This routine creates a duplicate of the string in the buffer. char *ADLParser::get_relation_dup(void) { char *result = NULL; // relational operator being returned if( _curline == NULL ) // Return NULL at EOF. return NULL; skipws(); // Skip whitespace before relation char *start = _ptr; // Store start of relational operator char first = *_ptr; // the first character if( (first == '=') || (first == '!') || (first == '<') || (first == '>') ) { next_char(); char second = *_ptr; // the second character if( (second == '=') ) { next_char(); char tmp = *_ptr; *_ptr = '\0'; // NULL terminate result = strdup(start); // Duplicate the string *_ptr = tmp; // restore buffer } else { parse_err(SYNERR, "relational operator expected at %s\n", _ptr); } } else { parse_err(SYNERR, "relational operator expected at %s\n", _ptr); } return result; } //------------------------------get_oplist------------------------------------- // Looks for identifier pairs where first must be the name of an operand, and // second must be a name unique in the scope of this instruction. Stores the // names with a pointer to the OpClassForm of their type in a local name table. void ADLParser::get_oplist(NameList ¶meters, FormDict &operands) { OpClassForm *opclass = NULL; char *ident = NULL; do { next_char(); // skip open paren & comma characters skipws(); if (_curchar == ')') break; // Get operand type, and check it against global name table ident = get_ident(); if (ident == NULL) { parse_err(SYNERR, "optype identifier expected at %c\n", _curchar); return; } else { const Form *form = _globalNames[ident]; if( form == NULL ) { parse_err(SYNERR, "undefined operand type %s\n", ident); return; } // Check for valid operand type OpClassForm *opc = form->is_opclass(); OperandForm *oper = form->is_operand(); if((oper == NULL) && (opc == NULL)) { parse_err(SYNERR, "identifier %s not operand type\n", ident); return; } opclass = opc; } // Debugging Stuff if (_AD._adl_debug > 1) fprintf(stderr, "\tOperand Type: %s\t", ident); // Get name of operand and add it to local name table if( (ident = get_unique_ident(operands, "operand")) == NULL) { return; } // Parameter names must not be global names. if( _globalNames[ident] != NULL ) { parse_err(SYNERR, "Reuse of global name %s as operand.\n",ident); return; } operands.Insert(ident, opclass); parameters.addName(ident); // Debugging Stuff if (_AD._adl_debug > 1) fprintf(stderr, "\tOperand Name: %s\n", ident); skipws(); } while(_curchar == ','); if (_curchar != ')') parse_err(SYNERR, "missing ')'\n"); else { next_char(); // set current character position past the close paren } } //------------------------------get_effectlist--------------------------------- // Looks for identifier pairs where first must be the name of a pre-defined, // effect, and the second must be the name of an operand defined in the // operand list of this instruction. Stores the names with a pointer to the // effect form in a local effects table. void ADLParser::get_effectlist(FormDict &effects, FormDict &operands) { OperandForm *opForm; Effect *eForm; char *ident; do { next_char(); // skip open paren & comma characters skipws(); if (_curchar == ')') break; // Get effect type, and check it against global name table ident = get_ident(); if (ident == NULL) { parse_err(SYNERR, "effect type identifier expected at %c\n", _curchar); return; } else { // Check for valid effect type const Form *form = _globalNames[ident]; if( form == NULL ) { parse_err(SYNERR, "undefined effect type %s\n", ident); return; } else { if( (eForm = form->is_effect()) == NULL) { parse_err(SYNERR, "identifier %s not effect type\n", ident); return; } } } // Debugging Stuff if (_AD._adl_debug > 1) fprintf(stderr, "\tEffect Type: %s\t", ident); skipws(); // Get name of operand and check that it is in the local name table if( (ident = get_unique_ident(effects, "effect")) == NULL) { parse_err(SYNERR, "missing operand identifier in effect list\n"); return; } const Form *form = operands[ident]; opForm = form ? form->is_operand() : NULL; if( opForm == NULL ) { if( form && form->is_opclass() ) { const char* cname = form->is_opclass()->_ident; parse_err(SYNERR, "operand classes are illegal in effect lists (found %s %s)\n", cname, ident); } else { parse_err(SYNERR, "undefined operand %s in effect list\n", ident); } return; } // Add the pair to the effects table effects.Insert(ident, eForm); // Debugging Stuff if (_AD._adl_debug > 1) fprintf(stderr, "\tOperand Name: %s\n", ident); skipws(); } while(_curchar == ','); if (_curchar != ')') parse_err(SYNERR, "missing ')'\n"); else { next_char(); // set current character position past the close paren } } //-------------------------------preproc_line---------------------------------- // A "#line" keyword has been seen, so parse the rest of the line. void ADLParser::preproc_line(void) { int line = get_int(); skipws_no_preproc(); const char* file = NULL; if (_curchar == '"') { next_char(); // Move past the initial '"' file = _ptr; while (true) { if (_curchar == '\n') { parse_err(SYNERR, "missing '\"' at end of #line directive"); return; } if (_curchar == '"') { *_ptr = '\0'; // Terminate the string next_char(); skipws_no_preproc(); break; } next_char(); } } ensure_end_of_line(); if (file != NULL) _AD._ADL_file._name = file; _buf.set_linenum(line); } //------------------------------preproc_define--------------------------------- // A "#define" keyword has been seen, so parse the rest of the line. void ADLParser::preproc_define(void) { char* flag = get_ident_no_preproc(); skipws_no_preproc(); // only #define x y is supported for now char* def = get_ident_no_preproc(); _AD.set_preproc_def(flag, def); skipws_no_preproc(); if (_curchar != '\n') { parse_err(SYNERR, "non-identifier in preprocessor definition\n"); } } //------------------------------preproc_undef---------------------------------- // An "#undef" keyword has been seen, so parse the rest of the line. void ADLParser::preproc_undef(void) { char* flag = get_ident_no_preproc(); skipws_no_preproc(); ensure_end_of_line(); _AD.set_preproc_def(flag, NULL); } //------------------------------parse_err-------------------------------------- // Issue a parser error message, and skip to the end of the current line void ADLParser::parse_err(int flag, const char *fmt, ...) { va_list args; va_start(args, fmt); if (flag == 1) _AD._syntax_errs += _AD.emit_msg(0, flag, linenum(), fmt, args); else if (flag == 2) _AD._semantic_errs += _AD.emit_msg(0, flag, linenum(), fmt, args); else _AD._warnings += _AD.emit_msg(0, flag, linenum(), fmt, args); int error_char = _curchar; char* error_ptr = _ptr+1; for(;*_ptr != '\n'; _ptr++) ; // Skip to the end of the current line _curchar = '\n'; va_end(args); _AD._no_output = 1; if (flag == 1) { char* error_tail = strchr(error_ptr, '\n'); char tem = *error_ptr; error_ptr[-1] = '\0'; char* error_head = error_ptr-1; while (error_head > _curline && *error_head) --error_head; if (error_tail) *error_tail = '\0'; fprintf(stderr, "Error Context: %s>>>%c<<<%s\n", error_head, error_char, error_ptr); if (error_tail) *error_tail = '\n'; error_ptr[-1] = tem; } } //---------------------------ensure_start_of_line------------------------------ // A preprocessor directive has been encountered. Be sure it has fallen at // the beginning of a line, or else report an error. void ADLParser::ensure_start_of_line(void) { if (_curchar == '\n') { next_line(); return; } assert( _ptr >= _curline && _ptr < _curline+strlen(_curline), "Must be able to find which line we are in" ); for (char *s = _curline; s < _ptr; s++) { if (*s > ' ') { parse_err(SYNERR, "'%c' must be at beginning of line\n", _curchar); break; } } } //---------------------------ensure_end_of_line-------------------------------- // A preprocessor directive has been parsed. Be sure there is no trailing // garbage at the end of this line. Set the scan point to the beginning of // the next line. void ADLParser::ensure_end_of_line(void) { skipws_no_preproc(); if (_curchar != '\n' && _curchar != '\0') { parse_err(SYNERR, "garbage char '%c' at end of line\n", _curchar); } else { next_char_or_line(); } } //---------------------------handle_preproc------------------------------------ // The '#' character introducing a preprocessor directive has been found. // Parse the whole directive name (e.g., #define, #endif) and take appropriate // action. If we are in an "untaken" span of text, simply keep track of // #ifdef nesting structure, so we can find out when to start taking text // again. (In this state, we "sort of support" C's #if directives, enough // to disregard their associated #else and #endif lines.) If we are in a // "taken" span of text, there are two cases: "#define" and "#undef" // directives are preserved and passed up to the caller, which eventually // passes control to the top-level parser loop, which handles #define and // #undef directly. (This prevents these directives from occurring in // arbitrary positions in the AD file--we require better structure than C.) // In the other case, and #ifdef, #ifndef, #else, or #endif is silently // processed as whitespace, with the "taken" state of the text correctly // updated. This routine returns "false" exactly in the case of a "taken" // #define or #undef, which tells the caller that a preprocessor token // has appeared which must be handled explicitly by the parse loop. bool ADLParser::handle_preproc_token() { assert(*_ptr == '#', "must be at start of preproc"); ensure_start_of_line(); next_char(); skipws_no_preproc(); char* start_ident = _ptr; char* ident = (_curchar == '\n') ? NULL : get_ident_no_preproc(); if (ident == NULL) { parse_err(SYNERR, "expected preprocessor command, got end of line\n"); } else if (!strcmp(ident, "ifdef") || !strcmp(ident, "ifndef")) { char* flag = get_ident_no_preproc(); ensure_end_of_line(); // Test the identifier only if we are already in taken code: bool flag_def = preproc_taken() && (_AD.get_preproc_def(flag) != NULL); bool now_taken = !strcmp(ident, "ifdef") ? flag_def : !flag_def; begin_if_def(now_taken); } else if (!strcmp(ident, "if")) { if (preproc_taken()) parse_err(SYNERR, "unimplemented: #%s %s", ident, _ptr+1); next_line(); // Intelligently skip this nested C preprocessor directive: begin_if_def(true); } else if (!strcmp(ident, "else")) { ensure_end_of_line(); invert_if_def(); } else if (!strcmp(ident, "endif")) { ensure_end_of_line(); end_if_def(); } else if (preproc_taken()) { // pass this token up to the main parser as "#define" or "#undef" _ptr = start_ident; _curchar = *--_ptr; if( _curchar != '#' ) { parse_err(SYNERR, "no space allowed after # in #define or #undef"); assert(_curchar == '#', "no space allowed after # in #define or #undef"); } return false; } return true; } //---------------------------skipws_common------------------------------------- // Skip whitespace, including comments and newlines, while keeping an accurate // line count. // Maybe handle certain preprocessor constructs: #ifdef, #ifndef, #else, #endif void ADLParser::skipws_common(bool do_preproc) { char *start = _ptr; char *next = _ptr + 1; if (*_ptr == '\0') { // Check for string terminator if (_curchar > ' ') return; if (_curchar == '\n') { if (!do_preproc) return; // let caller handle the newline next_line(); _ptr = _curline; next = _ptr + 1; } else if (_curchar == '#' || (_curchar == '/' && (*next == '/' || *next == '*'))) { parse_err(SYNERR, "unimplemented: comment token in a funny place"); } } while(_curline != NULL) { // Check for end of file if (*_ptr == '\n') { // keep proper track of new lines if (!do_preproc) break; // let caller handle the newline next_line(); _ptr = _curline; next = _ptr + 1; } else if ((*_ptr == '/') && (*next == '/')) // C++ comment do { _ptr++; next++; } while(*_ptr != '\n'); // So go to end of line else if ((*_ptr == '/') && (*next == '*')) { // C comment _ptr++; next++; do { _ptr++; next++; if (*_ptr == '\n') { // keep proper track of new lines next_line(); // skip newlines within comments if (_curline == NULL) { // check for end of file parse_err(SYNERR, "end-of-file detected inside comment\n"); break; } _ptr = _curline; next = _ptr + 1; } } while(!((*_ptr == '*') && (*next == '/'))); // Go to end of comment _ptr = ++next; next++; // increment _ptr past comment end } else if (do_preproc && *_ptr == '#') { // Note that this calls skipws_common(false) recursively! bool preproc_handled = handle_preproc_token(); if (!preproc_handled) { if (preproc_taken()) { return; // short circuit } ++_ptr; // skip the preprocessor character } next = _ptr+1; } else if(*_ptr > ' ' && !(do_preproc && !preproc_taken())) { break; } else if (*_ptr == '"' || *_ptr == '\'') { assert(do_preproc, "only skip strings if doing preproc"); // skip untaken quoted string int qchar = *_ptr; while (true) { ++_ptr; if (*_ptr == qchar) { ++_ptr; break; } if (*_ptr == '\\') ++_ptr; if (*_ptr == '\n' || *_ptr == '\0') { parse_err(SYNERR, "newline in string"); break; } } next = _ptr + 1; } else { ++_ptr; ++next; } } if( _curline != NULL ) // at end of file _curchar isn't valid _curchar = *_ptr; // reset _curchar to maintain invariant } //---------------------------cur_char----------------------------------------- char ADLParser::cur_char() { return (_curchar); } //---------------------------next_char----------------------------------------- void ADLParser::next_char() { if (_curchar == '\n') parse_err(WARN, "must call next_line!"); _curchar = *++_ptr; // if ( _curchar == '\n' ) { // next_line(); // } } //---------------------------next_char_or_line--------------------------------- void ADLParser::next_char_or_line() { if ( _curchar != '\n' ) { _curchar = *++_ptr; } else { next_line(); _ptr = _curline; _curchar = *_ptr; // maintain invariant } } //---------------------------next_line----------------------------------------- void ADLParser::next_line() { _curline = _buf.get_line(); _curchar = ' '; } //------------------------get_line_string-------------------------------------- // Prepended location descriptor, for debugging. // Must return a malloced string (that can be freed if desired). char* ADLParser::get_line_string(int linenum) { const char* file = _AD._ADL_file._name; int line = linenum ? linenum : this->linenum(); char* location = (char *)malloc(strlen(file) + 100); sprintf(location, "\n#line %d \"%s\"\n", line, file); return location; } //-------------------------is_literal_constant--------------------------------- bool ADLParser::is_literal_constant(const char *param) { if (param[0] == 0) return false; // null string if (param[0] == '(') return true; // parenthesized expression if (param[0] == '0' && (param[1] == 'x' || param[1] == 'X')) { // Make sure it's a hex constant. int i = 2; do { if( !ADLParser::is_hex_digit(*(param+i)) ) return false; ++i; } while( *(param+i) != 0 ); return true; } return false; } //---------------------------is_hex_digit-------------------------------------- bool ADLParser::is_hex_digit(char digit) { return ((digit >= '0') && (digit <= '9')) ||((digit >= 'a') && (digit <= 'f')) ||((digit >= 'A') && (digit <= 'F')); } //---------------------------is_int_token-------------------------------------- bool ADLParser::is_int_token(const char* token, int& intval) { const char* cp = token; while (*cp != '\0' && *cp <= ' ') cp++; if (*cp == '-') cp++; int ndigit = 0; while (*cp >= '0' && *cp <= '9') { cp++; ndigit++; } while (*cp != '\0' && *cp <= ' ') cp++; if (ndigit == 0 || *cp != '\0') { return false; } intval = atoi(token); return true; } static const char* skip_expr_ws(const char* str) { const char * cp = str; while (cp[0]) { if (cp[0] <= ' ') { ++cp; } else if (cp[0] == '#') { ++cp; while (cp[0] == ' ') ++cp; assert(0 == strncmp(cp, "line", 4), "must be a #line directive"); const char* eol = strchr(cp, '\n'); assert(eol != NULL, "must find end of line"); if (eol == NULL) eol = cp + strlen(cp); cp = eol; } else { break; } } return cp; } //-----------------------equivalent_expressions-------------------------------- bool ADLParser::equivalent_expressions(const char* str1, const char* str2) { if (str1 == str2) return true; else if (str1 == NULL || str2 == NULL) return false; const char* cp1 = str1; const char* cp2 = str2; char in_quote = '\0'; while (cp1[0] && cp2[0]) { if (!in_quote) { // skip spaces and/or cpp directives const char* cp1a = skip_expr_ws(cp1); const char* cp2a = skip_expr_ws(cp2); if (cp1a > cp1 && cp2a > cp2) { cp1 = cp1a; cp2 = cp2a; continue; } if (cp1a > cp1 || cp2a > cp2) break; // fail } // match one non-space char if (cp1[0] != cp2[0]) break; // fail char ch = cp1[0]; cp1++; cp2++; // watch for quotes if (in_quote && ch == '\\') { if (cp1[0] != cp2[0]) break; // fail if (!cp1[0]) break; cp1++; cp2++; } if (in_quote && ch == in_quote) { in_quote = '\0'; } else if (!in_quote && (ch == '"' || ch == '\'')) { in_quote = ch; } } return (!cp1[0] && !cp2[0]); } //-------------------------------trim------------------------------------------ void ADLParser::trim(char* &token) { while (*token <= ' ') token++; char* end = token + strlen(token); while (end > token && *(end-1) <= ' ') --end; *end = '\0'; }