/*

 * Copyright (c) 1998, 2012, 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.

 *

 */

// output_c.cpp - Class CPP file output routines for architecture definition

#include "adlc.hpp"

// Utilities to characterize effect statements

static bool is_def(int usedef) {

  switch(usedef) {

  case Component::DEF:

  case Component::USE_DEF: return true; break;

  }

  return false;

}

static bool is_use(int usedef) {

  switch(usedef) {

  case Component::USE:

  case Component::USE_DEF:

  case Component::USE_KILL: return true; break;

  }

  return false;

}

static bool is_kill(int usedef) {

  switch(usedef) {

  case Component::KILL:

  case Component::USE_KILL: return true; break;

  }

  return false;

}

// Define  an array containing the machine register names, strings.

static void defineRegNames(FILE *fp, RegisterForm *registers) {

  if (registers) {

    fprintf(fp,"\n");

    fprintf(fp,"// An array of character pointers to machine register names.\n");

    fprintf(fp,"const char *Matcher::regName[REG_COUNT] = {\n");

    // Output the register name for each register in the allocation classes

    RegDef *reg_def = NULL;

    RegDef *next = NULL;

    registers->reset_RegDefs();

    for( reg_def = registers->iter_RegDefs(); reg_def != NULL; reg_def = next ) {

      next = registers->iter_RegDefs();

      const char *comma = (next != NULL) ? "," : " // no trailing comma";

      fprintf(fp,"  \"%s\"%s\n",

                 reg_def->_regname, comma );

    }

    // Finish defining enumeration

    fprintf(fp,"};\n");

    fprintf(fp,"\n");

    fprintf(fp,"// An array of character pointers to machine register names.\n");

    fprintf(fp,"const VMReg OptoReg::opto2vm[REG_COUNT] = {\n");

    reg_def = NULL;

    next = NULL;

    registers->reset_RegDefs();

    for( reg_def = registers->iter_RegDefs(); reg_def != NULL; reg_def = next ) {

      next = registers->iter_RegDefs();

      const char *comma = (next != NULL) ? "," : " // no trailing comma";

      fprintf(fp,"\t%s%s\n", reg_def->_concrete, comma );

    }

    // Finish defining array

    fprintf(fp,"\t};\n");

    fprintf(fp,"\n");

    fprintf(fp," OptoReg::Name OptoReg::vm2opto[ConcreteRegisterImpl::number_of_registers];\n");

  }

}

// Define an array containing the machine register encoding values

static void defineRegEncodes(FILE *fp, RegisterForm *registers) {

  if (registers) {

    fprintf(fp,"\n");

    fprintf(fp,"// An array of the machine register encode values\n");

    fprintf(fp,"const unsigned char Matcher::_regEncode[REG_COUNT] = {\n");

    // Output the register encoding for each register in the allocation classes

    RegDef *reg_def = NULL;

    RegDef *next    = NULL;

    registers->reset_RegDefs();

    for( reg_def = registers->iter_RegDefs(); reg_def != NULL; reg_def = next ) {

      next = registers->iter_RegDefs();

      const char* register_encode = reg_def->register_encode();

      const char *comma = (next != NULL) ? "," : " // no trailing comma";

      int encval;

      if (!ADLParser::is_int_token(register_encode, encval)) {

        fprintf(fp,"  %s%s  // %s\n",

                register_encode, comma, reg_def->_regname );

      } else {

        // Output known constants in hex char format (backward compatibility).

        assert(encval < 256, "Exceeded supported width for register encoding");

        fprintf(fp,"  (unsigned char)'\\x%X'%s  // %s\n",

                encval,          comma, reg_def->_regname );

      }

    }

    // Finish defining enumeration

    fprintf(fp,"};\n");

  } // Done defining array

}

// Output an enumeration of register class names

static void defineRegClassEnum(FILE *fp, RegisterForm *registers) {

  if (registers) {

    // Output an enumeration of register class names

    fprintf(fp,"\n");

    fprintf(fp,"// Enumeration of register class names\n");

    fprintf(fp, "enum machRegisterClass {\n");

    registers->_rclasses.reset();

    for( const char *class_name = NULL;

         (class_name = registers->_rclasses.iter()) != NULL; ) {

      fprintf(fp,"  %s,\n", toUpper( class_name ));

    }

    // Finish defining enumeration

    fprintf(fp, "  _last_Mach_Reg_Class\n");

    fprintf(fp, "};\n");

  }

}

// Declare an enumeration of user-defined register classes

// and a list of register masks, one for each class.

