hotspot/src/share/vm/adlc/output_h.cpp
author never
Tue, 18 May 2010 23:58:32 -0700
changeset 5536 f23c4e2e0d5e
parent 4751 9418f690831d
child 5547 f4b087cbb361
permissions -rw-r--r--
6953576: bottom_type for matched AddPNodes doesn't always agree with ideal Reviewed-by: kvn
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
4751
9418f690831d 6916644: C2 compiler crash on x86
never
parents: 3180
diff changeset
     2
 * Copyright 1998-2010 Sun Microsystems, Inc.  All Rights Reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
// output_h.cpp - Class HPP file output routines for architecture definition
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
#include "adlc.hpp"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
// Generate the #define that describes the number of registers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
static void defineRegCount(FILE *fp, RegisterForm *registers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
  if (registers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
    int regCount =  AdlcVMDeps::Physical + registers->_rdefs.count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
    fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
    fprintf(fp,"// the number of reserved registers + machine registers.\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
    fprintf(fp,"#define REG_COUNT    %d\n", regCount);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// Output enumeration of machine register numbers
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
// (1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// // Enumerate machine registers starting after reserved regs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// // in the order of occurrence in the register block.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// enum MachRegisterNumbers {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
//   EAX_num = 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
//   ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
//   _last_Mach_Reg
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
// }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
void ArchDesc::buildMachRegisterNumbers(FILE *fp_hpp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  if (_register) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
    RegDef *reg_def = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
    // Output a #define for the number of machine registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
    defineRegCount(fp_hpp, _register);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
    // Count all the Save_On_Entry and Always_Save registers
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
    int    saved_on_entry = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
    int  c_saved_on_entry = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
    _register->reset_RegDefs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
    while( (reg_def = _register->iter_RegDefs()) != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
      if( strcmp(reg_def->_callconv,"SOE") == 0 ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
          strcmp(reg_def->_callconv,"AS")  == 0 )  ++saved_on_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
      if( strcmp(reg_def->_c_conv,"SOE") == 0 ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
          strcmp(reg_def->_c_conv,"AS")  == 0 )  ++c_saved_on_entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
    fprintf(fp_hpp, "\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
    fprintf(fp_hpp, "// the number of save_on_entry + always_saved registers.\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
    fprintf(fp_hpp, "#define MAX_SAVED_ON_ENTRY_REG_COUNT    %d\n",   max(saved_on_entry,c_saved_on_entry));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
    fprintf(fp_hpp, "#define     SAVED_ON_ENTRY_REG_COUNT    %d\n",   saved_on_entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
    fprintf(fp_hpp, "#define   C_SAVED_ON_ENTRY_REG_COUNT    %d\n", c_saved_on_entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
    // (1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
    // Build definition for enumeration of register numbers
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
    fprintf(fp_hpp, "\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
    fprintf(fp_hpp, "// Enumerate machine register numbers starting after reserved regs.\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
    fprintf(fp_hpp, "// in the order of occurrence in the register block.\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
    fprintf(fp_hpp, "enum MachRegisterNumbers {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
    // Output the register number for each register in the allocation classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
    _register->reset_RegDefs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
    int i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
    while( (reg_def = _register->iter_RegDefs()) != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
      fprintf(fp_hpp,"  %s_num,\t\t// %d\n", reg_def->_regname, i++);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
    // Finish defining enumeration
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
    fprintf(fp_hpp, "  _last_Mach_Reg\t// %d\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
    fprintf(fp_hpp, "};\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  fprintf(fp_hpp, "\n// Size of register-mask in ints\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  fprintf(fp_hpp, "#define RM_SIZE %d\n",RegisterForm::RegMask_Size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  fprintf(fp_hpp, "// Unroll factor for loops over the data in a RegMask\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  fprintf(fp_hpp, "#define FORALL_BODY ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  int len = RegisterForm::RegMask_Size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  for( int i = 0; i < len; i++ )
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    fprintf(fp_hpp, "BODY(%d) ",i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  fprintf(fp_hpp, "\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  fprintf(fp_hpp,"class RegMask;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  // All RegMasks are declared "extern const ..." in ad_<arch>.hpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  // fprintf(fp_hpp,"extern RegMask STACK_OR_STACK_SLOTS_mask;\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
// Output enumeration of machine register encodings
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
// (2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
// // Enumerate machine registers starting after reserved regs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
// // in the order of occurrence in the alloc_class(es).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
// enum MachRegisterEncodes {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
//   EAX_enc = 0x00,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
//   ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
// }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
void ArchDesc::buildMachRegisterEncodes(FILE *fp_hpp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  if (_register) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
    RegDef *reg_def = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
    RegDef *reg_def_next = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
    // (2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
    // Build definition for enumeration of encode values
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
    fprintf(fp_hpp, "\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
    fprintf(fp_hpp, "// Enumerate machine registers starting after reserved regs.\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
    fprintf(fp_hpp, "// in the order of occurrence in the alloc_class(es).\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
    fprintf(fp_hpp, "enum MachRegisterEncodes {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
    // Output the register encoding for each register in the allocation classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
    _register->reset_RegDefs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
    reg_def_next = _register->iter_RegDefs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
    while( (reg_def = reg_def_next) != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
      reg_def_next = _register->iter_RegDefs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
      fprintf(fp_hpp,"  %s_enc = %s%s\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
              reg_def->_regname, reg_def->register_encode(), reg_def_next == NULL? "" : "," );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
    // Finish defining enumeration
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    fprintf(fp_hpp, "};\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  } // Done with register form
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
// Declare an array containing the machine register names, strings.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
static void declareRegNames(FILE *fp, RegisterForm *registers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  if (registers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
//    fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
//    fprintf(fp,"// An array of character pointers to machine register names.\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
//    fprintf(fp,"extern const char *regName[];\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
// Declare an array containing the machine register sizes in 32-bit words.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
void ArchDesc::declareRegSizes(FILE *fp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
// regSize[] is not used
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
// Declare an array containing the machine register encoding values
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
static void declareRegEncodes(FILE *fp, RegisterForm *registers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  if (registers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
    // // //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
    // fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
    // fprintf(fp,"// An array containing the machine register encode values\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
    // fprintf(fp,"extern const char  regEncode[];\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
// ---------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
//------------------------------Utilities to build Instruction Classes--------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
// ---------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
static void out_RegMask(FILE *fp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  fprintf(fp,"  virtual const RegMask &out_RegMask() const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
// ---------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
//--------Utilities to build MachOper and MachNode derived Classes------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
// ---------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
//------------------------------Utilities to build Operand Classes------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
static void in_RegMask(FILE *fp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  fprintf(fp,"  virtual const RegMask *in_RegMask(int index) const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
static void declare_hash(FILE *fp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  fprintf(fp,"  virtual uint           hash() const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
static void declare_cmp(FILE *fp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  fprintf(fp,"  virtual uint           cmp( const MachOper &oper ) const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
static void declareConstStorage(FILE *fp, FormDict &globals, OperandForm *oper) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  int i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  Component *comp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  if (oper->num_consts(globals) == 0) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  // Iterate over the component list looking for constants
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  oper->_components.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  if ((comp = oper->_components.iter()) == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
    assert(oper->num_consts(globals) == 1, "Bad component list detected.\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    const char *type = oper->ideal_type(globals);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
    if (!strcmp(type, "ConI")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
      if (i > 0) fprintf(fp,", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
      fprintf(fp,"  int32          _c%d;\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
    else if (!strcmp(type, "ConP")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
      if (i > 0) fprintf(fp,", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
      fprintf(fp,"  const TypePtr *_c%d;\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
    }
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   206
    else if (!strcmp(type, "ConN")) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   207
      if (i > 0) fprintf(fp,", ");
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   208
      fprintf(fp,"  const TypeNarrowOop *_c%d;\n", i);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   209
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
    else if (!strcmp(type, "ConL")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
      if (i > 0) fprintf(fp,", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
      fprintf(fp,"  jlong          _c%d;\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    else if (!strcmp(type, "ConF")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
      if (i > 0) fprintf(fp,", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
      fprintf(fp,"  jfloat         _c%d;\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    else if (!strcmp(type, "ConD")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
      if (i > 0) fprintf(fp,", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
      fprintf(fp,"  jdouble        _c%d;\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    else if (!strcmp(type, "Bool")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
      fprintf(fp,"private:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
      fprintf(fp,"  BoolTest::mask _c%d;\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
      fprintf(fp,"public:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
      assert(0, "Non-constant operand lacks component list.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  } // end if NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
    oper->_components.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
    while ((comp = oper->_components.iter()) != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
      if (!strcmp(comp->base_type(globals), "ConI")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
        fprintf(fp,"  jint             _c%d;\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
        i++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
      else if (!strcmp(comp->base_type(globals), "ConP")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
        fprintf(fp,"  const TypePtr *_c%d;\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
        i++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
      }
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   242
      else if (!strcmp(comp->base_type(globals), "ConN")) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   243
        fprintf(fp,"  const TypePtr *_c%d;\n", i);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   244
        i++;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   245
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
      else if (!strcmp(comp->base_type(globals), "ConL")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
        fprintf(fp,"  jlong            _c%d;\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
        i++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
      else if (!strcmp(comp->base_type(globals), "ConF")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
        fprintf(fp,"  jfloat           _c%d;\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
        i++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
      else if (!strcmp(comp->base_type(globals), "ConD")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
        fprintf(fp,"  jdouble          _c%d;\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
        i++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
// Declare constructor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
// Parameters start with condition code, then all other constants
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
// (0) public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
// (1)  MachXOper(int32 ccode, int32 c0, int32 c1, ..., int32 cn)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
// (2)     : _ccode(ccode), _c0(c0), _c1(c1), ..., _cn(cn) { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
static void defineConstructor(FILE *fp, const char *name, uint num_consts,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
                              ComponentList &lst, bool is_ideal_bool,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
                              Form::DataType constant_type, FormDict &globals) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  fprintf(fp,"public:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  // generate line (1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  fprintf(fp,"  %sOper(", name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  if( num_consts == 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
    fprintf(fp,") {}\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  // generate parameters for constants
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  uint i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  Component *comp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  lst.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  if ((comp = lst.iter()) == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
    assert(num_consts == 1, "Bad component list detected.\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    switch( constant_type ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
    case Form::idealI : {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
      fprintf(fp,is_ideal_bool ? "BoolTest::mask c%d" : "int32 c%d", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
    }
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   291
    case Form::idealN : { fprintf(fp,"const TypeNarrowOop *c%d", i); break; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
    case Form::idealP : { fprintf(fp,"const TypePtr *c%d", i); break; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
    case Form::idealL : { fprintf(fp,"jlong c%d", i);   break;        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
    case Form::idealF : { fprintf(fp,"jfloat c%d", i);  break;        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
    case Form::idealD : { fprintf(fp,"jdouble c%d", i); break;        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
      assert(!is_ideal_bool, "Non-constant operand lacks component list.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  } // end if NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
    lst.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
    while((comp = lst.iter()) != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
      if (!strcmp(comp->base_type(globals), "ConI")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
        if (i > 0) fprintf(fp,", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
        fprintf(fp,"int32 c%d", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
        i++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
      else if (!strcmp(comp->base_type(globals), "ConP")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
        if (i > 0) fprintf(fp,", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
        fprintf(fp,"const TypePtr *c%d", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
        i++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
      }
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   314
      else if (!strcmp(comp->base_type(globals), "ConN")) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   315
        if (i > 0) fprintf(fp,", ");
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   316
        fprintf(fp,"const TypePtr *c%d", i);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   317
        i++;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   318
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
      else if (!strcmp(comp->base_type(globals), "ConL")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
        if (i > 0) fprintf(fp,", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
        fprintf(fp,"jlong c%d", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
        i++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
      else if (!strcmp(comp->base_type(globals), "ConF")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
        if (i > 0) fprintf(fp,", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
        fprintf(fp,"jfloat c%d", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
        i++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
      else if (!strcmp(comp->base_type(globals), "ConD")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
        if (i > 0) fprintf(fp,", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
        fprintf(fp,"jdouble c%d", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
        i++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
      else if (!strcmp(comp->base_type(globals), "Bool")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
        if (i > 0) fprintf(fp,", ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
        fprintf(fp,"BoolTest::mask c%d", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
        i++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  // finish line (1) and start line (2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  fprintf(fp,")  : ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  // generate initializers for constants
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  fprintf(fp,"_c%d(c%d)", i, i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  for( i = 1; i < num_consts; ++i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
    fprintf(fp,", _c%d(c%d)", i, i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  // The body for the constructor is empty
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  fprintf(fp," {}\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
// ---------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
// Utilities to generate format rules for machine operands and instructions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
// ---------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
// Generate the format rule for condition codes
1495
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   358
static void defineCCodeDump(OperandForm* oper, FILE *fp, int i) {
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   359
  assert(oper != NULL, "what");
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   360
  CondInterface* cond = oper->_interface->is_CondInterface();
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   361
  fprintf(fp, "         if( _c%d == BoolTest::eq ) st->print(\"%s\");\n",i,cond->_equal_format);
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   362
  fprintf(fp, "    else if( _c%d == BoolTest::ne ) st->print(\"%s\");\n",i,cond->_not_equal_format);
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   363
  fprintf(fp, "    else if( _c%d == BoolTest::le ) st->print(\"%s\");\n",i,cond->_less_equal_format);
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   364
  fprintf(fp, "    else if( _c%d == BoolTest::ge ) st->print(\"%s\");\n",i,cond->_greater_equal_format);
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   365
  fprintf(fp, "    else if( _c%d == BoolTest::lt ) st->print(\"%s\");\n",i,cond->_less_format);
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   366
  fprintf(fp, "    else if( _c%d == BoolTest::gt ) st->print(\"%s\");\n",i,cond->_greater_format);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
// Output code that dumps constant values, increment "i" if type is constant
1495
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   370
static uint dump_spec_constant(FILE *fp, const char *ideal_type, uint i, OperandForm* oper) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  if (!strcmp(ideal_type, "ConI")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
    fprintf(fp,"   st->print(\"#%%d\", _c%d);\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
    ++i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  else if (!strcmp(ideal_type, "ConP")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
    fprintf(fp,"    _c%d->dump_on(st);\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
    ++i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  }
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   379
  else if (!strcmp(ideal_type, "ConN")) {
1497
cd3234c89e59 6764622: IdealGraphVisualizer fixes
never
parents: 1495
diff changeset
   380
    fprintf(fp,"    _c%d->dump_on(st);\n", i);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   381
    ++i;
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   382
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  else if (!strcmp(ideal_type, "ConL")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
    fprintf(fp,"    st->print(\"#\" INT64_FORMAT, _c%d);\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
    ++i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  else if (!strcmp(ideal_type, "ConF")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
    fprintf(fp,"    st->print(\"#%%f\", _c%d);\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
    ++i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  else if (!strcmp(ideal_type, "ConD")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
    fprintf(fp,"    st->print(\"#%%f\", _c%d);\n", i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
    ++i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  else if (!strcmp(ideal_type, "Bool")) {
1495
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   396
    defineCCodeDump(oper, fp,i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
    ++i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  return i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
// Generate the format rule for an operand
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
void gen_oper_format(FILE *fp, FormDict &globals, OperandForm &oper, bool for_c_file = false) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  if (!for_c_file) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
    // invoked after output #ifndef PRODUCT to ad_<arch>.hpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
    // compile the bodies separately, to cut down on recompilations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
    fprintf(fp,"  virtual void           int_format(PhaseRegAlloc *ra, const MachNode *node, outputStream *st) const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
    fprintf(fp,"  virtual void           ext_format(PhaseRegAlloc *ra, const MachNode *node, int idx, outputStream *st) const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  // Local pointer indicates remaining part of format rule
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  uint  idx = 0;                   // position of operand in match rule
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  // Generate internal format function, used when stored locally
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  fprintf(fp, "\n#ifndef PRODUCT\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  fprintf(fp,"void %sOper::int_format(PhaseRegAlloc *ra, const MachNode *node, outputStream *st) const {\n", oper._ident);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  // Generate the user-defined portion of the format
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  if (oper._format) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
    if ( oper._format->_strings.count() != 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
      // No initialization code for int_format
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
      // Build the format from the entries in strings and rep_vars
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
      const char  *string  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
      oper._format->_rep_vars.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
      oper._format->_strings.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
      while ( (string = oper._format->_strings.iter()) != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
        fprintf(fp,"  ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
        // Check if this is a standard string or a replacement variable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
        if ( string != NameList::_signal ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
          // Normal string
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
          // Pass through to st->print
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
          fprintf(fp,"st->print(\"%s\");\n", string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
          // Replacement variable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
          const char *rep_var = oper._format->_rep_vars.iter();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
          // Check that it is a local name, and an operand
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   440
          const Form* form = oper._localNames[rep_var];
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   441
          if (form == NULL) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   442
            globalAD->syntax_err(oper._linenum,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   443
                                 "\'%s\' not found in format for %s\n", rep_var, oper._ident);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   444
            assert(form, "replacement variable was not found in local names");
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   445
          }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   446
          OperandForm *op      = form->is_operand();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
          // Get index if register or constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
          if ( op->_matrule && op->_matrule->is_base_register(globals) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
            idx  = oper.register_position( globals, rep_var);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
          else if (op->_matrule && op->_matrule->is_base_constant(globals)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
            idx  = oper.constant_position( globals, rep_var);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
            idx = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
          // output invocation of "$..."s format function
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
          if ( op != NULL )   op->int_format(fp, globals, idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
          if ( idx == -1 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
            fprintf(stderr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
                    "Using a name, %s, that isn't in match rule\n", rep_var);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
            assert( strcmp(op->_ident,"label")==0, "Unimplemented");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
        } // Done with a replacement variable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
      } // Done with all format strings
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
      // Default formats for base operands (RegI, RegP, ConI, ConP, ...)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
      oper.int_format(fp, globals, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  } else { // oper._format == NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
    // Provide a few special case formats where the AD writer cannot.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
    if ( strcmp(oper._ident,"Universe")==0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
      fprintf(fp, "  st->print(\"$$univ\");\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
    // labelOper::int_format is defined in ad_<...>.cpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  // ALWAYS! Provide a special case output for condition codes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  if( oper.is_ideal_bool() ) {
1495
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   481
    defineCCodeDump(&oper, fp,0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  fprintf(fp,"}\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  // Generate external format function, when data is stored externally
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  fprintf(fp,"void %sOper::ext_format(PhaseRegAlloc *ra, const MachNode *node, int idx, outputStream *st) const {\n", oper._ident);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  // Generate the user-defined portion of the format
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  if (oper._format) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
    if ( oper._format->_strings.count() != 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
      // Check for a replacement string "$..."
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
      if ( oper._format->_rep_vars.count() != 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
        // Initialization code for ext_format
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
      // Build the format from the entries in strings and rep_vars
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
      const char  *string  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
      oper._format->_rep_vars.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
      oper._format->_strings.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
      while ( (string = oper._format->_strings.iter()) != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
        fprintf(fp,"  ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
        // Check if this is a standard string or a replacement variable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
        if ( string != NameList::_signal ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
          // Normal string
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
          // Pass through to st->print
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
          fprintf(fp,"st->print(\"%s\");\n", string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
          // Replacement variable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
          const char *rep_var = oper._format->_rep_vars.iter();
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   511
         // Check that it is a local name, and an operand
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   512
          const Form* form = oper._localNames[rep_var];
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   513
          if (form == NULL) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   514
            globalAD->syntax_err(oper._linenum,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   515
                                 "\'%s\' not found in format for %s\n", rep_var, oper._ident);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   516
            assert(form, "replacement variable was not found in local names");
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   517
          }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   518
          OperandForm *op      = form->is_operand();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
          // Get index if register or constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
          if ( op->_matrule && op->_matrule->is_base_register(globals) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
            idx  = oper.register_position( globals, rep_var);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
          else if (op->_matrule && op->_matrule->is_base_constant(globals)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
            idx  = oper.constant_position( globals, rep_var);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
            idx = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
          // output invocation of "$..."s format function
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
          if ( op != NULL )   op->ext_format(fp, globals, idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
          // Lookup the index position of the replacement variable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
          idx      = oper._components.operand_position_format(rep_var);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
          if ( idx == -1 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
            fprintf(stderr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
                    "Using a name, %s, that isn't in match rule\n", rep_var);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
            assert( strcmp(op->_ident,"label")==0, "Unimplemented");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
        } // Done with a replacement variable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
      } // Done with all format strings
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
      // Default formats for base operands (RegI, RegP, ConI, ConP, ...)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
      oper.ext_format(fp, globals, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  } else { // oper._format == NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
    // Provide a few special case formats where the AD writer cannot.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
    if ( strcmp(oper._ident,"Universe")==0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
      fprintf(fp, "  st->print(\"$$univ\");\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
    // labelOper::ext_format is defined in ad_<...>.cpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  // ALWAYS! Provide a special case output for condition codes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  if( oper.is_ideal_bool() ) {
1495
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   554
    defineCCodeDump(&oper, fp,0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  fprintf(fp, "}\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  fprintf(fp, "#endif\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
// Generate the format rule for an instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
void gen_inst_format(FILE *fp, FormDict &globals, InstructForm &inst, bool for_c_file = false) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  if (!for_c_file) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
    // compile the bodies separately, to cut down on recompilations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
    // #ifndef PRODUCT region generated by caller
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
    fprintf(fp,"  virtual void           format(PhaseRegAlloc *ra, outputStream *st) const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  // Define the format function
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
  fprintf(fp, "#ifndef PRODUCT\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  fprintf(fp, "void %sNode::format(PhaseRegAlloc *ra, outputStream *st) const {\n", inst._ident);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  // Generate the user-defined portion of the format
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  if( inst._format ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
    // If there are replacement variables,
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 2129
diff changeset
   577
    // Generate index values needed for determining the operand position
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
    if( inst._format->_rep_vars.count() )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
      inst.index_temps(fp, globals);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
    // Build the format from the entries in strings and rep_vars
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
    const char  *string  = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
    inst._format->_rep_vars.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
    inst._format->_strings.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
    while( (string = inst._format->_strings.iter()) != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
      fprintf(fp,"    ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
      // Check if this is a standard string or a replacement variable
1495
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   588
      if( string == NameList::_signal ) { // Replacement variable
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   589
        const char* rep_var =  inst._format->_rep_vars.iter();
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   590
        inst.rep_var_format( fp, rep_var);
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   591
      } else if( string == NameList::_signal3 ) { // Replacement variable in raw text
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   592
        const char* rep_var =  inst._format->_rep_vars.iter();
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   593
        const Form *form   = inst._localNames[rep_var];
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   594
        if (form == NULL) {
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   595
          fprintf(stderr, "unknown replacement variable in format statement: '%s'\n", rep_var);
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   596
          assert(false, "ShouldNotReachHere()");
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   597
        }
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   598
        OpClassForm *opc   = form->is_opclass();
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   599
        assert( opc, "replacement variable was not found in local names");
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   600
        // Lookup the index position of the replacement variable
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   601
        int idx  = inst.operand_position_format(rep_var);
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   602
        if ( idx == -1 ) {
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   603
          assert( strcmp(opc->_ident,"label")==0, "Unimplemented");
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   604
          assert( false, "ShouldNotReachHere()");
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   605
        }
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   606
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   607
        if (inst.is_noninput_operand(idx)) {
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   608
          assert( false, "ShouldNotReachHere()");
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   609
        } else {
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   610
          // Output the format call for this operand
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   611
          fprintf(fp,"opnd_array(%d)",idx);
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   612
        }
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   613
        rep_var =  inst._format->_rep_vars.iter();
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   614
        inst._format->_strings.iter();
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   615
        if ( strcmp(rep_var,"$constant") == 0 && opc->is_operand()) {
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   616
          Form::DataType constant_type = form->is_operand()->is_base_constant(globals);
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   617
          if ( constant_type == Form::idealD ) {
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   618
            fprintf(fp,"->constantD()");
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   619
          } else if ( constant_type == Form::idealF ) {
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   620
            fprintf(fp,"->constantF()");
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   621
          } else if ( constant_type == Form::idealL ) {
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   622
            fprintf(fp,"->constantL()");
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   623
          } else {
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   624
            fprintf(fp,"->constant()");
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   625
          }
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   626
        } else if ( strcmp(rep_var,"$cmpcode") == 0) {
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   627
            fprintf(fp,"->ccode()");
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   628
        } else {
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   629
          assert( false, "ShouldNotReachHere()");
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   630
        }
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   631
      } else if( string == NameList::_signal2 ) // Raw program text
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   632
        fputs(inst._format->_strings.iter(), fp);
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
   633
      else
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
        fprintf(fp,"st->print(\"%s\");\n", string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
    } // Done with all format strings
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
  } // Done generating the user-defined portion of the format
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  // Add call debug info automatically
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
  Form::CallType call_type = inst.is_ideal_call();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
  if( call_type != Form::invalid_type ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
    switch( call_type ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
    case Form::JAVA_DYNAMIC:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
      fprintf(fp,"    _method->print_short_name();\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
    case Form::JAVA_STATIC:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
      fprintf(fp,"    if( _method ) _method->print_short_name(st); else st->print(\" wrapper for: %%s\", _name);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
      fprintf(fp,"    if( !_method ) dump_trap_args(st);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
    case Form::JAVA_COMPILED:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
    case Form::JAVA_INTERP:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
    case Form::JAVA_RUNTIME:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
    case Form::JAVA_LEAF:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
    case Form::JAVA_NATIVE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
      fprintf(fp,"    st->print(\" %%s\", _name);");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
      assert(0,"ShouldNotReacHere");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
    fprintf(fp,  "    st->print_cr(\"\");\n" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
    fprintf(fp,  "    if (_jvms) _jvms->format(ra, this, st); else st->print_cr(\"        No JVM State Info\");\n" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
    fprintf(fp,  "    st->print(\"        # \");\n" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
    fprintf(fp,  "    if( _jvms ) _oop_map->print_on(st);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
  else if(inst.is_ideal_safepoint()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
    fprintf(fp,  "    st->print(\"\");\n" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
    fprintf(fp,  "    if (_jvms) _jvms->format(ra, this, st); else st->print_cr(\"        No JVM State Info\");\n" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
    fprintf(fp,  "    st->print(\"        # \");\n" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
    fprintf(fp,  "    if( _jvms ) _oop_map->print_on(st);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  else if( inst.is_ideal_if() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    fprintf(fp,  "    st->print(\"  P=%%f C=%%f\",_prob,_fcnt);\n" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
  else if( inst.is_ideal_mem() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
    // Print out the field name if available to improve readability
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
    fprintf(fp,  "    if (ra->C->alias_type(adr_type())->field() != NULL) {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
    fprintf(fp,  "      st->print(\" ! Field \");\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
    fprintf(fp,  "      if( ra->C->alias_type(adr_type())->is_volatile() )\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
    fprintf(fp,  "        st->print(\" Volatile\");\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
    fprintf(fp,  "      ra->C->alias_type(adr_type())->field()->holder()->name()->print_symbol_on(st);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
    fprintf(fp,  "      st->print(\".\");\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
    fprintf(fp,  "      ra->C->alias_type(adr_type())->field()->name()->print_symbol_on(st);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
    fprintf(fp,  "    } else\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
    // Make sure 'Volatile' gets printed out
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
    fprintf(fp,  "    if( ra->C->alias_type(adr_type())->is_volatile() )\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
    fprintf(fp,  "      st->print(\" Volatile!\");\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
  // Complete the definition of the format function
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
  fprintf(fp, "  }\n#endif\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
static bool is_non_constant(char* x) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  // Tells whether the string (part of an operator interface) is non-constant.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
  // Simply detect whether there is an occurrence of a formal parameter,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
  // which will always begin with '$'.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
  return strchr(x, '$') == 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
void ArchDesc::declare_pipe_classes(FILE *fp_hpp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
  if (!_pipeline)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  fprintf(fp_hpp, "\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  fprintf(fp_hpp, "// Pipeline_Use_Cycle_Mask Class\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
  fprintf(fp_hpp, "class Pipeline_Use_Cycle_Mask {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
  if (_pipeline->_maxcycleused <=
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
#ifdef SPARC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
    64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
    32
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
      ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
    fprintf(fp_hpp, "protected:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
    fprintf(fp_hpp, "  %s _mask;\n\n", _pipeline->_maxcycleused <= 32 ? "uint" : "uint64_t" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
    fprintf(fp_hpp, "public:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
    fprintf(fp_hpp, "  Pipeline_Use_Cycle_Mask() : _mask(0) {}\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
    if (_pipeline->_maxcycleused <= 32)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
      fprintf(fp_hpp, "  Pipeline_Use_Cycle_Mask(uint mask) : _mask(mask) {}\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
    else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
      fprintf(fp_hpp, "  Pipeline_Use_Cycle_Mask(uint mask1, uint mask2) : _mask((((uint64_t)mask1) << 32) | mask2) {}\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
      fprintf(fp_hpp, "  Pipeline_Use_Cycle_Mask(uint64_t mask) : _mask(mask) {}\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
    fprintf(fp_hpp, "  Pipeline_Use_Cycle_Mask& operator=(const Pipeline_Use_Cycle_Mask &in) {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
    fprintf(fp_hpp, "    _mask = in._mask;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
    fprintf(fp_hpp, "    return *this;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
    fprintf(fp_hpp, "  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
    fprintf(fp_hpp, "  bool overlaps(const Pipeline_Use_Cycle_Mask &in2) const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
    fprintf(fp_hpp, "    return ((_mask & in2._mask) != 0);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
    fprintf(fp_hpp, "  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
    fprintf(fp_hpp, "  Pipeline_Use_Cycle_Mask& operator<<=(int n) {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
    fprintf(fp_hpp, "    _mask <<= n;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
    fprintf(fp_hpp, "    return *this;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
    fprintf(fp_hpp, "  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
    fprintf(fp_hpp, "  void Or(const Pipeline_Use_Cycle_Mask &in2) {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
    fprintf(fp_hpp, "    _mask |= in2._mask;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
    fprintf(fp_hpp, "  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
    fprintf(fp_hpp, "  friend Pipeline_Use_Cycle_Mask operator&(const Pipeline_Use_Cycle_Mask &, const Pipeline_Use_Cycle_Mask &);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
    fprintf(fp_hpp, "  friend Pipeline_Use_Cycle_Mask operator|(const Pipeline_Use_Cycle_Mask &, const Pipeline_Use_Cycle_Mask &);\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
    fprintf(fp_hpp, "protected:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
    uint masklen = (_pipeline->_maxcycleused + 31) >> 5;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
    uint l;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
    fprintf(fp_hpp, "  uint ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
    for (l = 1; l <= masklen; l++)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
      fprintf(fp_hpp, "_mask%d%s", l, l < masklen ? ", " : ";\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
    fprintf(fp_hpp, "public:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
    fprintf(fp_hpp, "  Pipeline_Use_Cycle_Mask() : ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
    for (l = 1; l <= masklen; l++)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
      fprintf(fp_hpp, "_mask%d(0)%s", l, l < masklen ? ", " : " {}\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
    fprintf(fp_hpp, "  Pipeline_Use_Cycle_Mask(");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
    for (l = 1; l <= masklen; l++)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
      fprintf(fp_hpp, "uint mask%d%s", l, l < masklen ? ", " : ") : ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
    for (l = 1; l <= masklen; l++)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
      fprintf(fp_hpp, "_mask%d(mask%d)%s", l, l, l < masklen ? ", " : " {}\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
    fprintf(fp_hpp, "  Pipeline_Use_Cycle_Mask& operator=(const Pipeline_Use_Cycle_Mask &in) {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
    for (l = 1; l <= masklen; l++)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
      fprintf(fp_hpp, "    _mask%d = in._mask%d;\n", l, l);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
    fprintf(fp_hpp, "    return *this;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
    fprintf(fp_hpp, "  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
    fprintf(fp_hpp, "  Pipeline_Use_Cycle_Mask intersect(const Pipeline_Use_Cycle_Mask &in2) {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
    fprintf(fp_hpp, "    Pipeline_Use_Cycle_Mask out;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
    for (l = 1; l <= masklen; l++)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
      fprintf(fp_hpp, "    out._mask%d = _mask%d & in2._mask%d;\n", l, l, l);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
    fprintf(fp_hpp, "    return out;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
    fprintf(fp_hpp, "  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
    fprintf(fp_hpp, "  bool overlaps(const Pipeline_Use_Cycle_Mask &in2) const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
    fprintf(fp_hpp, "    return (");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
    for (l = 1; l <= masklen; l++)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
      fprintf(fp_hpp, "((_mask%d & in2._mask%d) != 0)%s", l, l, l < masklen ? " || " : "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
    fprintf(fp_hpp, ") ? true : false;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
    fprintf(fp_hpp, "  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
    fprintf(fp_hpp, "  Pipeline_Use_Cycle_Mask& operator<<=(int n) {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
    fprintf(fp_hpp, "    if (n >= 32)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
    fprintf(fp_hpp, "      do {\n       ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
    for (l = masklen; l > 1; l--)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
      fprintf(fp_hpp, " _mask%d = _mask%d;", l, l-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
    fprintf(fp_hpp, " _mask%d = 0;\n", 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
    fprintf(fp_hpp, "      } while ((n -= 32) >= 32);\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
    fprintf(fp_hpp, "    if (n > 0) {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
    fprintf(fp_hpp, "      uint m = 32 - n;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
    fprintf(fp_hpp, "      uint mask = (1 << n) - 1;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
    fprintf(fp_hpp, "      uint temp%d = mask & (_mask%d >> m); _mask%d <<= n;\n", 2, 1, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
    for (l = 2; l < masklen; l++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
      fprintf(fp_hpp, "      uint temp%d = mask & (_mask%d >> m); _mask%d <<= n; _mask%d |= temp%d;\n", l+1, l, l, l, l);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
    fprintf(fp_hpp, "      _mask%d <<= n; _mask%d |= temp%d;\n", masklen, masklen, masklen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
    fprintf(fp_hpp, "    }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
    fprintf(fp_hpp, "    return *this;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
    fprintf(fp_hpp, "  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
    fprintf(fp_hpp, "  void Or(const Pipeline_Use_Cycle_Mask &);\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
    fprintf(fp_hpp, "  friend Pipeline_Use_Cycle_Mask operator&(const Pipeline_Use_Cycle_Mask &, const Pipeline_Use_Cycle_Mask &);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
    fprintf(fp_hpp, "  friend Pipeline_Use_Cycle_Mask operator|(const Pipeline_Use_Cycle_Mask &, const Pipeline_Use_Cycle_Mask &);\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
  fprintf(fp_hpp, "  friend class Pipeline_Use;\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
  fprintf(fp_hpp, "  friend class Pipeline_Use_Element;\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
  fprintf(fp_hpp, "};\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
  uint rescount = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
  const char *resource;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
  for ( _pipeline->_reslist.reset(); (resource = _pipeline->_reslist.iter()) != NULL; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
      int mask = _pipeline->_resdict[resource]->is_resource()->mask();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
      if ((mask & (mask-1)) == 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
        rescount++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
  fprintf(fp_hpp, "// Pipeline_Use_Element Class\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
  fprintf(fp_hpp, "class Pipeline_Use_Element {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
  fprintf(fp_hpp, "protected:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
  fprintf(fp_hpp, "  // Mask of used functional units\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
  fprintf(fp_hpp, "  uint _used;\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
  fprintf(fp_hpp, "  // Lower and upper bound of functional unit number range\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
  fprintf(fp_hpp, "  uint _lb, _ub;\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
  fprintf(fp_hpp, "  // Indicates multiple functionals units available\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
  fprintf(fp_hpp, "  bool _multiple;\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
  fprintf(fp_hpp, "  // Mask of specific used cycles\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  fprintf(fp_hpp, "  Pipeline_Use_Cycle_Mask _mask;\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
  fprintf(fp_hpp, "public:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  fprintf(fp_hpp, "  Pipeline_Use_Element() {}\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  fprintf(fp_hpp, "  Pipeline_Use_Element(uint used, uint lb, uint ub, bool multiple, Pipeline_Use_Cycle_Mask mask)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  fprintf(fp_hpp, "  : _used(used), _lb(lb), _ub(ub), _multiple(multiple), _mask(mask) {}\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  fprintf(fp_hpp, "  uint used() const { return _used; }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  fprintf(fp_hpp, "  uint lowerBound() const { return _lb; }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  fprintf(fp_hpp, "  uint upperBound() const { return _ub; }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
  fprintf(fp_hpp, "  bool multiple() const { return _multiple; }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
  fprintf(fp_hpp, "  Pipeline_Use_Cycle_Mask mask() const { return _mask; }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
  fprintf(fp_hpp, "  bool overlaps(const Pipeline_Use_Element &in2) const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
  fprintf(fp_hpp, "    return ((_used & in2._used) != 0 && _mask.overlaps(in2._mask));\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  fprintf(fp_hpp, "  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
  fprintf(fp_hpp, "  void step(uint cycles) {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  fprintf(fp_hpp, "    _used = 0;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
  fprintf(fp_hpp, "    _mask <<= cycles;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
  fprintf(fp_hpp, "  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  fprintf(fp_hpp, "  friend class Pipeline_Use;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  fprintf(fp_hpp, "};\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  fprintf(fp_hpp, "// Pipeline_Use Class\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
  fprintf(fp_hpp, "class Pipeline_Use {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
  fprintf(fp_hpp, "protected:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
  fprintf(fp_hpp, "  // These resources can be used\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
  fprintf(fp_hpp, "  uint _resources_used;\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  fprintf(fp_hpp, "  // These resources are used; excludes multiple choice functional units\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  fprintf(fp_hpp, "  uint _resources_used_exclusively;\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  fprintf(fp_hpp, "  // Number of elements\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
  fprintf(fp_hpp, "  uint _count;\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
  fprintf(fp_hpp, "  // This is the array of Pipeline_Use_Elements\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  fprintf(fp_hpp, "  Pipeline_Use_Element * _elements;\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  fprintf(fp_hpp, "public:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
  fprintf(fp_hpp, "  Pipeline_Use(uint resources_used, uint resources_used_exclusively, uint count, Pipeline_Use_Element *elements)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
  fprintf(fp_hpp, "  : _resources_used(resources_used)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
  fprintf(fp_hpp, "  , _resources_used_exclusively(resources_used_exclusively)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
  fprintf(fp_hpp, "  , _count(count)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
  fprintf(fp_hpp, "  , _elements(elements)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
  fprintf(fp_hpp, "  {}\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  fprintf(fp_hpp, "  uint resourcesUsed() const { return _resources_used; }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
  fprintf(fp_hpp, "  uint resourcesUsedExclusively() const { return _resources_used_exclusively; }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
  fprintf(fp_hpp, "  uint count() const { return _count; }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
  fprintf(fp_hpp, "  Pipeline_Use_Element * element(uint i) const { return &_elements[i]; }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
  fprintf(fp_hpp, "  uint full_latency(uint delay, const Pipeline_Use &pred) const;\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
  fprintf(fp_hpp, "  void add_usage(const Pipeline_Use &pred);\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
  fprintf(fp_hpp, "  void reset() {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
  fprintf(fp_hpp, "    _resources_used = _resources_used_exclusively = 0;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
  fprintf(fp_hpp, "  };\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
  fprintf(fp_hpp, "  void step(uint cycles) {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  fprintf(fp_hpp, "    reset();\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
  fprintf(fp_hpp, "    for (uint i = 0; i < %d; i++)\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
    rescount);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
  fprintf(fp_hpp, "      (&_elements[i])->step(cycles);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
  fprintf(fp_hpp, "  };\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
  fprintf(fp_hpp, "  static const Pipeline_Use         elaborated_use;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
  fprintf(fp_hpp, "  static const Pipeline_Use_Element elaborated_elements[%d];\n\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
    rescount);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
  fprintf(fp_hpp, "  friend class Pipeline;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  fprintf(fp_hpp, "};\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  fprintf(fp_hpp, "// Pipeline Class\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
  fprintf(fp_hpp, "class Pipeline {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
  fprintf(fp_hpp, "public:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
  fprintf(fp_hpp, "  static bool enabled() { return %s; }\n\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
    _pipeline ? "true" : "false" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
  assert( _pipeline->_maxInstrsPerBundle &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
        ( _pipeline->_instrUnitSize || _pipeline->_bundleUnitSize) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
          _pipeline->_instrFetchUnitSize &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
          _pipeline->_instrFetchUnits,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
    "unspecified pipeline architecture units");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
  uint unitSize = _pipeline->_instrUnitSize ? _pipeline->_instrUnitSize : _pipeline->_bundleUnitSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
  fprintf(fp_hpp, "  enum {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
  fprintf(fp_hpp, "    _variable_size_instructions = %d,\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
    _pipeline->_variableSizeInstrs ? 1 : 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
  fprintf(fp_hpp, "    _fixed_size_instructions = %d,\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
    _pipeline->_variableSizeInstrs ? 0 : 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
  fprintf(fp_hpp, "    _branch_has_delay_slot = %d,\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
    _pipeline->_branchHasDelaySlot ? 1 : 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
  fprintf(fp_hpp, "    _max_instrs_per_bundle = %d,\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
    _pipeline->_maxInstrsPerBundle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  fprintf(fp_hpp, "    _max_bundles_per_cycle = %d,\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
    _pipeline->_maxBundlesPerCycle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  fprintf(fp_hpp, "    _max_instrs_per_cycle = %d\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
    _pipeline->_maxBundlesPerCycle * _pipeline->_maxInstrsPerBundle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
  fprintf(fp_hpp, "  };\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  fprintf(fp_hpp, "  static bool instr_has_unit_size() { return %s; }\n\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
    _pipeline->_instrUnitSize != 0 ? "true" : "false" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  if( _pipeline->_bundleUnitSize != 0 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
    if( _pipeline->_instrUnitSize != 0 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
      fprintf(fp_hpp, "// Individual Instructions may be bundled together by the hardware\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
    else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
      fprintf(fp_hpp, "// Instructions exist only in bundles\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
    fprintf(fp_hpp, "// Bundling is not supported\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
  if( _pipeline->_instrUnitSize != 0 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
    fprintf(fp_hpp, "  // Size of an instruction\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
    fprintf(fp_hpp, "  // Size of an individual instruction does not exist - unsupported\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
  fprintf(fp_hpp, "  static uint instr_unit_size() {");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
  if( _pipeline->_instrUnitSize == 0 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
    fprintf(fp_hpp, " assert( false, \"Instructions are only in bundles\" );");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
  fprintf(fp_hpp, " return %d; };\n\n", _pipeline->_instrUnitSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
  if( _pipeline->_bundleUnitSize != 0 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
    fprintf(fp_hpp, "  // Size of a bundle\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
    fprintf(fp_hpp, "  // Bundles do not exist - unsupported\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
  fprintf(fp_hpp, "  static uint bundle_unit_size() {");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
  if( _pipeline->_bundleUnitSize == 0 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
    fprintf(fp_hpp, " assert( false, \"Bundles are not supported\" );");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
  fprintf(fp_hpp, " return %d; };\n\n", _pipeline->_bundleUnitSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
  fprintf(fp_hpp, "  static bool requires_bundling() { return %s; }\n\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
    _pipeline->_bundleUnitSize != 0 && _pipeline->_instrUnitSize == 0 ? "true" : "false" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
  fprintf(fp_hpp, "private:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
  fprintf(fp_hpp, "  Pipeline();  // Not a legal constructor\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
  fprintf(fp_hpp, "\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
  fprintf(fp_hpp, "  const unsigned char                   _read_stage_count;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
  fprintf(fp_hpp, "  const unsigned char                   _write_stage;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
  fprintf(fp_hpp, "  const unsigned char                   _fixed_latency;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
  fprintf(fp_hpp, "  const unsigned char                   _instruction_count;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
  fprintf(fp_hpp, "  const bool                            _has_fixed_latency;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
  fprintf(fp_hpp, "  const bool                            _has_branch_delay;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
  fprintf(fp_hpp, "  const bool                            _has_multiple_bundles;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
  fprintf(fp_hpp, "  const bool                            _force_serialization;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
  fprintf(fp_hpp, "  const bool                            _may_have_no_code;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
  fprintf(fp_hpp, "  const enum machPipelineStages * const _read_stages;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
  fprintf(fp_hpp, "  const enum machPipelineStages * const _resource_stage;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
  fprintf(fp_hpp, "  const uint                    * const _resource_cycles;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
  fprintf(fp_hpp, "  const Pipeline_Use                    _resource_use;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
  fprintf(fp_hpp, "\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
  fprintf(fp_hpp, "public:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
  fprintf(fp_hpp, "  Pipeline(uint                            write_stage,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
  fprintf(fp_hpp, "           uint                            count,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
  fprintf(fp_hpp, "           bool                            has_fixed_latency,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
  fprintf(fp_hpp, "           uint                            fixed_latency,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
  fprintf(fp_hpp, "           uint                            instruction_count,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
  fprintf(fp_hpp, "           bool                            has_branch_delay,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
  fprintf(fp_hpp, "           bool                            has_multiple_bundles,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
  fprintf(fp_hpp, "           bool                            force_serialization,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
  fprintf(fp_hpp, "           bool                            may_have_no_code,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
  fprintf(fp_hpp, "           enum machPipelineStages * const dst,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
  fprintf(fp_hpp, "           enum machPipelineStages * const stage,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
  fprintf(fp_hpp, "           uint                    * const cycles,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
  fprintf(fp_hpp, "           Pipeline_Use                    resource_use)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
  fprintf(fp_hpp, "  : _write_stage(write_stage)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
  fprintf(fp_hpp, "  , _read_stage_count(count)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
  fprintf(fp_hpp, "  , _has_fixed_latency(has_fixed_latency)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
  fprintf(fp_hpp, "  , _fixed_latency(fixed_latency)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
  fprintf(fp_hpp, "  , _read_stages(dst)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
  fprintf(fp_hpp, "  , _resource_stage(stage)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
  fprintf(fp_hpp, "  , _resource_cycles(cycles)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
  fprintf(fp_hpp, "  , _resource_use(resource_use)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
  fprintf(fp_hpp, "  , _instruction_count(instruction_count)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
  fprintf(fp_hpp, "  , _has_branch_delay(has_branch_delay)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
  fprintf(fp_hpp, "  , _has_multiple_bundles(has_multiple_bundles)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
  fprintf(fp_hpp, "  , _force_serialization(force_serialization)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
  fprintf(fp_hpp, "  , _may_have_no_code(may_have_no_code)\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
  fprintf(fp_hpp, "  {};\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
  fprintf(fp_hpp, "\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
  fprintf(fp_hpp, "  uint writeStage() const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
  fprintf(fp_hpp, "    return (_write_stage);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
  fprintf(fp_hpp, "  }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
  fprintf(fp_hpp, "\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
  fprintf(fp_hpp, "  enum machPipelineStages readStage(int ndx) const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  fprintf(fp_hpp, "    return (ndx < _read_stage_count ? _read_stages[ndx] : stage_undefined);");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
  fprintf(fp_hpp, "  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
  fprintf(fp_hpp, "  uint resourcesUsed() const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
  fprintf(fp_hpp, "    return _resource_use.resourcesUsed();\n  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
  fprintf(fp_hpp, "  uint resourcesUsedExclusively() const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
  fprintf(fp_hpp, "    return _resource_use.resourcesUsedExclusively();\n  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
  fprintf(fp_hpp, "  bool hasFixedLatency() const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
  fprintf(fp_hpp, "    return (_has_fixed_latency);\n  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
  fprintf(fp_hpp, "  uint fixedLatency() const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
  fprintf(fp_hpp, "    return (_fixed_latency);\n  }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
  fprintf(fp_hpp, "  uint functional_unit_latency(uint start, const Pipeline *pred) const;\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
  fprintf(fp_hpp, "  uint operand_latency(uint opnd, const Pipeline *pred) const;\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
  fprintf(fp_hpp, "  const Pipeline_Use& resourceUse() const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
  fprintf(fp_hpp, "    return (_resource_use); }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
  fprintf(fp_hpp, "  const Pipeline_Use_Element * resourceUseElement(uint i) const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
  fprintf(fp_hpp, "    return (&_resource_use._elements[i]); }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
  fprintf(fp_hpp, "  uint resourceUseCount() const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
  fprintf(fp_hpp, "    return (_resource_use._count); }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
  fprintf(fp_hpp, "  uint instructionCount() const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
  fprintf(fp_hpp, "    return (_instruction_count); }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
  fprintf(fp_hpp, "  bool hasBranchDelay() const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  fprintf(fp_hpp, "    return (_has_branch_delay); }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
  fprintf(fp_hpp, "  bool hasMultipleBundles() const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
  fprintf(fp_hpp, "    return (_has_multiple_bundles); }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
  fprintf(fp_hpp, "  bool forceSerialization() const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
  fprintf(fp_hpp, "    return (_force_serialization); }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
  fprintf(fp_hpp, "  bool mayHaveNoCode() const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  fprintf(fp_hpp, "    return (_may_have_no_code); }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
  fprintf(fp_hpp, "//const Pipeline_Use_Cycle_Mask& resourceUseMask(int resource) const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
  fprintf(fp_hpp, "//  return (_resource_use_masks[resource]); }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  fprintf(fp_hpp, "\n#ifndef PRODUCT\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
  fprintf(fp_hpp, "  static const char * stageName(uint i);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
  fprintf(fp_hpp, "#endif\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
  fprintf(fp_hpp, "};\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
  fprintf(fp_hpp, "// Bundle class\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
  fprintf(fp_hpp, "class Bundle {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
  uint mshift = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
  for (uint msize = _pipeline->_maxInstrsPerBundle * _pipeline->_maxBundlesPerCycle; msize != 0; msize >>= 1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
    mshift++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  uint rshift = rescount;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
  fprintf(fp_hpp, "protected:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
  fprintf(fp_hpp, "  enum {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
  fprintf(fp_hpp, "    _unused_delay                   = 0x%x,\n", 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
  fprintf(fp_hpp, "    _use_nop_delay                  = 0x%x,\n", 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
  fprintf(fp_hpp, "    _use_unconditional_delay        = 0x%x,\n", 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
  fprintf(fp_hpp, "    _use_conditional_delay          = 0x%x,\n", 3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
  fprintf(fp_hpp, "    _used_in_conditional_delay      = 0x%x,\n", 4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
  fprintf(fp_hpp, "    _used_in_unconditional_delay    = 0x%x,\n", 5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
  fprintf(fp_hpp, "    _used_in_all_conditional_delays = 0x%x,\n", 6);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
  fprintf(fp_hpp, "\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
  fprintf(fp_hpp, "    _use_delay                      = 0x%x,\n", 3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
  fprintf(fp_hpp, "    _used_in_delay                  = 0x%x\n",  4);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
  fprintf(fp_hpp, "  };\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
  fprintf(fp_hpp, "  uint _flags          : 3,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
  fprintf(fp_hpp, "       _starts_bundle  : 1,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
  fprintf(fp_hpp, "       _instr_count    : %d,\n",   mshift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
  fprintf(fp_hpp, "       _resources_used : %d;\n",   rshift);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
  fprintf(fp_hpp, "public:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
  fprintf(fp_hpp, "  Bundle() : _flags(_unused_delay), _starts_bundle(0), _instr_count(0), _resources_used(0) {}\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  fprintf(fp_hpp, "  void set_instr_count(uint i) { _instr_count  = i; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
  fprintf(fp_hpp, "  void set_resources_used(uint i) { _resources_used   = i; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
  fprintf(fp_hpp, "  void clear_usage() { _flags = _unused_delay; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
  fprintf(fp_hpp, "  void set_starts_bundle() { _starts_bundle = true; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
  fprintf(fp_hpp, "  uint flags() const { return (_flags); }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
  fprintf(fp_hpp, "  uint instr_count() const { return (_instr_count); }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
  fprintf(fp_hpp, "  uint resources_used() const { return (_resources_used); }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
  fprintf(fp_hpp, "  bool starts_bundle() const { return (_starts_bundle != 0); }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
  fprintf(fp_hpp, "  void set_use_nop_delay() { _flags = _use_nop_delay; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
  fprintf(fp_hpp, "  void set_use_unconditional_delay() { _flags = _use_unconditional_delay; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
  fprintf(fp_hpp, "  void set_use_conditional_delay() { _flags = _use_conditional_delay; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
  fprintf(fp_hpp, "  void set_used_in_unconditional_delay() { _flags = _used_in_unconditional_delay; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
  fprintf(fp_hpp, "  void set_used_in_conditional_delay() { _flags = _used_in_conditional_delay; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
  fprintf(fp_hpp, "  void set_used_in_all_conditional_delays() { _flags = _used_in_all_conditional_delays; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
  fprintf(fp_hpp, "  bool use_nop_delay() { return (_flags == _use_nop_delay); }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
  fprintf(fp_hpp, "  bool use_unconditional_delay() { return (_flags == _use_unconditional_delay); }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
  fprintf(fp_hpp, "  bool use_conditional_delay() { return (_flags == _use_conditional_delay); }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
  fprintf(fp_hpp, "  bool used_in_unconditional_delay() { return (_flags == _used_in_unconditional_delay); }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
  fprintf(fp_hpp, "  bool used_in_conditional_delay() { return (_flags == _used_in_conditional_delay); }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
  fprintf(fp_hpp, "  bool used_in_all_conditional_delays() { return (_flags == _used_in_all_conditional_delays); }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
  fprintf(fp_hpp, "  bool use_delay() { return ((_flags & _use_delay) != 0); }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
  fprintf(fp_hpp, "  bool used_in_delay() { return ((_flags & _used_in_delay) != 0); }\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
  fprintf(fp_hpp, "  enum {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
  fprintf(fp_hpp, "    _nop_count = %d\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
    _pipeline->_nopcnt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
  fprintf(fp_hpp, "  };\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
  fprintf(fp_hpp, "  static void initialize_nops(MachNode *nop_list[%d], Compile* C);\n\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
    _pipeline->_nopcnt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
  fprintf(fp_hpp, "#ifndef PRODUCT\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
  fprintf(fp_hpp, "  void dump() const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
  fprintf(fp_hpp, "#endif\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
  fprintf(fp_hpp, "};\n\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
//  const char *classname;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
//  for (_pipeline->_classlist.reset(); (classname = _pipeline->_classlist.iter()) != NULL; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
//    PipeClassForm *pipeclass = _pipeline->_classdict[classname]->is_pipeclass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
//    fprintf(fp_hpp, "// Pipeline Class Instance for \"%s\"\n", classname);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
//  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
//------------------------------declareClasses---------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
// Construct the class hierarchy of MachNode classes from the instruction &
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
// operand lists
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
void ArchDesc::declareClasses(FILE *fp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
  // Declare an array containing the machine register names, strings.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
  declareRegNames(fp, _register);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
  // Declare an array containing the machine register encoding values
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
  declareRegEncodes(fp, _register);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
  // Generate declarations for the total number of operands
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
  fprintf(fp,"// Total number of operands defined in architecture definition\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
  int num_operands = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
  OperandForm *op;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
  for (_operands.reset(); (op = (OperandForm*)_operands.iter()) != NULL; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
    // Ensure this is a machine-world instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
    if (op->ideal_only()) continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
    ++num_operands;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
  int first_operand_class = num_operands;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
  OpClassForm *opc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
  for (_opclass.reset(); (opc = (OpClassForm*)_opclass.iter()) != NULL; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
    // Ensure this is a machine-world instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
    if (opc->ideal_only()) continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
    ++num_operands;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
  fprintf(fp,"#define FIRST_OPERAND_CLASS   %d\n", first_operand_class);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
  fprintf(fp,"#define NUM_OPERANDS          %d\n", num_operands);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
  // Generate declarations for the total number of instructions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
  fprintf(fp,"// Total number of instructions defined in architecture definition\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
  fprintf(fp,"#define NUM_INSTRUCTIONS   %d\n",instructFormCount());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
  // Generate Machine Classes for each operand defined in AD file
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
  fprintf(fp,"//----------------------------Declare classes derived from MachOper----------\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
  // Iterate through all operands
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
  _operands.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
  OperandForm *oper;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
  for( ; (oper = (OperandForm*)_operands.iter()) != NULL;) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
    // Ensure this is a machine-world instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
    if (oper->ideal_only() ) continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
    // The declaration of labelOper is in machine-independent file: machnode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
    if ( strcmp(oper->_ident,"label")  == 0 ) continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
    // The declaration of methodOper is in machine-independent file: machnode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
    if ( strcmp(oper->_ident,"method") == 0 ) continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
    // Build class definition for this operand
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
    fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
    fprintf(fp,"class %sOper : public MachOper { \n",oper->_ident);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
    fprintf(fp,"private:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
    // Operand definitions that depend upon number of input edges
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
      uint num_edges = oper->num_edges(_globalNames);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
      if( num_edges != 1 ) { // Use MachOper::num_edges() {return 1;}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
        fprintf(fp,"  virtual uint           num_edges() const { return %d; }\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
              num_edges );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
      if( num_edges > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
        in_RegMask(fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
    // Support storing constants inside the MachOper
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
    declareConstStorage(fp,_globalNames,oper);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
    // Support storage of the condition codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
    if( oper->is_ideal_bool() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
      fprintf(fp,"  virtual int ccode() const { \n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
      fprintf(fp,"    switch (_c0) {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
      fprintf(fp,"    case  BoolTest::eq : return equal();\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
      fprintf(fp,"    case  BoolTest::gt : return greater();\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
      fprintf(fp,"    case  BoolTest::lt : return less();\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
      fprintf(fp,"    case  BoolTest::ne : return not_equal();\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
      fprintf(fp,"    case  BoolTest::le : return less_equal();\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
      fprintf(fp,"    case  BoolTest::ge : return greater_equal();\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
      fprintf(fp,"    default : ShouldNotReachHere(); return 0;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
      fprintf(fp,"    }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
      fprintf(fp,"  };\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
    // Support storage of the condition codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
    if( oper->is_ideal_bool() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
      fprintf(fp,"  virtual void negate() { \n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
      fprintf(fp,"    _c0 = (BoolTest::mask)((int)_c0^0x4); \n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
      fprintf(fp,"  };\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
    // Declare constructor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
    // Parameters start with condition code, then all other constants
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
    // (1)  MachXOper(int32 ccode, int32 c0, int32 c1, ..., int32 cn)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
    // (2)     : _ccode(ccode), _c0(c0), _c1(c1), ..., _cn(cn) { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
    Form::DataType constant_type = oper->simple_type(_globalNames);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
    defineConstructor(fp, oper->_ident, oper->num_consts(_globalNames),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
                      oper->_components, oper->is_ideal_bool(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
                      constant_type, _globalNames);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
    // Clone function
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
    fprintf(fp,"  virtual MachOper      *clone(Compile* C) const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
    // Support setting a spill offset into a constant operand.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
    // We only support setting an 'int' offset, while in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
    // LP64 build spill offsets are added with an AddP which
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
    // requires a long constant.  Thus we don't support spilling
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
    // in frames larger than 4Gig.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
    if( oper->has_conI(_globalNames) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
        oper->has_conL(_globalNames) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
      fprintf(fp, "  virtual void set_con( jint c0 ) { _c0 = c0; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
    // virtual functions for encoding and format
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
    //    fprintf(fp,"  virtual void           encode()   const {\n    %s }\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
    //            (oper->_encrule)?(oper->_encrule->_encrule):"");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
    // Check the interface type, and generate the correct query functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
    // encoding queries based upon MEMORY_INTER, REG_INTER, CONST_INTER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
    fprintf(fp,"  virtual uint           opcode() const { return %s; }\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
            machOperEnum(oper->_ident));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
    // virtual function to look up ideal return type of machine instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
    // (1)  virtual const Type    *type() const { return .....; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
    if ((oper->_matrule) && (oper->_matrule->_lChild == NULL) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
        (oper->_matrule->_rChild == NULL)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
      unsigned int position = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
      const char  *opret, *opname, *optype;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
      oper->_matrule->base_operand(position,_globalNames,opret,opname,optype);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
      fprintf(fp,"  virtual const Type *type() const {");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
      const char *type = getIdealType(optype);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
      if( type != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
        Form::DataType data_type = oper->is_base_constant(_globalNames);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
        // Check if we are an ideal pointer type
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1239
        if( data_type == Form::idealP || data_type == Form::idealN ) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
          // Return the ideal type we already have: <TypePtr *>
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
          fprintf(fp," return _c0;");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
          // Return the appropriate bottom type
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
          fprintf(fp," return %s;", getIdealType(optype));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
        fprintf(fp," ShouldNotCallThis(); return Type::BOTTOM;");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
      fprintf(fp," }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
      // Check for user-defined stack slots, based upon sRegX
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
      Form::DataType data_type = oper->is_user_name_for_sReg();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
      if( data_type != Form::none ){
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
        const char *type = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
        switch( data_type ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
        case Form::idealI: type = "TypeInt::INT";   break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
        case Form::idealP: type = "TypePtr::BOTTOM";break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
        case Form::idealF: type = "Type::FLOAT";    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
        case Form::idealD: type = "Type::DOUBLE";   break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
        case Form::idealL: type = "TypeLong::LONG"; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
        case Form::none: // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
        default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
          assert( false, "No support for this type of stackSlot");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
        fprintf(fp,"  virtual const Type    *type() const { return %s; } // stackSlotX\n", type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
    // virtual functions for defining the encoding interface.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
    // Access the linearized ideal register mask,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
    // map to physical register encoding
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
    if ( oper->_matrule && oper->_matrule->is_base_register(_globalNames) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
      // Just use the default virtual 'reg' call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
    } else if ( oper->ideal_to_sReg_type(oper->_ident) != Form::none ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
      // Special handling for operand 'sReg', a Stack Slot Register.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
      // Map linearized ideal register mask to stack slot number
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
      fprintf(fp,"  virtual int            reg(PhaseRegAlloc *ra_, const Node *node) const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
      fprintf(fp,"    return (int)OptoReg::reg2stack(ra_->get_reg_first(node));/* sReg */\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
      fprintf(fp,"  }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
      fprintf(fp,"  virtual int            reg(PhaseRegAlloc *ra_, const Node *node, int idx) const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
      fprintf(fp,"    return (int)OptoReg::reg2stack(ra_->get_reg_first(node->in(idx)));/* sReg */\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
      fprintf(fp,"  }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
    // Output the operand specific access functions used by an enc_class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
    // These are only defined when we want to override the default virtual func
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
    if (oper->_interface != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
      fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
      // Check if it is a Memory Interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
      if ( oper->_interface->is_MemInterface() != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
        MemInterface *mem_interface = oper->_interface->is_MemInterface();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
        const char *base = mem_interface->_base;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
        if( base != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
          define_oper_interface(fp, *oper, _globalNames, "base", base);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
        char *index = mem_interface->_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
        if( index != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
          define_oper_interface(fp, *oper, _globalNames, "index", index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
        const char *scale = mem_interface->_scale;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
        if( scale != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
          define_oper_interface(fp, *oper, _globalNames, "scale", scale);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
        const char *disp = mem_interface->_disp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
        if( disp != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
          define_oper_interface(fp, *oper, _globalNames, "disp", disp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
          oper->disp_is_oop(fp, _globalNames);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
        if( oper->stack_slots_only(_globalNames) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
          // should not call this:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
          fprintf(fp,"  virtual int       constant_disp() const { return Type::OffsetBot; }");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
        } else if ( disp != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
          define_oper_interface(fp, *oper, _globalNames, "constant_disp", disp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
      } // end Memory Interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
      // Check if it is a Conditional Interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
      else if (oper->_interface->is_CondInterface() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
        CondInterface *cInterface = oper->_interface->is_CondInterface();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
        const char *equal = cInterface->_equal;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
        if( equal != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
          define_oper_interface(fp, *oper, _globalNames, "equal", equal);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
        const char *not_equal = cInterface->_not_equal;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
        if( not_equal != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
          define_oper_interface(fp, *oper, _globalNames, "not_equal", not_equal);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
        const char *less = cInterface->_less;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
        if( less != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
          define_oper_interface(fp, *oper, _globalNames, "less", less);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
        const char *greater_equal = cInterface->_greater_equal;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
        if( greater_equal != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
          define_oper_interface(fp, *oper, _globalNames, "greater_equal", greater_equal);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
        const char *less_equal = cInterface->_less_equal;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
        if( less_equal != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
          define_oper_interface(fp, *oper, _globalNames, "less_equal", less_equal);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
        const char *greater = cInterface->_greater;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
        if( greater != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
          define_oper_interface(fp, *oper, _globalNames, "greater", greater);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
      } // end Conditional Interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
      // Check if it is a Constant Interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
      else if (oper->_interface->is_ConstInterface() != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
        assert( oper->num_consts(_globalNames) == 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
                "Must have one constant when using CONST_INTER encoding");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
        if (!strcmp(oper->ideal_type(_globalNames), "ConI")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
          // Access the locally stored constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
          fprintf(fp,"  virtual intptr_t       constant() const {");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
          fprintf(fp,   " return (intptr_t)_c0;");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
          fprintf(fp,"  }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
        else if (!strcmp(oper->ideal_type(_globalNames), "ConP")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
          // Access the locally stored constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
          fprintf(fp,"  virtual intptr_t       constant() const {");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
          fprintf(fp,   " return _c0->get_con();");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
          fprintf(fp, " }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
          // Generate query to determine if this pointer is an oop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
          fprintf(fp,"  virtual bool           constant_is_oop() const {");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
          fprintf(fp,   " return _c0->isa_oop_ptr();");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
          fprintf(fp, " }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
        }
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1367
        else if (!strcmp(oper->ideal_type(_globalNames), "ConN")) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1368
          // Access the locally stored constant
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1369
          fprintf(fp,"  virtual intptr_t       constant() const {");
3180
c589129153a4 6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents: 2131
diff changeset
  1370
          fprintf(fp,   " return _c0->get_ptrtype()->get_con();");
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1371
          fprintf(fp, " }\n");
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1372
          // Generate query to determine if this pointer is an oop
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1373
          fprintf(fp,"  virtual bool           constant_is_oop() const {");
3180
c589129153a4 6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents: 2131
diff changeset
  1374
          fprintf(fp,   " return _c0->get_ptrtype()->isa_oop_ptr();");
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1375
          fprintf(fp, " }\n");
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1376
        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
        else if (!strcmp(oper->ideal_type(_globalNames), "ConL")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
          fprintf(fp,"  virtual intptr_t       constant() const {");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
          // We don't support addressing modes with > 4Gig offsets.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
          // Truncate to int.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
          fprintf(fp,   "  return (intptr_t)_c0;");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
          fprintf(fp, " }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
          fprintf(fp,"  virtual jlong          constantL() const {");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
          fprintf(fp,   " return _c0;");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
          fprintf(fp, " }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
        else if (!strcmp(oper->ideal_type(_globalNames), "ConF")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
          fprintf(fp,"  virtual intptr_t       constant() const {");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
          fprintf(fp,   " ShouldNotReachHere(); return 0; ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
          fprintf(fp, " }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
          fprintf(fp,"  virtual jfloat         constantF() const {");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
          fprintf(fp,   " return (jfloat)_c0;");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
          fprintf(fp, " }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
        else if (!strcmp(oper->ideal_type(_globalNames), "ConD")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
          fprintf(fp,"  virtual intptr_t       constant() const {");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
          fprintf(fp,   " ShouldNotReachHere(); return 0; ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
          fprintf(fp, " }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
          fprintf(fp,"  virtual jdouble        constantD() const {");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
          fprintf(fp,   " return _c0;");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
          fprintf(fp, " }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
      else if (oper->_interface->is_RegInterface() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
        // make sure that a fixed format string isn't used for an
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
        // operand which might be assiged to multiple registers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
        // Otherwise the opto assembly output could be misleading.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
        if (oper->_format->_strings.count() != 0 && !oper->is_bound_register()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
          syntax_err(oper->_linenum,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
                     "Only bound registers can have fixed formats: %s\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1411
                     oper->_ident);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
      else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
        assert( false, "ShouldNotReachHere();");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
    fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
    // // Currently all XXXOper::hash() methods are identical (990820)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
    // declare_hash(fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
    // // Currently all XXXOper::Cmp() methods are identical (990820)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
    // declare_cmp(fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
    // Do not place dump_spec() and Name() into PRODUCT code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
    // int_format and ext_format are not needed in PRODUCT code either
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
    fprintf(fp, "#ifndef PRODUCT\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
    // Declare int_format() and ext_format()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
    gen_oper_format(fp, _globalNames, *oper);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
    // Machine independent print functionality for debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
    // IF we have constants, create a dump_spec function for the derived class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
    // (1)  virtual void           dump_spec() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
    // (2)    st->print("#%d", _c#);        // Constant != ConP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
    //  OR    _c#->dump_on(st);             // Type ConP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
    //  ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
    // (3)  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
    uint num_consts = oper->num_consts(_globalNames);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
    if( num_consts > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
      // line (1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
      fprintf(fp, "  virtual void           dump_spec(outputStream *st) const {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
      // generate format string for st->print
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
      // Iterate over the component list & spit out the right thing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
      uint i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
      const char *type = oper->ideal_type(_globalNames);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
      Component  *comp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
      oper->_components.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
      if ((comp = oper->_components.iter()) == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
        assert(num_consts == 1, "Bad component list detected.\n");
1495
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
  1452
        i = dump_spec_constant( fp, type, i, oper );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
        // Check that type actually matched
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
        assert( i != 0, "Non-constant operand lacks component list.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
      } // end if NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
      else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
        // line (2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
        // dump all components
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
        oper->_components.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
        while((comp = oper->_components.iter()) != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
          type = comp->base_type(_globalNames);
1495
128fe18951ed 6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents: 1055
diff changeset
  1462
          i = dump_spec_constant( fp, type, i, NULL );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
      // finish line (3)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
      fprintf(fp,"  }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
    fprintf(fp,"  virtual const char    *Name() const { return \"%s\";}\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
            oper->_ident);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
    fprintf(fp,"#endif\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
    // Close definition of this XxxMachOper
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
    fprintf(fp,"};\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1477
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1478
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1479
  // Generate Machine Classes for each instruction defined in AD file
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
  fprintf(fp,"//----------------------------Declare classes for Pipelines-----------------\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
  declare_pipe_classes(fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
  // Generate Machine Classes for each instruction defined in AD file
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
  fprintf(fp,"//----------------------------Declare classes derived from MachNode----------\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
  _instructions.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
  InstructForm *instr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
  for( ; (instr = (InstructForm*)_instructions.iter()) != NULL; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
    // Ensure this is a machine-world instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
    if ( instr->ideal_only() ) continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
    // Build class definition for this instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
    fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
    fprintf(fp,"class %sNode : public %s { \n",
5536
f23c4e2e0d5e 6953576: bottom_type for matched AddPNodes doesn't always agree with ideal
never
parents: 4751
diff changeset
  1496
            instr->_ident, instr->mach_base_class(_globalNames) );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
    fprintf(fp,"private:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
    fprintf(fp,"  MachOper *_opnd_array[%d];\n", instr->num_opnds() );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
    if ( instr->is_ideal_jump() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
      fprintf(fp, "  GrowableArray<Label*> _index2label;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
    fprintf(fp,"public:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
    fprintf(fp,"  MachOper *opnd_array(uint operand_index) const { assert(operand_index < _num_opnds, \"invalid _opnd_array index\"); return _opnd_array[operand_index]; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
    fprintf(fp,"  void      set_opnd_array(uint operand_index, MachOper *operand) { assert(operand_index < _num_opnds, \"invalid _opnd_array index\"); _opnd_array[operand_index] = operand; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
    fprintf(fp,"private:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
    if ( instr->is_ideal_jump() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
      fprintf(fp,"  virtual void           add_case_label(int index_num, Label* blockLabel) {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
      fprintf(fp,"                                          _index2label.at_put_grow(index_num, blockLabel);}\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
    if( can_cisc_spill() && (instr->cisc_spill_alternate() != NULL) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
      fprintf(fp,"  const RegMask  *_cisc_RegMask;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
    out_RegMask(fp);                      // output register mask
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
    fprintf(fp,"  virtual uint           rule() const { return %s_rule; }\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
            instr->_ident);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
    // If this instruction contains a labelOper
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
    // Declare Node::methods that set operand Label's contents
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
    int label_position = instr->label_position();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
    if( label_position != -1 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
      // Set the label, stored in labelOper::_branch_label
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
      fprintf(fp,"  virtual void           label_set( Label& label, uint block_num );\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
    // If this instruction contains a methodOper
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
    // Declare Node::methods that set operand method's contents
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
    int method_position = instr->method_position();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
    if( method_position != -1 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1530
      // Set the address method, stored in methodOper::_method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
      fprintf(fp,"  virtual void           method_set( intptr_t method );\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1534
    // virtual functions for attributes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
    // Each instruction attribute results in a virtual call of same name.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
    // The ins_cost is not handled here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
    Attribute *attr = instr->_attribs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
    bool is_pc_relative = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
    while (attr != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
      if (strcmp(attr->_ident,"ins_cost") &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
          strcmp(attr->_ident,"ins_pc_relative")) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
        fprintf(fp,"  int             %s() const { return %s; }\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
                attr->_ident, attr->_val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
      // Check value for ins_pc_relative, and if it is true (1), set the flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
      if (!strcmp(attr->_ident,"ins_pc_relative") && attr->int_val(*this) != 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
        is_pc_relative = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
      attr = (Attribute *)attr->_next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1550
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
    // virtual functions for encode and format
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
    // Output the opcode function and the encode function here using the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
    // encoding class information in the _insencode slot.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
    if ( instr->_insencode ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
      fprintf(fp,"  virtual void           emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
    // virtual function for getting the size of an instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
    if ( instr->_size ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
       fprintf(fp,"  virtual uint           size(PhaseRegAlloc *ra_) const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
    // Return the top-level ideal opcode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
    // Use MachNode::ideal_Opcode() for nodes based on MachNode class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
    // if the ideal_Opcode == Op_Node.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
    if ( strcmp("Node", instr->ideal_Opcode(_globalNames)) != 0 ||
5536
f23c4e2e0d5e 6953576: bottom_type for matched AddPNodes doesn't always agree with ideal
never
parents: 4751
diff changeset
  1569
         strcmp("MachNode", instr->mach_base_class(_globalNames)) != 0 ) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
      fprintf(fp,"  virtual int            ideal_Opcode() const { return Op_%s; }\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
            instr->ideal_Opcode(_globalNames) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
    // Allow machine-independent optimization, invert the sense of the IF test
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
    if( instr->is_ideal_if() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
      fprintf(fp,"  virtual void           negate() { \n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
      // Identify which operand contains the negate(able) ideal condition code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
      int   idx = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
      instr->_components.reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
      for( Component *comp; (comp = instr->_components.iter()) != NULL; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
        // Check that component is an operand
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
        Form *form = (Form*)_globalNames[comp->_type];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
        OperandForm *opForm = form ? form->is_operand() : NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
        if( opForm == NULL ) continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
        // Lookup the position of the operand in the instruction.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
        if( opForm->is_ideal_bool() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
          idx = instr->operand_position(comp->_name, comp->_usedef);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
          assert( idx != NameList::Not_in_list, "Did not find component in list that contained it.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
      fprintf(fp,"    opnd_array(%d)->negate();\n", idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
      fprintf(fp,"    _prob = 1.0f - _prob;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
      fprintf(fp,"  };\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
    // Identify which input register matches the input register.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
    uint  matching_input = instr->two_address(_globalNames);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
    // Generate the method if it returns != 0 otherwise use MachNode::two_adr()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
    if( matching_input != 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
      fprintf(fp,"  virtual uint           two_adr() const  ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
      fprintf(fp,"{ return oper_input_base()");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
      for( uint i = 2; i <= matching_input; i++ )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
        fprintf(fp," + opnd_array(%d)->num_edges()",i-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
      fprintf(fp,"; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
    // Declare cisc_version, if applicable
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
    //   MachNode *cisc_version( int offset /* ,... */ );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
    instr->declare_cisc_version(*this, fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
    // If there is an explicit peephole rule, build it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
    if ( instr->peepholes() != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
      fprintf(fp,"  virtual MachNode      *peephole(Block *block, int block_index, PhaseRegAlloc *ra_, int &deleted, Compile *C);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
    // Output the declaration for number of relocation entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
    if ( instr->reloc(_globalNames) != 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
      fprintf(fp,"  virtual int            reloc()   const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
    if (instr->alignment() != 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
      fprintf(fp,"  virtual int            alignment_required()   const { return %d; }\n", instr->alignment());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
      fprintf(fp,"  virtual int            compute_padding(int current_offset)   const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
    // Starting point for inputs matcher wants.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
    // Use MachNode::oper_input_base() for nodes based on MachNode class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
    // if the base == 1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
    if ( instr->oper_input_base(_globalNames) != 1 ||
5536
f23c4e2e0d5e 6953576: bottom_type for matched AddPNodes doesn't always agree with ideal
never
parents: 4751
diff changeset
  1634
         strcmp("MachNode", instr->mach_base_class(_globalNames)) != 0 ) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
      fprintf(fp,"  virtual uint           oper_input_base() const { return %d; }\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
            instr->oper_input_base(_globalNames));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1638
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
    // Make the constructor and following methods 'public:'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
    fprintf(fp,"public:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
    // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
    if ( instr->is_ideal_jump() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
      fprintf(fp,"  %sNode() : _index2label(MinJumpTableSize*2) { ", instr->_ident);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
      fprintf(fp,"  %sNode() { ", instr->_ident);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1647
      if( can_cisc_spill() && (instr->cisc_spill_alternate() != NULL) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
        fprintf(fp,"_cisc_RegMask = NULL; ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1649
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1651
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1652
    fprintf(fp," _num_opnds = %d; _opnds = _opnd_array; ", instr->num_opnds());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1653
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
    bool node_flags_set = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
    // flag: if this instruction matches an ideal 'Goto' node
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
    if ( instr->is_ideal_goto() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
      fprintf(fp,"init_flags(Flag_is_Goto");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1658
      node_flags_set = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1659
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1660
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
    // flag: if this instruction matches an ideal 'Copy*' node
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
    if ( instr->is_ideal_copy() != 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
      if ( node_flags_set ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
        fprintf(fp," | Flag_is_Copy");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1665
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1666
        fprintf(fp,"init_flags(Flag_is_Copy");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1667
        node_flags_set = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1668
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1669
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
    // Is an instruction is a constant?  If so, get its type
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1672
    Form::DataType  data_type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
    const char     *opType = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1674
    const char     *result = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
    data_type    = instr->is_chain_of_constant(_globalNames, opType, result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1676
    // Check if this instruction is a constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
    if ( data_type != Form::none ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
      if ( node_flags_set ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
        fprintf(fp," | Flag_is_Con");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
        fprintf(fp,"init_flags(Flag_is_Con");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
        node_flags_set = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1684
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1685
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1686
    // flag: if instruction matches 'If' | 'Goto' | 'CountedLoopEnd | 'Jump'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1687
    if ( instr->is_ideal_branch() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1688
      if ( node_flags_set ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1689
        fprintf(fp," | Flag_is_Branch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1690
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1691
        fprintf(fp,"init_flags(Flag_is_Branch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1692
        node_flags_set = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1693
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1694
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
    // flag: if this instruction is cisc alternate
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
    if ( can_cisc_spill() && instr->is_cisc_alternate() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
      if ( node_flags_set ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
        fprintf(fp," | Flag_is_cisc_alternate");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1700
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1701
        fprintf(fp,"init_flags(Flag_is_cisc_alternate");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1702
        node_flags_set = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1704
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1705
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1706
    // flag: if this instruction is pc relative
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
    if ( is_pc_relative ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1708
      if ( node_flags_set ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1709
        fprintf(fp," | Flag_is_pc_relative");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1710
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
        fprintf(fp,"init_flags(Flag_is_pc_relative");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
        node_flags_set = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1713
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1715
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1716
    // flag: if this instruction has short branch form
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1717
    if ( instr->has_short_branch_form() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1718
      if ( node_flags_set ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1719
        fprintf(fp," | Flag_may_be_short_branch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1720
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1721
        fprintf(fp,"init_flags(Flag_may_be_short_branch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1722
        node_flags_set = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
    // Check if machine instructions that USE memory, but do not DEF memory,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1727
    // depend upon a node that defines memory in machine-independent graph.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1728
    if ( instr->needs_anti_dependence_check(_globalNames) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
      if ( node_flags_set ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
        fprintf(fp," | Flag_needs_anti_dependence_check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1732
        fprintf(fp,"init_flags(Flag_needs_anti_dependence_check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
        node_flags_set = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1735
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1736
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1737
    if ( node_flags_set ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
      fprintf(fp,"); ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1739
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1740
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1741
    if (instr->is_ideal_unlock() || instr->is_ideal_call_leaf()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1742
      fprintf(fp,"clear_flag(Flag_is_safepoint_node); ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1743
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1745
    fprintf(fp,"}\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1746
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1747
    // size_of, used by base class's clone to obtain the correct size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1748
    fprintf(fp,"  virtual uint           size_of() const {");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1749
    fprintf(fp,   " return sizeof(%sNode);", instr->_ident);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1750
    fprintf(fp, " }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1751
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1752
    // Virtual methods which are only generated to override base class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1753
    if( instr->expands() || instr->needs_projections() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
        instr->has_temps() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
        instr->_matrule != NULL &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1756
        instr->num_opnds() != instr->num_unique_opnds() ) {
4751
9418f690831d 6916644: C2 compiler crash on x86
never
parents: 3180
diff changeset
  1757
      fprintf(fp,"  virtual MachNode      *Expand(State *state, Node_List &proj_list, Node* mem);\n");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1759
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1760
    if (instr->is_pinned(_globalNames)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1761
      fprintf(fp,"  virtual bool           pinned() const { return ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1762
      if (instr->is_parm(_globalNames)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
        fprintf(fp,"_in[0]->pinned();");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
        fprintf(fp,"true;");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
      fprintf(fp," }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1769
    if (instr->is_projection(_globalNames)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1770
      fprintf(fp,"  virtual const Node *is_block_proj() const { return this; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1771
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1772
    if ( instr->num_post_match_opnds() != 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1773
         || instr->is_chain_of_constant(_globalNames) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1774
      fprintf(fp,"  friend MachNode *State::MachNodeGenerator(int opcode, Compile* C);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1775
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
    if ( instr->rematerialize(_globalNames, get_registers()) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
      fprintf(fp,"  // Rematerialize %s\n", instr->_ident);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1778
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1779
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1780
    // Declare short branch methods, if applicable
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1781
    instr->declare_short_branch_methods(fp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1782
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
    // Instructions containing a constant that will be entered into the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1784
    // float/double table redefine the base virtual function
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1785
#ifdef SPARC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1786
    // Sparc doubles entries in the constant table require more space for
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1787
    // alignment. (expires 9/98)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1788
    int table_entries = (3 * instr->num_consts( _globalNames, Form::idealD ))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
      + instr->num_consts( _globalNames, Form::idealF );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1790
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
    int table_entries = instr->num_consts( _globalNames, Form::idealD )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
      + instr->num_consts( _globalNames, Form::idealF );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1793
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1794
    if( table_entries != 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1795
      fprintf(fp,"  virtual int            const_size() const {");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
      fprintf(fp,   " return %d;", table_entries);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
      fprintf(fp, " }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1798
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1799
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1800
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1801
    // See if there is an "ins_pipe" declaration for this instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1802
    if (instr->_ins_pipe) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1803
      fprintf(fp,"  static  const Pipeline *pipeline_class();\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1804
      fprintf(fp,"  virtual const Pipeline *pipeline() const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1805
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1806
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1807
    // Generate virtual function for MachNodeX::bottom_type when necessary
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1808
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1809
    // Note on accuracy:  Pointer-types of machine nodes need to be accurate,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1810
    // or else alias analysis on the matched graph may produce bad code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1811
    // Moreover, the aliasing decisions made on machine-node graph must be
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1812
    // no less accurate than those made on the ideal graph, or else the graph
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1813
    // may fail to schedule.  (Reason:  Memory ops which are reordered in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1814
    // the ideal graph might look interdependent in the machine graph,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1815
    // thereby removing degrees of scheduling freedom that the optimizer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1816
    // assumed would be available.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1817
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1818
    // %%% We should handle many of these cases with an explicit ADL clause:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1819
    // instruct foo() %{ ... bottom_type(TypeRawPtr::BOTTOM); ... %}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1820
    if( data_type != Form::none ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1821
      // A constant's bottom_type returns a Type containing its constant value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1822
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1823
      // !!!!!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1824
      // Convert all ints, floats, ... to machine-independent TypeXs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1825
      // as is done for pointers
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1826
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1827
      // Construct appropriate constant type containing the constant value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1828
      fprintf(fp,"  virtual const class Type *bottom_type() const{\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1829
      switch( data_type ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1830
      case Form::idealI:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1831
        fprintf(fp,"    return  TypeInt::make(opnd_array(1)->constant());\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1832
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1833
      case Form::idealP:
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1834
      case Form::idealN:
2129
e810a33b5c67 6778669: Patch from Red Hat -- fixes compilation errors
twisti
parents: 1497
diff changeset
  1835
        fprintf(fp,"    return  opnd_array(1)->type();\n");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1836
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1837
      case Form::idealD:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1838
        fprintf(fp,"    return  TypeD::make(opnd_array(1)->constantD());\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1839
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1840
      case Form::idealF:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1841
        fprintf(fp,"    return  TypeF::make(opnd_array(1)->constantF());\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1842
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1843
      case Form::idealL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1844
        fprintf(fp,"    return  TypeLong::make(opnd_array(1)->constantL());\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1845
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1846
      default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1847
        assert( false, "Unimplemented()" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
      fprintf(fp,"  };\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
/*    else if ( instr->_matrule && instr->_matrule->_rChild &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
        (  strcmp("ConvF2I",instr->_matrule->_rChild->_opType)==0
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1854
        || strcmp("ConvD2I",instr->_matrule->_rChild->_opType)==0 ) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1855
      // !!!!! !!!!!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1856
      // Provide explicit bottom type for conversions to int
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1857
      // On Intel the result operand is a stackSlot, untyped.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1858
      fprintf(fp,"  virtual const class Type *bottom_type() const{");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1859
      fprintf(fp,   " return  TypeInt::INT;");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1860
      fprintf(fp, " };\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1861
    }*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1862
    else if( instr->is_ideal_copy() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1863
              !strcmp(instr->_matrule->_lChild->_opType,"stackSlotP") ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1864
      // !!!!!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1865
      // Special hack for ideal Copy of pointer.  Bottom type is oop or not depending on input.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1866
      fprintf(fp,"  const Type            *bottom_type() const { return in(1)->bottom_type(); } // Copy?\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1867
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1868
    else if( instr->is_ideal_loadPC() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1869
      // LoadPCNode provides the return address of a call to native code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1870
      // Define its bottom type to be TypeRawPtr::BOTTOM instead of TypePtr::BOTTOM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1871
      // since it is a pointer to an internal VM location and must have a zero offset.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1872
      // Allocation detects derived pointers, in part, by their non-zero offsets.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1873
      fprintf(fp,"  const Type            *bottom_type() const { return TypeRawPtr::BOTTOM; } // LoadPC?\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1874
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1875
    else if( instr->is_ideal_box() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1876
      // BoxNode provides the address of a stack slot.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1877
      // Define its bottom type to be TypeRawPtr::BOTTOM instead of TypePtr::BOTTOM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1878
      // This prevent s insert_anti_dependencies from complaining. It will
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1879
      // complain if it see that the pointer base is TypePtr::BOTTOM since
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1880
      // it doesn't understand what that might alias.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1881
      fprintf(fp,"  const Type            *bottom_type() const { return TypeRawPtr::BOTTOM; } // Box?\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1882
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1883
    else if( instr->_matrule && instr->_matrule->_rChild && !strcmp(instr->_matrule->_rChild->_opType,"CMoveP") ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1884
      int offset = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1885
      // Special special hack to see if the Cmp? has been incorporated in the conditional move
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1886
      MatchNode *rl = instr->_matrule->_rChild->_lChild;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1887
      if( rl && !strcmp(rl->_opType, "Binary") ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
          MatchNode *rlr = rl->_rChild;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1889
          if (rlr && strncmp(rlr->_opType, "Cmp", 3) == 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1890
            offset = 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1891
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1892
      // Special hack for ideal CMoveP; ideal type depends on inputs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1893
      fprintf(fp,"  const Type            *bottom_type() const { const Type *t = in(oper_input_base()+%d)->bottom_type(); return (req() <= oper_input_base()+%d) ? t : t->meet(in(oper_input_base()+%d)->bottom_type()); } // CMoveP\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1894
        offset, offset+1, offset+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1895
    }
1055
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 670
diff changeset
  1896
    else if( instr->_matrule && instr->_matrule->_rChild && !strcmp(instr->_matrule->_rChild->_opType,"CMoveN") ) {
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 670
diff changeset
  1897
      int offset = 1;
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 670
diff changeset
  1898
      // Special special hack to see if the Cmp? has been incorporated in the conditional move
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 670
diff changeset
  1899
      MatchNode *rl = instr->_matrule->_rChild->_lChild;
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 670
diff changeset
  1900
      if( rl && !strcmp(rl->_opType, "Binary") ) {
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 670
diff changeset
  1901
          MatchNode *rlr = rl->_rChild;
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 670
diff changeset
  1902
          if (rlr && strncmp(rlr->_opType, "Cmp", 3) == 0)
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 670
diff changeset
  1903
            offset = 2;
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 670
diff changeset
  1904
      }
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 670
diff changeset
  1905
      // Special hack for ideal CMoveN; ideal type depends on inputs
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 670
diff changeset
  1906
      fprintf(fp,"  const Type            *bottom_type() const { const Type *t = in(oper_input_base()+%d)->bottom_type(); return (req() <= oper_input_base()+%d) ? t : t->meet(in(oper_input_base()+%d)->bottom_type()); } // CMoveN\n",
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 670
diff changeset
  1907
        offset, offset+1, offset+1);
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 670
diff changeset
  1908
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1909
    else if (instr->is_tls_instruction()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1910
      // Special hack for tlsLoadP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1911
      fprintf(fp,"  const Type            *bottom_type() const { return TypeRawPtr::BOTTOM; } // tlsLoadP\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1912
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1913
    else if ( instr->is_ideal_if() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1914
      fprintf(fp,"  const Type            *bottom_type() const { return TypeTuple::IFBOTH; } // matched IfNode\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1915
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1916
    else if ( instr->is_ideal_membar() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1917
      fprintf(fp,"  const Type            *bottom_type() const { return TypeTuple::MEMBAR; } // matched MemBar\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1918
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1919
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1920
    // Check where 'ideal_type' must be customized
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1921
    /*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1922
    if ( instr->_matrule && instr->_matrule->_rChild &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1923
        (  strcmp("ConvF2I",instr->_matrule->_rChild->_opType)==0
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1924
        || strcmp("ConvD2I",instr->_matrule->_rChild->_opType)==0 ) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1925
      fprintf(fp,"  virtual uint           ideal_reg() const { return Compile::current()->matcher()->base2reg[Type::Int]; }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1926
    }*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1927
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1928
    // Analyze machine instructions that either USE or DEF memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1929
    int memory_operand = instr->memory_operand(_globalNames);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1930
    // Some guys kill all of memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1931
    if ( instr->is_wide_memory_kill(_globalNames) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1932
      memory_operand = InstructForm::MANY_MEMORY_OPERANDS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1933
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1934
    if ( memory_operand != InstructForm::NO_MEMORY_OPERAND ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1935
      if( memory_operand == InstructForm::MANY_MEMORY_OPERANDS ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1936
        fprintf(fp,"  virtual const TypePtr *adr_type() const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1937
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1938
      fprintf(fp,"  virtual const MachOper *memory_operand() const;\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1939
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1940
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1941
    fprintf(fp, "#ifndef PRODUCT\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1942
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1943
    // virtual function for generating the user's assembler output
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1944
    gen_inst_format(fp, _globalNames,*instr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1945
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1946
    // Machine independent print functionality for debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1947
    fprintf(fp,"  virtual const char    *Name() const { return \"%s\";}\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1948
            instr->_ident);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1949
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1950
    fprintf(fp, "#endif\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1951
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1952
    // Close definition of this XxxMachNode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1953
    fprintf(fp,"};\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1954
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1955
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1956
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1957
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1958
void ArchDesc::defineStateClass(FILE *fp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1959
  static const char *state__valid    = "_valid[((uint)index) >> 5] &  (0x1 << (((uint)index) & 0x0001F))";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1960
  static const char *state__set_valid= "_valid[((uint)index) >> 5] |= (0x1 << (((uint)index) & 0x0001F))";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1961
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1962
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1963
  fprintf(fp,"// MACROS to inline and constant fold State::valid(index)...\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1964
  fprintf(fp,"// when given a constant 'index' in dfa_<arch>.cpp\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1965
  fprintf(fp,"//   uint word   = index >> 5;       // Shift out bit position\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1966
  fprintf(fp,"//   uint bitpos = index & 0x0001F;  // Mask off word bits\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1967
  fprintf(fp,"#define STATE__VALID(index) ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1968
  fprintf(fp,"    (%s)\n", state__valid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1969
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1970
  fprintf(fp,"#define STATE__NOT_YET_VALID(index) ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1971
  fprintf(fp,"  ( (%s) == 0 )\n", state__valid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1972
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1973
  fprintf(fp,"#define STATE__VALID_CHILD(state,index) ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1974
  fprintf(fp,"  ( state && (state->%s) )\n", state__valid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1975
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1976
  fprintf(fp,"#define STATE__SET_VALID(index) ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1977
  fprintf(fp,"  (%s)\n", state__set_valid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1978
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1979
  fprintf(fp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1980
          "//---------------------------State-------------------------------------------\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1981
  fprintf(fp,"// State contains an integral cost vector, indexed by machine operand opcodes,\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1982
  fprintf(fp,"// a rule vector consisting of machine operand/instruction opcodes, and also\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1983
  fprintf(fp,"// indexed by machine operand opcodes, pointers to the children in the label\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1984
  fprintf(fp,"// tree generated by the Label routines in ideal nodes (currently limited to\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1985
  fprintf(fp,"// two for convenience, but this could change).\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1986
  fprintf(fp,"class State : public ResourceObj {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1987
  fprintf(fp,"public:\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1988
  fprintf(fp,"  int    _id;         // State identifier\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1989
  fprintf(fp,"  Node  *_leaf;       // Ideal (non-machine-node) leaf of match tree\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1990
  fprintf(fp,"  State *_kids[2];       // Children of state node in label tree\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1991
  fprintf(fp,"  unsigned int _cost[_LAST_MACH_OPER];  // Cost vector, indexed by operand opcodes\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1992
  fprintf(fp,"  unsigned int _rule[_LAST_MACH_OPER];  // Rule vector, indexed by operand opcodes\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1993
  fprintf(fp,"  unsigned int _valid[(_LAST_MACH_OPER/32)+1]; // Bit Map of valid Cost/Rule entries\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1994
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1995
  fprintf(fp,"  State(void);                      // Constructor\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1996
  fprintf(fp,"  DEBUG_ONLY( ~State(void); )       // Destructor\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1997
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1998
  fprintf(fp,"  // Methods created by ADLC and invoked by Reduce\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1999
  fprintf(fp,"  MachOper *MachOperGenerator( int opcode, Compile* C );\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2000
  fprintf(fp,"  MachNode *MachNodeGenerator( int opcode, Compile* C );\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2001
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2002
  fprintf(fp,"  // Assign a state to a node, definition of method produced by ADLC\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2003
  fprintf(fp,"  bool DFA( int opcode, const Node *ideal );\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2004
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2005
  fprintf(fp,"  // Access function for _valid bit vector\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2006
  fprintf(fp,"  bool valid(uint index) {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2007
  fprintf(fp,"    return( STATE__VALID(index) != 0 );\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2008
  fprintf(fp,"  }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2009
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2010
  fprintf(fp,"  // Set function for _valid bit vector\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2011
  fprintf(fp,"  void set_valid(uint index) {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2012
  fprintf(fp,"    STATE__SET_VALID(index);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2013
  fprintf(fp,"  }\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2014
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2015
  fprintf(fp,"#ifndef PRODUCT\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2016
  fprintf(fp,"  void dump();                // Debugging prints\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2017
  fprintf(fp,"  void dump(int depth);\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2018
  fprintf(fp,"#endif\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2019
  if (_dfa_small) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2020
    // Generate the routine name we'll need
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2021
    for (int i = 1; i < _last_opcode; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2022
      if (_mlistab[i] == NULL) continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2023
      fprintf(fp, "  void  _sub_Op_%s(const Node *n);\n", NodeClassNames[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2024
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2025
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2026
  fprintf(fp,"};\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2027
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2028
  fprintf(fp,"\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2029
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2030
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2031
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2032
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2033
//---------------------------buildMachOperEnum---------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2034
// Build enumeration for densely packed operands.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2035
// This enumeration is used to index into the arrays in the State objects
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2036
// that indicate cost and a successfull rule match.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2037
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2038
// Information needed to generate the ReduceOp mapping for the DFA
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2039
class OutputMachOperands : public OutputMap {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2040
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2041
  OutputMachOperands(FILE *hpp, FILE *cpp, FormDict &globals, ArchDesc &AD)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2042
    : OutputMap(hpp, cpp, globals, AD) {};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2043
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2044
  void declaration() { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2045
  void definition()  { fprintf(_cpp, "enum MachOperands {\n"); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2046
  void closing()     { fprintf(_cpp, "  _LAST_MACH_OPER\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2047
                       OutputMap::closing();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2048
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2049
  void map(OpClassForm &opc)  { fprintf(_cpp, "  %s", _AD.machOperEnum(opc._ident) ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2050
  void map(OperandForm &oper) { fprintf(_cpp, "  %s", _AD.machOperEnum(oper._ident) ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2051
  void map(char        *name) { fprintf(_cpp, "  %s", _AD.machOperEnum(name)); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2052
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2053
  bool do_instructions()      { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2054
  void map(InstructForm &inst){ assert( false, "ShouldNotCallThis()"); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2055
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2056
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2057
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2058
void ArchDesc::buildMachOperEnum(FILE *fp_hpp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2059
  // Construct the table for MachOpcodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2060
  OutputMachOperands output_mach_operands(fp_hpp, fp_hpp, _globalNames, *this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2061
  build_map(output_mach_operands);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2062
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2063
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2064
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2065
//---------------------------buildMachEnum----------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2066
// Build enumeration for all MachOpers and all MachNodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2067
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2068
// Information needed to generate the ReduceOp mapping for the DFA
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2069
class OutputMachOpcodes : public OutputMap {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2070
  int begin_inst_chain_rule;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2071
  int end_inst_chain_rule;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2072
  int begin_rematerialize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2073
  int end_rematerialize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2074
  int end_instructions;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2075
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2076
  OutputMachOpcodes(FILE *hpp, FILE *cpp, FormDict &globals, ArchDesc &AD)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2077
    : OutputMap(hpp, cpp, globals, AD),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2078
      begin_inst_chain_rule(-1), end_inst_chain_rule(-1), end_instructions(-1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2079
  {};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2080
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2081
  void declaration() { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2082
  void definition()  { fprintf(_cpp, "enum MachOpcodes {\n"); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2083
  void closing()     {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2084
    if( begin_inst_chain_rule != -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2085
      fprintf(_cpp, "  _BEGIN_INST_CHAIN_RULE = %d,\n", begin_inst_chain_rule);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2086
    if( end_inst_chain_rule   != -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2087
      fprintf(_cpp, "  _END_INST_CHAIN_RULE  = %d,\n", end_inst_chain_rule);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2088
    if( begin_rematerialize   != -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2089
      fprintf(_cpp, "  _BEGIN_REMATERIALIZE   = %d,\n", begin_rematerialize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2090
    if( end_rematerialize     != -1 )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2091
      fprintf(_cpp, "  _END_REMATERIALIZE    = %d,\n", end_rematerialize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2092
    // always execute since do_instructions() is true, and avoids trailing comma
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2093
    fprintf(_cpp, "  _last_Mach_Node  = %d \n",  end_instructions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2094
    OutputMap::closing();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2095
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2096
  void map(OpClassForm &opc)  { fprintf(_cpp, "  %s_rule", opc._ident ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2097
  void map(OperandForm &oper) { fprintf(_cpp, "  %s_rule", oper._ident ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2098
  void map(char        *name) { if (name) fprintf(_cpp, "  %s_rule", name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2099
                                else      fprintf(_cpp, "  0"); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2100
  void map(InstructForm &inst) {fprintf(_cpp, "  %s_rule", inst._ident ); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2101
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2102
  void record_position(OutputMap::position place, int idx ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2103
    switch(place) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2104
    case OutputMap::BEGIN_INST_CHAIN_RULES :
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2105
      begin_inst_chain_rule = idx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2106
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2107
    case OutputMap::END_INST_CHAIN_RULES :
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2108
      end_inst_chain_rule   = idx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2109
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2110
    case OutputMap::BEGIN_REMATERIALIZE :
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2111
      begin_rematerialize   = idx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2112
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2113
    case OutputMap::END_REMATERIALIZE :
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2114
      end_rematerialize     = idx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2115
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2116
    case OutputMap::END_INSTRUCTIONS :
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2117
      end_instructions      = idx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2118
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2119
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2120
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2121
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2122
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2123
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2124
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2125
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2126
void ArchDesc::buildMachOpcodesEnum(FILE *fp_hpp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2127
  // Construct the table for MachOpcodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2128
  OutputMachOpcodes output_mach_opcodes(fp_hpp, fp_hpp, _globalNames, *this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2129
  build_map(output_mach_opcodes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2130
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2131
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2132
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2133
// Generate an enumeration of the pipeline states, and both
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2134
// the functional units (resources) and the masks for
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2135
// specifying resources
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2136
void ArchDesc::build_pipeline_enums(FILE *fp_hpp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2137
  int stagelen = (int)strlen("undefined");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2138
  int stagenum = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2139
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2140
  if (_pipeline) {              // Find max enum string length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2141
    const char *stage;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2142
    for ( _pipeline->_stages.reset(); (stage = _pipeline->_stages.iter()) != NULL; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2143
      int len = (int)strlen(stage);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2144
      if (stagelen < len) stagelen = len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2145
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2146
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2147
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2148
  // Generate a list of stages
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2149
  fprintf(fp_hpp, "\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2150
  fprintf(fp_hpp, "// Pipeline Stages\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2151
  fprintf(fp_hpp, "enum machPipelineStages {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2152
  fprintf(fp_hpp, "   stage_%-*s = 0,\n", stagelen, "undefined");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2153
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2154
  if( _pipeline ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2155
    const char *stage;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2156
    for ( _pipeline->_stages.reset(); (stage = _pipeline->_stages.iter()) != NULL; )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2157
      fprintf(fp_hpp, "   stage_%-*s = %d,\n", stagelen, stage, ++stagenum);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2158
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2159
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2160
  fprintf(fp_hpp, "   stage_%-*s = %d\n", stagelen, "count", stagenum);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2161
  fprintf(fp_hpp, "};\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2162
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2163
  fprintf(fp_hpp, "\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2164
  fprintf(fp_hpp, "// Pipeline Resources\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2165
  fprintf(fp_hpp, "enum machPipelineResources {\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2166
  int rescount = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2167
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2168
  if( _pipeline ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2169
    const char *resource;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2170
    int reslen = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2171
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2172
    // Generate a list of resources, and masks
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2173
    for ( _pipeline->_reslist.reset(); (resource = _pipeline->_reslist.iter()) != NULL; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2174
      int len = (int)strlen(resource);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2175
      if (reslen < len)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2176
        reslen = len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2177
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2178
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2179
    for ( _pipeline->_reslist.reset(); (resource = _pipeline->_reslist.iter()) != NULL; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2180
      const ResourceForm *resform = _pipeline->_resdict[resource]->is_resource();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2181
      int mask = resform->mask();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2182
      if ((mask & (mask-1)) == 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2183
        fprintf(fp_hpp, "   resource_%-*s = %d,\n", reslen, resource, rescount++);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2184
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2185
    fprintf(fp_hpp, "\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2186
    for ( _pipeline->_reslist.reset(); (resource = _pipeline->_reslist.iter()) != NULL; ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2187
      const ResourceForm *resform = _pipeline->_resdict[resource]->is_resource();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2188
      fprintf(fp_hpp, "   res_mask_%-*s = 0x%08x,\n", reslen, resource, resform->mask());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2189
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2190
    fprintf(fp_hpp, "\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2191
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2192
  fprintf(fp_hpp, "   resource_count = %d\n", rescount);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2193
  fprintf(fp_hpp, "};\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2194
}