/*

 * 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_h.cpp - Class HPP file output routines for architecture definition

#include "adlc.hpp"

// The comment delimiter used in format statements after assembler instructions.

#define commentSeperator "!"

// Generate the #define that describes the number of registers.

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

  if (registers) {

    int regCount =  AdlcVMDeps::Physical + registers->_rdefs.count();

    fprintf(fp,"\n");

    fprintf(fp,"// the number of reserved registers + machine registers.\n");

    fprintf(fp,"#define REG_COUNT    %d\n", regCount);

  }

}

// Output enumeration of machine register numbers

// (1)

// // Enumerate machine registers starting after reserved regs.

// // in the order of occurrence in the register block.

// enum MachRegisterNumbers {

//   EAX_num = 0,

//   ...

//   _last_Mach_Reg

// }

void ArchDesc::buildMachRegisterNumbers(FILE *fp_hpp) {

  if (_register) {

    RegDef *reg_def = NULL;

    // Output a #define for the number of machine registers

    defineRegCount(fp_hpp, _register);

    // Count all the Save_On_Entry and Always_Save registers

    int    saved_on_entry = 0;

    int  c_saved_on_entry = 0;

    _register->reset_RegDefs();

    while( (reg_def = _register->iter_RegDefs()) != NULL ) {

      if( strcmp(reg_def->_callconv,"SOE") == 0 ||

          strcmp(reg_def->_callconv,"AS")  == 0 )  ++saved_on_entry;

      if( strcmp(reg_def->_c_conv,"SOE") == 0 ||

          strcmp(reg_def->_c_conv,"AS")  == 0 )  ++c_saved_on_entry;

    }

    fprintf(fp_hpp, "\n");

    fprintf(fp_hpp, "// the number of save_on_entry + always_saved registers.\n");

    fprintf(fp_hpp, "#define MAX_SAVED_ON_ENTRY_REG_COUNT    %d\n",   max(saved_on_entry,c_saved_on_entry));

    fprintf(fp_hpp, "#define     SAVED_ON_ENTRY_REG_COUNT    %d\n",   saved_on_entry);

    fprintf(fp_hpp, "#define   C_SAVED_ON_ENTRY_REG_COUNT    %d\n", c_saved_on_entry);

    // (1)

    // Build definition for enumeration of register numbers

    fprintf(fp_hpp, "\n");

    fprintf(fp_hpp, "// Enumerate machine register numbers starting after reserved regs.\n");

    fprintf(fp_hpp, "// in the order of occurrence in the register block.\n");

    fprintf(fp_hpp, "enum MachRegisterNumbers {\n");

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

    _register->reset_RegDefs();

    int i = 0;

    while( (reg_def = _register->iter_RegDefs()) != NULL ) {

      fprintf(fp_hpp,"  %s_num,", reg_def->_regname);

      for (int j = 0; j < 20-(int)strlen(reg_def->_regname); j++) fprintf(fp_hpp, " ");

      fprintf(fp_hpp," // enum %3d, regnum %3d, reg encode %3s\n",

              i++,

              reg_def->register_num(),

              reg_def->register_encode());

    }

    // Finish defining enumeration

    fprintf(fp_hpp, "  _last_Mach_Reg            // %d\n", i);

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

  }

  fprintf(fp_hpp, "\n// Size of register-mask in ints\n");

  fprintf(fp_hpp, "#define RM_SIZE %d\n",RegisterForm::RegMask_Size());

  fprintf(fp_hpp, "// Unroll factor for loops over the data in a RegMask\n");

  fprintf(fp_hpp, "#define FORALL_BODY ");

  int len = RegisterForm::RegMask_Size();

  for( int i = 0; i < len; i++ )

    fprintf(fp_hpp, "BODY(%d) ",i);

  fprintf(fp_hpp, "\n\n");

  fprintf(fp_hpp,"class RegMask;\n");

  // All RegMasks are declared "extern const ..." in ad_<arch>.hpp

  // fprintf(fp_hpp,"extern RegMask STACK_OR_STACK_SLOTS_mask;\n\n");

}

// Output enumeration of machine register encodings

// (2)

// // Enumerate machine registers starting after reserved regs.

// // in the order of occurrence in the alloc_class(es).

// enum MachRegisterEncodes {

//   EAX_enc = 0x00,

//   ...

// }

void ArchDesc::buildMachRegisterEncodes(FILE *fp_hpp) {

  if (_register) {

    RegDef *reg_def = NULL;

    RegDef *reg_def_next = NULL;

    // (2)

    // Build definition for enumeration of encode values

    fprintf(fp_hpp, "\n");

    fprintf(fp_hpp, "// Enumerate machine registers starting after reserved regs.\n");

    fprintf(fp_hpp, "// in the order of occurrence in the alloc_class(es).\n");

    fprintf(fp_hpp, "enum MachRegisterEncodes {\n");

    // Find max enum string length.

    size_t maxlen = 0;

    _register->reset_RegDefs();

    reg_def = _register->iter_RegDefs();

    while (reg_def != NULL) {

      size_t len = strlen(reg_def->_regname);

      if (len > maxlen) maxlen = len;

      reg_def = _register->iter_RegDefs();

    }

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

    _register->reset_RegDefs();

    reg_def_next = _register->iter_RegDefs();

    while( (reg_def = reg_def_next) != NULL ) {

      reg_def_next = _register->iter_RegDefs();

      fprintf(fp_hpp,"  %s_enc", reg_def->_regname);

      for (size_t i = strlen(reg_def->_regname); i < maxlen; i++) fprintf(fp_hpp, " ");

      fprintf(fp_hpp," = %3s%s\n", reg_def->register_encode(), reg_def_next == NULL? "" : "," );

    }

    // Finish defining enumeration

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

  } // Done with register form

}

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

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

  if (registers) {

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

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

//    fprintf(fp,"extern const char *regName[];\n");

  }

}

// Declare an array containing the machine register sizes in 32-bit words.

void ArchDesc::declareRegSizes(FILE *fp) {

// regSize[] is not used

}

// Declare an array containing the machine register encoding values

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

  if (registers) {

    // // //

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

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

    // fprintf(fp,"extern const char  regEncode[];\n");

  }

}

// ---------------------------------------------------------------------------

//------------------------------Utilities to build Instruction Classes--------

// ---------------------------------------------------------------------------

static void out_RegMask(FILE *fp) {

  fprintf(fp,"  virtual const RegMask &out_RegMask() const;\n");

}

// ---------------------------------------------------------------------------

//--------Utilities to build MachOper and MachNode derived Classes------------

// ---------------------------------------------------------------------------

//------------------------------Utilities to build Operand Classes------------

static void in_RegMask(FILE *fp) {

  fprintf(fp,"  virtual const RegMask *in_RegMask(int index) const;\n");

}

static void declareConstStorage(FILE *fp, FormDict &globals, OperandForm *oper) {

  int i = 0;

  Component *comp;

  if (oper->num_consts(globals) == 0) return;

  // Iterate over the component list looking for constants

  oper->_components.reset();

  if ((comp = oper->_components.iter()) == NULL) {

    assert(oper->num_consts(globals) == 1, "Bad component list detected.\n");

    const char *type = oper->ideal_type(globals);

    if (!strcmp(type, "ConI")) {

      if (i > 0) fprintf(fp,", ");

      fprintf(fp,"  int32          _c%d;\n", i);

    }

    else if (!strcmp(type, "ConP")) {

      if (i > 0) fprintf(fp,", ");

      fprintf(fp,"  const TypePtr *_c%d;\n", i);

    }

    else if (!strcmp(type, "ConN")) {

      if (i > 0) fprintf(fp,", ");

      fprintf(fp,"  const TypeNarrowOop *_c%d;\n", i);

    }

    else if (!strcmp(type, "ConNKlass")) {

      if (i > 0) fprintf(fp,", ");

      fprintf(fp,"  const TypeNarrowKlass *_c%d;\n", i);

    }

    else if (!strcmp(type, "ConL")) {

      if (i > 0) fprintf(fp,", ");

      fprintf(fp,"  jlong          _c%d;\n", i);

    }

    else if (!strcmp(type, "ConF")) {

      if (i > 0) fprintf(fp,", ");

      fprintf(fp,"  jfloat         _c%d;\n", i);

    }

    else if (!strcmp(type, "ConD")) {

      if (i > 0) fprintf(fp,", ");

      fprintf(fp,"  jdouble        _c%d;\n", i);

    }

    else if (!strcmp(type, "Bool")) {

      fprintf(fp,"private:\n");

      fprintf(fp,"  BoolTest::mask _c%d;\n", i);

      fprintf(fp,"public:\n");

    }

    else {

      assert(0, "Non-constant operand lacks component list.");

    }

  } // end if NULL

  else {

    oper->_components.reset();

    while ((comp = oper->_components.iter()) != NULL) {

      if (!strcmp(comp->base_type(globals), "ConI")) {

        fprintf(fp,"  jint             _c%d;\n", i);

        i++;

      }

      else if (!strcmp(comp->base_type(globals), "ConP")) {

        fprintf(fp,"  const TypePtr *_c%d;\n", i);

        i++;

      }

      else if (!strcmp(comp->base_type(globals), "ConN")) {

        fprintf(fp,"  const TypePtr *_c%d;\n", i);

        i++;

      }

      else if (!strcmp(comp->base_type(globals), "ConNKlass")) {

        fprintf(fp,"  const TypePtr *_c%d;\n", i);

        i++;

      }

      else if (!strcmp(comp->base_type(globals), "ConL")) {

        fprintf(fp,"  jlong            _c%d;\n", i);

        i++;

      }

      else if (!strcmp(comp->base_type(globals), "ConF")) {

        fprintf(fp,"  jfloat           _c%d;\n", i);

        i++;

      }

      else if (!strcmp(comp->base_type(globals), "ConD")) {

        fprintf(fp,"  jdouble          _c%d;\n", i);

        i++;

      }

    }

  }

}

// Declare constructor.

// Parameters start with condition code, then all other constants

//

// (0) public:

// (1)  MachXOper(int32 ccode, int32 c0, int32 c1, ..., int32 cn)

// (2)     : _ccode(ccode), _c0(c0), _c1(c1), ..., _cn(cn) { }

//

static void defineConstructor(FILE *fp, const char *name, uint num_consts,

                              ComponentList &lst, bool is_ideal_bool,

                              Form::DataType constant_type, FormDict &globals) {

  fprintf(fp,"public:\n");

  // generate line (1)

  fprintf(fp,"  %sOper(", name);

  if( num_consts == 0 ) {

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

    return;

  }

  // generate parameters for constants

  uint i = 0;

  Component *comp;

  lst.reset();

  if ((comp = lst.iter()) == NULL) {

    assert(num_consts == 1, "Bad component list detected.\n");

    switch( constant_type ) {

    case Form::idealI : {

      fprintf(fp,is_ideal_bool ? "BoolTest::mask c%d" : "int32 c%d", i);

      break;

    }

    case Form::idealN :      { fprintf(fp,"const TypeNarrowOop *c%d", i); break; }

    case Form::idealNKlass : { fprintf(fp,"const TypeNarrowKlass *c%d", i); break; }

    case Form::idealP :      { fprintf(fp,"const TypePtr *c%d", i); break; }

    case Form::idealL :      { fprintf(fp,"jlong c%d", i);   break;        }

    case Form::idealF :      { fprintf(fp,"jfloat c%d", i);  break;        }

    case Form::idealD :      { fprintf(fp,"jdouble c%d", i); break;        }

    default:

      assert(!is_ideal_bool, "Non-constant operand lacks component list.");

      break;

    }

  } // end if NULL

  else {

    lst.reset();

    while((comp = lst.iter()) != NULL) {

      if (!strcmp(comp->base_type(globals), "ConI")) {

        if (i > 0) fprintf(fp,", ");

        fprintf(fp,"int32 c%d", i);

        i++;

      }

      else if (!strcmp(comp->base_type(globals), "ConP")) {

        if (i > 0) fprintf(fp,", ");

        fprintf(fp,"const TypePtr *c%d", i);

        i++;

      }

      else if (!strcmp(comp->base_type(globals), "ConN")) {

        if (i > 0) fprintf(fp,", ");

        fprintf(fp,"const TypePtr *c%d", i);

        i++;

      }

      else if (!strcmp(comp->base_type(globals), "ConNKlass")) {

        if (i > 0) fprintf(fp,", ");

        fprintf(fp,"const TypePtr *c%d", i);

        i++;

      }

      else if (!strcmp(comp->base_type(globals), "ConL")) {

        if (i > 0) fprintf(fp,", ");

        fprintf(fp,"jlong c%d", i);

        i++;

      }

      else if (!strcmp(comp->base_type(globals), "ConF")) {

        if (i > 0) fprintf(fp,", ");

        fprintf(fp,"jfloat c%d", i);

        i++;

      }

      else if (!strcmp(comp->base_type(globals), "ConD")) {

        if (i > 0) fprintf(fp,", ");

        fprintf(fp,"jdouble c%d", i);

        i++;

      }

      else if (!strcmp(comp->base_type(globals), "Bool")) {

        if (i > 0) fprintf(fp,", ");

        fprintf(fp,"BoolTest::mask c%d", i);

        i++;

      }

    }

  }

  // finish line (1) and start line (2)

  fprintf(fp,")  : ");

  // generate initializers for constants

  i = 0;

  fprintf(fp,"_c%d(c%d)", i, i);

  for( i = 1; i < num_consts; ++i) {

    fprintf(fp,", _c%d(c%d)", i, i);

  }

  // The body for the constructor is empty

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

}

// ---------------------------------------------------------------------------

// Utilities to generate format rules for machine operands and instructions

// ---------------------------------------------------------------------------

// Generate the format rule for condition codes

static void defineCCodeDump(OperandForm* oper, FILE *fp, int i) {

  assert(oper != NULL, "what");

  CondInterface* cond = oper->_interface->is_CondInterface();

  fprintf(fp, "       if( _c%d == BoolTest::eq ) st->print(\"%s\");\n",i,cond->_equal_format);

  fprintf(fp, "  else if( _c%d == BoolTest::ne ) st->print(\"%s\");\n",i,cond->_not_equal_format);

  fprintf(fp, "  else if( _c%d == BoolTest::le ) st->print(\"%s\");\n",i,cond->_less_equal_format);

  fprintf(fp, "  else if( _c%d == BoolTest::ge ) st->print(\"%s\");\n",i,cond->_greater_equal_format);

  fprintf(fp, "  else if( _c%d == BoolTest::lt ) st->print(\"%s\");\n",i,cond->_less_format);

  fprintf(fp, "  else if( _c%d == BoolTest::gt ) st->print(\"%s\");\n",i,cond->_greater_format);

}

// Output code that dumps constant values, increment "i" if type is constant

static uint dump_spec_constant(FILE *fp, const char *ideal_type, uint i, OperandForm* oper) {

  if (!strcmp(ideal_type, "ConI")) {

    fprintf(fp,"   st->print(\"#%%d\", _c%d);\n", i);

    fprintf(fp,"   st->print(\"/0x%%08x\", _c%d);\n", i);

    ++i;

  }

  else if (!strcmp(ideal_type, "ConP")) {

    fprintf(fp,"    _c%d->dump_on(st);\n", i);

    ++i;

  }

  else if (!strcmp(ideal_type, "ConN")) {

    fprintf(fp,"    _c%d->dump_on(st);\n", i);

    ++i;

  }

  else if (!strcmp(ideal_type, "ConNKlass")) {

    fprintf(fp,"    _c%d->dump_on(st);\n", i);

    ++i;

  }

  else if (!strcmp(ideal_type, "ConL")) {

    fprintf(fp,"    st->print(\"#\" INT64_FORMAT, _c%d);\n", i);

    fprintf(fp,"    st->print(\"/\" PTR64_FORMAT, _c%d);\n", i);

    ++i;

  }

  else if (!strcmp(ideal_type, "ConF")) {

    fprintf(fp,"    st->print(\"#%%f\", _c%d);\n", i);

    fprintf(fp,"    jint _c%di = JavaValue(_c%d).get_jint();\n", i, i);

    fprintf(fp,"    st->print(\"/0x%%x/\", _c%di);\n", i);

    ++i;

  }

  else if (!strcmp(ideal_type, "ConD")) {

    fprintf(fp,"    st->print(\"#%%f\", _c%d);\n", i);

    fprintf(fp,"    jlong _c%dl = JavaValue(_c%d).get_jlong();\n", i, i);

    fprintf(fp,"    st->print(\"/\" PTR64_FORMAT, _c%dl);\n", i);

    ++i;

  }

  else if (!strcmp(ideal_type, "Bool")) {

    defineCCodeDump(oper, fp,i);

    ++i;

  }

  return i;

}

// Generate the format rule for an operand

void gen_oper_format(FILE *fp, FormDict &globals, OperandForm &oper, bool for_c_file = false) {

  if (!for_c_file) {

    // invoked after output #ifndef PRODUCT to ad_<arch>.hpp

    // compile the bodies separately, to cut down on recompilations

    fprintf(fp,"  virtual void           int_format(PhaseRegAlloc *ra, const MachNode *node, outputStream *st) const;\n");

    fprintf(fp,"  virtual void           ext_format(PhaseRegAlloc *ra, const MachNode *node, int idx, outputStream *st) const;\n");

    return;

  }

  // Local pointer indicates remaining part of format rule

  int idx = 0;                   // position of operand in match rule

  // Generate internal format function, used when stored locally

  fprintf(fp, "\n#ifndef PRODUCT\n");

  fprintf(fp,"void %sOper::int_format(PhaseRegAlloc *ra, const MachNode *node, outputStream *st) const {\n", oper._ident);

  // Generate the user-defined portion of the format

  if (oper._format) {

    if ( oper._format->_strings.count() != 0 ) {

      // No initialization code for int_format

      // Build the format from the entries in strings and rep_vars

      const char  *string  = NULL;

      oper._format->_rep_vars.reset();

      oper._format->_strings.reset();

      while ( (string = oper._format->_strings.iter()) != NULL ) {

        // Check if this is a standard string or a replacement variable

        if ( string != NameList::_signal ) {

          // Normal string

          // Pass through to st->print

          fprintf(fp,"  st->print(\"%s\");\n", string);

        } else {

          // Replacement variable

          const char *rep_var = oper._format->_rep_vars.iter();

          // Check that it is a local name, and an operand

          const Form* form = oper._localNames[rep_var];

          if (form == NULL) {

            globalAD->syntax_err(oper._linenum,

                                 "\'%s\' not found in format for %s\n", rep_var, oper._ident);

            assert(form, "replacement variable was not found in local names");

          }

          OperandForm *op      = form->is_operand();

          // Get index if register or constant

          if ( op->_matrule && op->_matrule->is_base_register(globals) ) {

            idx  = oper.register_position( globals, rep_var);

          }

          else if (op->_matrule && op->_matrule->is_base_constant(globals)) {

            idx  = oper.constant_position( globals, rep_var);

          } else {

            idx = 0;

          }

          // output invocation of "$..."s format function

          if ( op != NULL ) op->int_format(fp, globals, idx);

          if ( idx == -1 ) {

            fprintf(stderr,

                    "Using a name, %s, that isn't in match rule\n", rep_var);

            assert( strcmp(op->_ident,"label")==0, "Unimplemented");

          }

        } // Done with a replacement variable

      } // Done with all format strings

    } else {

      // Default formats for base operands (RegI, RegP, ConI, ConP, ...)

      oper.int_format(fp, globals, 0);

    }

  } else { // oper._format == NULL

    // Provide a few special case formats where the AD writer cannot.

    if ( strcmp(oper._ident,"Universe")==0 ) {

      fprintf(fp, "  st->print(\"$$univ\");\n");

    }

    // labelOper::int_format is defined in ad_<...>.cpp

  }

  // ALWAYS! Provide a special case output for condition codes.

  if( oper.is_ideal_bool() ) {

    defineCCodeDump(&oper, fp,0);

  }

  fprintf(fp,"}\n");

  // Generate external format function, when data is stored externally

  fprintf(fp,"void %sOper::ext_format(PhaseRegAlloc *ra, const MachNode *node, int idx, outputStream *st) const {\n", oper._ident);