void ArchDesc::declare_register_masks(FILE *fp_hpp) {

  const char  *rc_name;

  if( _register ) {

    // Build enumeration of user-defined register classes.

    defineRegClassEnum(fp_hpp, _register);

    // Generate a list of register masks, one for each class.

    fprintf(fp_hpp,"\n");

    fprintf(fp_hpp,"// Register masks, one for each register class.\n");

    _register->_rclasses.reset();

    for( rc_name = NULL;

         (rc_name = _register->_rclasses.iter()) != NULL; ) {

      const char *prefix    = "";

      RegClass   *reg_class = _register->getRegClass(rc_name);

      assert( reg_class, "Using an undefined register class");

      if (reg_class->_user_defined == NULL) {

        fprintf(fp_hpp, "extern const RegMask _%s%s_mask;\n", prefix, toUpper( rc_name ) );

        fprintf(fp_hpp, "inline const RegMask &%s%s_mask() { return _%s%s_mask; }\n", prefix, toUpper( rc_name ), prefix, toUpper( rc_name ));

      } else {

        fprintf(fp_hpp, "inline const RegMask &%s%s_mask() { %s }\n", prefix, toUpper( rc_name ), reg_class->_user_defined);

      }

      if( reg_class->_stack_or_reg ) {

        assert(reg_class->_user_defined == NULL, "no user defined reg class here");

        fprintf(fp_hpp, "extern const RegMask _%sSTACK_OR_%s_mask;\n", prefix, toUpper( rc_name ) );

        fprintf(fp_hpp, "inline const RegMask &%sSTACK_OR_%s_mask() { return _%sSTACK_OR_%s_mask; }\n", prefix, toUpper( rc_name ), prefix, toUpper( rc_name ) );

      }

    }

  }

}

// Generate an enumeration of user-defined register classes

// and a list of register masks, one for each class.

void ArchDesc::build_register_masks(FILE *fp_cpp) {

  const char  *rc_name;

  if( _register ) {

    // Generate a list of register masks, one for each class.

    fprintf(fp_cpp,"\n");

    fprintf(fp_cpp,"// Register masks, one for each register class.\n");

    _register->_rclasses.reset();

    for( rc_name = NULL;

         (rc_name = _register->_rclasses.iter()) != NULL; ) {

      const char *prefix    = "";

      RegClass   *reg_class = _register->getRegClass(rc_name);

      assert( reg_class, "Using an undefined register class");

      if (reg_class->_user_defined != NULL) continue;

      int len = RegisterForm::RegMask_Size();

      fprintf(fp_cpp, "const RegMask _%s%s_mask(", prefix, toUpper( rc_name ) );

      { int i;

        for( i = 0; i < len-1; i++ )

          fprintf(fp_cpp," 0x%x,",reg_class->regs_in_word(i,false));

        fprintf(fp_cpp," 0x%x );\n",reg_class->regs_in_word(i,false));

      }

      if( reg_class->_stack_or_reg ) {

        int i;

        fprintf(fp_cpp, "const RegMask _%sSTACK_OR_%s_mask(", prefix, toUpper( rc_name ) );

        for( i = 0; i < len-1; i++ )

          fprintf(fp_cpp," 0x%x,",reg_class->regs_in_word(i,true));

        fprintf(fp_cpp," 0x%x );\n",reg_class->regs_in_word(i,true));

      }

    }

  }

}

// Compute an index for an array in the pipeline_reads_NNN arrays

static int pipeline_reads_initializer(FILE *fp_cpp, NameList &pipeline_reads, PipeClassForm *pipeclass)

{

  int templen = 1;

  int paramcount = 0;

  const char *paramname;

  if (pipeclass->_parameters.count() == 0)

    return -1;

  pipeclass->_parameters.reset();

  paramname = pipeclass->_parameters.iter();

  const PipeClassOperandForm *pipeopnd =

    (const PipeClassOperandForm *)pipeclass->_localUsage[paramname];

  if (pipeopnd && !pipeopnd->isWrite() && strcmp(pipeopnd->_stage, "Universal"))

    pipeclass->_parameters.reset();

  while ( (paramname = pipeclass->_parameters.iter()) != NULL ) {

    const PipeClassOperandForm *tmppipeopnd =

        (const PipeClassOperandForm *)pipeclass->_localUsage[paramname];

    if (tmppipeopnd)

      templen += 10 + (int)strlen(tmppipeopnd->_stage);

    else

      templen += 19;

    paramcount++;

  }

  // See if the count is zero

  if (paramcount == 0) {

    return -1;

  }

  char *operand_stages = new char [templen];

  operand_stages[0] = 0;

  int i = 0;

  templen = 0;

  pipeclass->_parameters.reset();

  paramname = pipeclass->_parameters.iter();

  pipeopnd = (const PipeClassOperandForm *)pipeclass->_localUsage[paramname];

  if (pipeopnd && !pipeopnd->isWrite() && strcmp(pipeopnd->_stage, "Universal"))

    pipeclass->_parameters.reset();

  while ( (paramname = pipeclass->_parameters.iter()) != NULL ) {

    const PipeClassOperandForm *tmppipeopnd =

        (const PipeClassOperandForm *)pipeclass->_localUsage[paramname];

    templen += sprintf(&operand_stages[templen], "  stage_%s%c\n",

      tmppipeopnd ? tmppipeopnd->_stage : "undefined",

      (++i < paramcount ? ',' : ' ') );

  }

  // See if the same string is in the table

  int ndx = pipeline_reads.index(operand_stages);

  // No, add it to the table

  if (ndx < 0) {

    pipeline_reads.addName(operand_stages);

    ndx = pipeline_reads.index(operand_stages);

    fprintf(fp_cpp, "static const enum machPipelineStages pipeline_reads_%03d[%d] = {\n%s};\n\n",

      ndx+1, paramcount, operand_stages);

  }

  else

    delete [] operand_stages;

  return (ndx);

}

