/*

 * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.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"))

      instr->_insencode = 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.

  }

}

//------------------------------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) ) {

        assert( instr->_predicate == NULL, "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

    }