Mercurial > jdk8-mips64-public > hotspot / changeset

     1.1 --- a/src/share/vm/adlc/output_c.cpp	Thu Apr 04 21:15:43 2013 -0700
     1.2 +++ b/src/share/vm/adlc/output_c.cpp	Fri Apr 05 11:09:43 2013 +0200
     1.3 @@ -63,11 +63,10 @@
     1.4      RegDef *reg_def = NULL;
     1.5      RegDef *next = NULL;
     1.6      registers->reset_RegDefs();
     1.7 -    for( reg_def = registers->iter_RegDefs(); reg_def != NULL; reg_def = next ) {
     1.8 +    for (reg_def = registers->iter_RegDefs(); reg_def != NULL; reg_def = next) {
     1.9        next = registers->iter_RegDefs();
    1.10        const char *comma = (next != NULL) ? "," : " // no trailing comma";
    1.11 -      fprintf(fp,"  \"%s\"%s\n",
    1.12 -                 reg_def->_regname, comma );
    1.13 +      fprintf(fp,"  \"%s\"%s\n", reg_def->_regname, comma);
    1.14      }
    1.15  
    1.16      // Finish defining enumeration
    1.17 @@ -79,10 +78,10 @@
    1.18      reg_def = NULL;
    1.19      next = NULL;
    1.20      registers->reset_RegDefs();
    1.21 -    for( reg_def = registers->iter_RegDefs(); reg_def != NULL; reg_def = next ) {
    1.22 +    for (reg_def = registers->iter_RegDefs(); reg_def != NULL; reg_def = next) {
    1.23        next = registers->iter_RegDefs();
    1.24        const char *comma = (next != NULL) ? "," : " // no trailing comma";
    1.25 -      fprintf(fp,"\t%s%s\n", reg_def->_concrete, comma );
    1.26 +      fprintf(fp,"\t%s%s\n", reg_def->_concrete, comma);
    1.27      }
    1.28      // Finish defining array
    1.29      fprintf(fp,"\t};\n");
    1.30 @@ -104,19 +103,17 @@
    1.31      RegDef *reg_def = NULL;
    1.32      RegDef *next    = NULL;
    1.33      registers->reset_RegDefs();
    1.34 -    for( reg_def = registers->iter_RegDefs(); reg_def != NULL; reg_def = next ) {
    1.35 +    for (reg_def = registers->iter_RegDefs(); reg_def != NULL; reg_def = next) {
    1.36        next = registers->iter_RegDefs();
    1.37        const char* register_encode = reg_def->register_encode();
    1.38        const char *comma = (next != NULL) ? "," : " // no trailing comma";
    1.39        int encval;
    1.40        if (!ADLParser::is_int_token(register_encode, encval)) {
    1.41 -        fprintf(fp,"  %s%s  // %s\n",
    1.42 -                register_encode, comma, reg_def->_regname );
    1.43 +        fprintf(fp,"  %s%s  // %s\n", register_encode, comma, reg_def->_regname);
    1.44        } else {
    1.45          // Output known constants in hex char format (backward compatibility).
    1.46          assert(encval < 256, "Exceeded supported width for register encoding");
    1.47 -        fprintf(fp,"  (unsigned char)'\\x%X'%s  // %s\n",
    1.48 -                encval,          comma, reg_def->_regname );
    1.49 +        fprintf(fp,"  (unsigned char)'\\x%X'%s  // %s\n", encval, comma, reg_def->_regname);
    1.50        }
    1.51      }
    1.52      // Finish defining enumeration
    1.53 @@ -133,9 +130,10 @@
    1.54      fprintf(fp,"// Enumeration of register class names\n");
    1.55      fprintf(fp, "enum machRegisterClass {\n");
    1.56      registers->_rclasses.reset();
    1.57 -    for( const char *class_name = NULL;
    1.58 -         (class_name = registers->_rclasses.iter()) != NULL; ) {
    1.59 -      fprintf(fp,"  %s,\n", toUpper( class_name ));
    1.60 +    for (const char *class_name = NULL; (class_name = registers->_rclasses.iter()) != NULL;) {
    1.61 +      const char * class_name_to_upper = toUpper(class_name);
    1.62 +      fprintf(fp,"  %s,\n", class_name_to_upper);
    1.63 +      delete[] class_name_to_upper;
    1.64      }
    1.65      // Finish defining enumeration
    1.66      fprintf(fp, "  _last_Mach_Reg_Class\n");
    1.67 @@ -148,7 +146,7 @@
    1.68  void ArchDesc::declare_register_masks(FILE *fp_hpp) {
    1.69    const char  *rc_name;
    1.70  
    1.71 -  if( _register ) {
    1.72 +  if (_register) {
    1.73      // Build enumeration of user-defined register classes.
    1.74      defineRegClassEnum(fp_hpp, _register);
    1.75  
    1.76 @@ -156,24 +154,27 @@
    1.77      fprintf(fp_hpp,"\n");
    1.78      fprintf(fp_hpp,"// Register masks, one for each register class.\n");
    1.79      _register->_rclasses.reset();
    1.80 -    for( rc_name = NULL;
    1.81 -         (rc_name = _register->_rclasses.iter()) != NULL; ) {
    1.82 -      const char *prefix    = "";
    1.83 -      RegClass   *reg_class = _register->getRegClass(rc_name);
    1.84 -      assert( reg_class, "Using an undefined register class");
    1.85 +    for (rc_name = NULL; (rc_name = _register->_rclasses.iter()) != NULL;) {
    1.86 +      const char *prefix = "";
    1.87 +      RegClass *reg_class = _register->getRegClass(rc_name);
    1.88 +      assert(reg_class, "Using an undefined register class");
    1.89 +
    1.90 +      const char* rc_name_to_upper = toUpper(rc_name);
    1.91  
    1.92        if (reg_class->_user_defined == NULL) {
    1.93 -        fprintf(fp_hpp, "extern const RegMask _%s%s_mask;\n", prefix, toUpper( rc_name ) );
    1.94 -        fprintf(fp_hpp, "inline const RegMask &%s%s_mask() { return _%s%s_mask; }\n", prefix, toUpper( rc_name ), prefix, toUpper( rc_name ));
    1.95 +        fprintf(fp_hpp, "extern const RegMask _%s%s_mask;\n", prefix,  rc_name_to_upper);
    1.96 +        fprintf(fp_hpp, "inline const RegMask &%s%s_mask() { return _%s%s_mask; }\n", prefix, rc_name_to_upper, prefix, rc_name_to_upper);
    1.97        } else {
    1.98 -        fprintf(fp_hpp, "inline const RegMask &%s%s_mask() { %s }\n", prefix, toUpper( rc_name ), reg_class->_user_defined);
    1.99 +        fprintf(fp_hpp, "inline const RegMask &%s%s_mask() { %s }\n", prefix, rc_name_to_upper, reg_class->_user_defined);
   1.100        }
   1.101  
   1.102 -      if( reg_class->_stack_or_reg ) {
   1.103 +      if (reg_class->_stack_or_reg) {
   1.104          assert(reg_class->_user_defined == NULL, "no user defined reg class here");
   1.105 -        fprintf(fp_hpp, "extern const RegMask _%sSTACK_OR_%s_mask;\n", prefix, toUpper( rc_name ) );
   1.106 -        fprintf(fp_hpp, "inline const RegMask &%sSTACK_OR_%s_mask() { return _%sSTACK_OR_%s_mask; }\n", prefix, toUpper( rc_name ), prefix, toUpper( rc_name ) );
   1.107 +        fprintf(fp_hpp, "extern const RegMask _%sSTACK_OR_%s_mask;\n", prefix, rc_name_to_upper);
   1.108 +        fprintf(fp_hpp, "inline const RegMask &%sSTACK_OR_%s_mask() { return _%sSTACK_OR_%s_mask; }\n", prefix, rc_name_to_upper, prefix, rc_name_to_upper);
   1.109        }
   1.110 +      delete[] rc_name_to_upper;
   1.111 +
   1.112      }
   1.113    }
   1.114  }
   1.115 @@ -183,34 +184,41 @@
   1.116  void ArchDesc::build_register_masks(FILE *fp_cpp) {
   1.117    const char  *rc_name;
   1.118  
   1.119 -  if( _register ) {
   1.120 +  if (_register) {
   1.121      // Generate a list of register masks, one for each class.
   1.122      fprintf(fp_cpp,"\n");
   1.123      fprintf(fp_cpp,"// Register masks, one for each register class.\n");
   1.124      _register->_rclasses.reset();
   1.125 -    for( rc_name = NULL;
   1.126 -         (rc_name = _register->_rclasses.iter()) != NULL; ) {
   1.127 -      const char *prefix    = "";
   1.128 -      RegClass   *reg_class = _register->getRegClass(rc_name);
   1.129 -      assert( reg_class, "Using an undefined register class");
   1.130 -
   1.131 -      if (reg_class->_user_defined != NULL) continue;
   1.132 +    for (rc_name = NULL; (rc_name = _register->_rclasses.iter()) != NULL;) {
   1.133 +      const char *prefix = "";
   1.134 +      RegClass *reg_class = _register->getRegClass(rc_name);
   1.135 +      assert(reg_class, "Using an undefined register class");
   1.136 +
   1.137 +      if (reg_class->_user_defined != NULL) {
   1.138 +        continue;
   1.139 +      }
   1.140  
   1.141        int len = RegisterForm::RegMask_Size();
   1.142 -      fprintf(fp_cpp, "const RegMask _%s%s_mask(", prefix, toUpper( rc_name ) );
   1.143 -      { int i;
   1.144 -        for( i = 0; i < len-1; i++ )
   1.145 -          fprintf(fp_cpp," 0x%x,",reg_class->regs_in_word(i,false));
   1.146 -        fprintf(fp_cpp," 0x%x );\n",reg_class->regs_in_word(i,false));
   1.147 +      const char* rc_name_to_upper = toUpper(rc_name);
   1.148 +      fprintf(fp_cpp, "const RegMask _%s%s_mask(", prefix, rc_name_to_upper);
   1.149 +
   1.150 +      {
   1.151 +        int i;
   1.152 +        for(i = 0; i < len - 1; i++) {
   1.153 +          fprintf(fp_cpp," 0x%x,", reg_class->regs_in_word(i, false));
   1.154 +        }
   1.155 +        fprintf(fp_cpp," 0x%x );\n", reg_class->regs_in_word(i, false));
   1.156        }
   1.157  
   1.158 -      if( reg_class->_stack_or_reg ) {
   1.159 +      if (reg_class->_stack_or_reg) {
   1.160          int i;
   1.161 -        fprintf(fp_cpp, "const RegMask _%sSTACK_OR_%s_mask(", prefix, toUpper( rc_name ) );
   1.162 -        for( i = 0; i < len-1; i++ )
   1.163 -          fprintf(fp_cpp," 0x%x,",reg_class->regs_in_word(i,true));
   1.164 -        fprintf(fp_cpp," 0x%x );\n",reg_class->regs_in_word(i,true));
   1.165 +        fprintf(fp_cpp, "const RegMask _%sSTACK_OR_%s_mask(", prefix, rc_name_to_upper);
   1.166 +        for(i = 0; i < len - 1; i++) {
   1.167 +          fprintf(fp_cpp," 0x%x,",reg_class->regs_in_word(i, true));
   1.168 +        }
   1.169 +        fprintf(fp_cpp," 0x%x );\n",reg_class->regs_in_word(i, true));
   1.170        }
   1.171 +      delete[] rc_name_to_upper;
   1.172      }
   1.173    }
   1.174  }
   1.175 @@ -2676,7 +2684,9 @@
   1.176        if (strcmp(first_reg_class, "stack_slots") == 0) {
   1.177          fprintf(fp,"  return &(Compile::current()->FIRST_STACK_mask());\n");
   1.178        } else {
   1.179 -        fprintf(fp,"  return &%s_mask();\n", toUpper(first_reg_class));
   1.180 +        const char* first_reg_class_to_upper = toUpper(first_reg_class);
   1.181 +        fprintf(fp,"  return &%s_mask();\n", first_reg_class_to_upper);
   1.182 +        delete[] first_reg_class_to_upper;
   1.183        }
   1.184      } else {
   1.185        // Build a switch statement to return the desired mask.
   1.186 @@ -2688,7 +2698,9 @@
   1.187          if( !strcmp(reg_class, "stack_slots") ) {
   1.188            fprintf(fp, "  case %d: return &(Compile::current()->FIRST_STACK_mask());\n", index);
   1.189          } else {
   1.190 -          fprintf(fp, "  case %d: return &%s_mask();\n", index, toUpper(reg_class));
   1.191 +          const char* reg_class_to_upper = toUpper(reg_class);
   1.192 +          fprintf(fp, "  case %d: return &%s_mask();\n", index, reg_class_to_upper);
   1.193 +          delete[] reg_class_to_upper;
   1.194          }
   1.195        }
   1.196        fprintf(fp,"  }\n");

     2.1 --- a/src/share/vm/adlc/output_h.cpp	Thu Apr 04 21:15:43 2013 -0700
     2.2 +++ b/src/share/vm/adlc/output_h.cpp	Fri Apr 05 11:09:43 2013 +0200
     2.3 @@ -2069,9 +2069,21 @@
     2.4    void closing()     { fprintf(_cpp, "  _LAST_MACH_OPER\n");
     2.5                         OutputMap::closing();
     2.6    }
     2.7 -  void map(OpClassForm &opc)  { fprintf(_cpp, "  %s", _AD.machOperEnum(opc._ident) ); }
     2.8 -  void map(OperandForm &oper) { fprintf(_cpp, "  %s", _AD.machOperEnum(oper._ident) ); }
     2.9 -  void map(char        *name) { fprintf(_cpp, "  %s", _AD.machOperEnum(name)); }
    2.10 +  void map(OpClassForm &opc)  {
    2.11 +    const char* opc_ident_to_upper = _AD.machOperEnum(opc._ident);
    2.12 +    fprintf(_cpp, "  %s", opc_ident_to_upper);
    2.13 +    delete[] opc_ident_to_upper;
    2.14 +  }
    2.15 +  void map(OperandForm &oper) {
    2.16 +    const char* oper_ident_to_upper = _AD.machOperEnum(oper._ident);
    2.17 +    fprintf(_cpp, "  %s", oper_ident_to_upper);
    2.18 +    delete[] oper_ident_to_upper;
    2.19 +  }
    2.20 +  void map(char *name) {
    2.21 +    const char* name_to_upper = _AD.machOperEnum(name);
    2.22 +    fprintf(_cpp, "  %s", name_to_upper);
    2.23 +    delete[] name_to_upper;
    2.24 +  }
    2.25  
    2.26    bool do_instructions()      { return false; }
    2.27    void map(InstructForm &inst){ assert( false, "ShouldNotCallThis()"); }