// Compute an index for an array in the pipeline_res_stages_NNN arrays

static int pipeline_res_stages_initializer(

  FILE *fp_cpp,

  PipelineForm *pipeline,

  NameList &pipeline_res_stages,

  PipeClassForm *pipeclass)

{

  const PipeClassResourceForm *piperesource;

  int * res_stages = new int [pipeline->_rescount];

  int i;

  for (i = 0; i < pipeline->_rescount; i++)

     res_stages[i] = 0;

  for (pipeclass->_resUsage.reset();

       (piperesource = (const PipeClassResourceForm *)pipeclass->_resUsage.iter()) != NULL; ) {

    int used_mask = pipeline->_resdict[piperesource->_resource]->is_resource()->mask();

    for (i = 0; i < pipeline->_rescount; i++)

      if ((1 << i) & used_mask) {

        int stage = pipeline->_stages.index(piperesource->_stage);

        if (res_stages[i] < stage+1)

          res_stages[i] = stage+1;

      }

  }

  // Compute the length needed for the resource list

  int commentlen = 0;

  int max_stage = 0;

  for (i = 0; i < pipeline->_rescount; i++) {

    if (res_stages[i] == 0) {

      if (max_stage < 9)

        max_stage = 9;

    }

    else {

      int stagelen = (int)strlen(pipeline->_stages.name(res_stages[i]-1));

      if (max_stage < stagelen)

        max_stage = stagelen;

    }

    commentlen += (int)strlen(pipeline->_reslist.name(i));

  }

  int templen = 1 + commentlen + pipeline->_rescount * (max_stage + 14);

  // Allocate space for the resource list

  char * resource_stages = new char [templen];

  templen = 0;

  for (i = 0; i < pipeline->_rescount; i++) {

    const char * const resname =

      res_stages[i] == 0 ? "undefined" : pipeline->_stages.name(res_stages[i]-1);

    templen += sprintf(&resource_stages[templen], "  stage_%s%-*s // %s\n",

      resname, max_stage - (int)strlen(resname) + 1,

      (i < pipeline->_rescount-1) ? "," : "",

      pipeline->_reslist.name(i));

  }

  // See if the same string is in the table

  int ndx = pipeline_res_stages.index(resource_stages);

  // No, add it to the table

  if (ndx < 0) {

    pipeline_res_stages.addName(resource_stages);

    ndx = pipeline_res_stages.index(resource_stages);

    fprintf(fp_cpp, "static const enum machPipelineStages pipeline_res_stages_%03d[%d] = {\n%s};\n\n",

      ndx+1, pipeline->_rescount, resource_stages);

  }

  else

    delete [] resource_stages;

  delete [] res_stages;

  return (ndx);

}

// Compute an index for an array in the pipeline_res_cycles_NNN arrays

static int pipeline_res_cycles_initializer(

  FILE *fp_cpp,

  PipelineForm *pipeline,

  NameList &pipeline_res_cycles,

  PipeClassForm *pipeclass)

{

  const PipeClassResourceForm *piperesource;

  int * res_cycles = new int [pipeline->_rescount];

  int i;

  for (i = 0; i < pipeline->_rescount; i++)

     res_cycles[i] = 0;

  for (pipeclass->_resUsage.reset();

       (piperesource = (const PipeClassResourceForm *)pipeclass->_resUsage.iter()) != NULL; ) {

    int used_mask = pipeline->_resdict[piperesource->_resource]->is_resource()->mask();

    for (i = 0; i < pipeline->_rescount; i++)

      if ((1 << i) & used_mask) {

        int cycles = piperesource->_cycles;

        if (res_cycles[i] < cycles)

          res_cycles[i] = cycles;

      }

  }

  // Pre-compute the string length

  int templen;

  int cyclelen = 0, commentlen = 0;

  int max_cycles = 0;

  char temp[32];

  for (i = 0; i < pipeline->_rescount; i++) {

    if (max_cycles < res_cycles[i])

      max_cycles = res_cycles[i];

    templen = sprintf(temp, "%d", res_cycles[i]);

    if (cyclelen < templen)

      cyclelen = templen;

    commentlen += (int)strlen(pipeline->_reslist.name(i));

  }

  templen = 1 + commentlen + (cyclelen + 8) * pipeline->_rescount;

  // Allocate space for the resource list

  char * resource_cycles = new char [templen];

  templen = 0;

  for (i = 0; i < pipeline->_rescount; i++) {

    templen += sprintf(&resource_cycles[templen], "  %*d%c // %s\n",

      cyclelen, res_cycles[i], (i < pipeline->_rescount-1) ? ',' : ' ', pipeline->_reslist.name(i));

  }

  // See if the same string is in the table

  int ndx = pipeline_res_cycles.index(resource_cycles);

  // No, add it to the table

  if (ndx < 0) {

    pipeline_res_cycles.addName(resource_cycles);

    ndx = pipeline_res_cycles.index(resource_cycles);

    fprintf(fp_cpp, "static const uint pipeline_res_cycles_%03d[%d] = {\n%s};\n\n",

      ndx+1, pipeline->_rescount, resource_cycles);

  }

  else

    delete [] resource_cycles;

  delete [] res_cycles;

  return (ndx);

}

//typedef unsigned long long uint64_t;

// Compute an index for an array in the pipeline_res_mask_NNN arrays

static int pipeline_res_mask_initializer(

  FILE *fp_cpp,

  PipelineForm *pipeline,

  NameList &pipeline_res_mask,

  NameList &pipeline_res_args,

  PipeClassForm *pipeclass)

{

  const PipeClassResourceForm *piperesource;

  const uint rescount      = pipeline->_rescount;

  const uint maxcycleused  = pipeline->_maxcycleused;

  const uint cyclemasksize = (maxcycleused + 31) >> 5;

  int i, j;

  int element_count = 0;

  uint *res_mask = new uint [cyclemasksize];

  uint resources_used             = 0;

  uint resources_used_exclusively = 0;

  for (pipeclass->_resUsage.reset();

       (piperesource = (const PipeClassResourceForm *)pipeclass->_resUsage.iter()) != NULL; )

    element_count++;

  // Pre-compute the string length

  int templen;

  int commentlen = 0;

  int max_cycles = 0;

  int cyclelen = ((maxcycleused + 3) >> 2);

  int masklen = (rescount + 3) >> 2;

  int cycledigit = 0;

  for (i = maxcycleused; i > 0; i /= 10)

    cycledigit++;

  int maskdigit = 0;

  for (i = rescount; i > 0; i /= 10)

    maskdigit++;

  static const char * pipeline_use_cycle_mask = "Pipeline_Use_Cycle_Mask";

  static const char * pipeline_use_element    = "Pipeline_Use_Element";

  templen = 1 +

    (int)(strlen(pipeline_use_cycle_mask) + (int)strlen(pipeline_use_element) +

     (cyclemasksize * 12) + masklen + (cycledigit * 2) + 30) * element_count;

  // Allocate space for the resource list

  char * resource_mask = new char [templen];

  char * last_comma = NULL;

  templen = 0;

  for (pipeclass->_resUsage.reset();

       (piperesource = (const PipeClassResourceForm *)pipeclass->_resUsage.iter()) != NULL; ) {

    int used_mask = pipeline->_resdict[piperesource->_resource]->is_resource()->mask();

    if (!used_mask)

      fprintf(stderr, "*** used_mask is 0 ***\n");

    resources_used |= used_mask;

    uint lb, ub;

    for (lb =  0; (used_mask & (1 << lb)) == 0; lb++);

    for (ub = 31; (used_mask & (1 << ub)) == 0; ub--);

    if (lb == ub)

      resources_used_exclusively |= used_mask;

    int formatlen =

      sprintf(&resource_mask[templen], "  %s(0x%0*x, %*d, %*d, %s %s(",

        pipeline_use_element,

        masklen, used_mask,

        cycledigit, lb, cycledigit, ub,

        ((used_mask & (used_mask-1)) != 0) ? "true, " : "false,",

        pipeline_use_cycle_mask);

    templen += formatlen;

    memset(res_mask, 0, cyclemasksize * sizeof(uint));

    int cycles = piperesource->_cycles;

    uint stage          = pipeline->_stages.index(piperesource->_stage);

    if (NameList::Not_in_list == stage) {

      fprintf(stderr,

              "pipeline_res_mask_initializer: "

              "semantic error: "

              "pipeline stage undeclared: %s\n",