< prev index next >

src/hotspot/share/ci/ciReplay.cpp

Print this page
*** 39,10 ***
--- 39,11 ---
  #include "memory/oopFactory.hpp"
  #include "memory/resourceArea.hpp"
  #include "oops/constantPool.hpp"
  #include "oops/cpCache.inline.hpp"
  #include "oops/fieldStreams.inline.hpp"
+ #include "oops/inlineKlass.inline.hpp"
  #include "oops/klass.inline.hpp"
  #include "oops/method.inline.hpp"
  #include "oops/oop.inline.hpp"
  #include "prims/jvmtiExport.hpp"
  #include "prims/methodHandles.hpp"

*** 923,10 ***
--- 924,11 ---
              tty->print_cr("Resolving klass %s at %d", cp->klass_name_at(i)->as_utf8(), i);
              Klass* k = cp->klass_at(i, CHECK);
            }
            break;
          }
+ 
          case JVM_CONSTANT_Long:
          case JVM_CONSTANT_Double:
            parsed_two_word = i + 1;
  
          case JVM_CONSTANT_ClassIndex:

*** 969,123 ***
        }
  
      }
    }
  
!   // staticfield <klass> <name> <signature> <value>
!   //
!   // Initialize a class and fill in the value for a static field.
!   // This is useful when the compile was dependent on the value of
!   // static fields but it's impossible to properly rerun the static
!   // initializer.
!   void process_staticfield(TRAPS) {
!     InstanceKlass* k = (InstanceKlass *)parse_klass(CHECK);
! 
!     if (k == NULL || ReplaySuppressInitializers == 0 ||
!         (ReplaySuppressInitializers == 2 && k->class_loader() == NULL)) {
!       return;
!     }
! 
!     assert(k->is_initialized(), "must be");
! 
!     const char* field_name = parse_escaped_string();
!     const char* field_signature = parse_string();
!     fieldDescriptor fd;
!     Symbol* name = SymbolTable::new_symbol(field_name);
!     Symbol* sig = SymbolTable::new_symbol(field_signature);
!     if (!k->find_local_field(name, sig, &fd) ||
!         !fd.is_static() ||
!         fd.has_initial_value()) {
!       report_error(field_name);
!       return;
      }
  
!     oop java_mirror = k->java_mirror();
      if (field_signature[0] == JVM_SIGNATURE_ARRAY) {
        int length = parse_int("array length");
        oop value = NULL;
  
        if (field_signature[1] == JVM_SIGNATURE_ARRAY) {
          // multi dimensional array
!         ArrayKlass* kelem = (ArrayKlass *)parse_klass(CHECK);
!         if (kelem == NULL) {
-           return;
-         }
          int rank = 0;
          while (field_signature[rank] == JVM_SIGNATURE_ARRAY) {
            rank++;
          }
          jint* dims = NEW_RESOURCE_ARRAY(jint, rank);
          dims[0] = length;
          for (int i = 1; i < rank; i++) {
            dims[i] = 1; // These aren't relevant to the compiler
          }
!         value = kelem->multi_allocate(rank, dims, CHECK);
        } else {
          if (strcmp(field_signature, "[B") == 0) {
!           value = oopFactory::new_byteArray(length, CHECK);
          } else if (strcmp(field_signature, "[Z") == 0) {
!           value = oopFactory::new_boolArray(length, CHECK);
          } else if (strcmp(field_signature, "[C") == 0) {
!           value = oopFactory::new_charArray(length, CHECK);
          } else if (strcmp(field_signature, "[S") == 0) {
!           value = oopFactory::new_shortArray(length, CHECK);
          } else if (strcmp(field_signature, "[F") == 0) {
!           value = oopFactory::new_floatArray(length, CHECK);
          } else if (strcmp(field_signature, "[D") == 0) {
!           value = oopFactory::new_doubleArray(length, CHECK);
          } else if (strcmp(field_signature, "[I") == 0) {
!           value = oopFactory::new_intArray(length, CHECK);
          } else if (strcmp(field_signature, "[J") == 0) {
!           value = oopFactory::new_longArray(length, CHECK);
          } else if (field_signature[0] == JVM_SIGNATURE_ARRAY &&
                     field_signature[1] == JVM_SIGNATURE_CLASS) {
!           Klass* kelem = resolve_klass(field_signature + 1, CHECK);
!           value = oopFactory::new_objArray(kelem, length, CHECK);
          } else {
            report_error("unhandled array staticfield");
          }
        }
        java_mirror->obj_field_put(fd.offset(), value);
      } else {
!       const char* string_value = parse_escaped_string();
!       if (strcmp(field_signature, "I") == 0) {
-         int value = atoi(string_value);
-         java_mirror->int_field_put(fd.offset(), value);
-       } else if (strcmp(field_signature, "B") == 0) {
-         int value = atoi(string_value);
-         java_mirror->byte_field_put(fd.offset(), value);
-       } else if (strcmp(field_signature, "C") == 0) {
-         int value = atoi(string_value);
-         java_mirror->char_field_put(fd.offset(), value);
-       } else if (strcmp(field_signature, "S") == 0) {
-         int value = atoi(string_value);
-         java_mirror->short_field_put(fd.offset(), value);
-       } else if (strcmp(field_signature, "Z") == 0) {
-         int value = atoi(string_value);
-         java_mirror->bool_field_put(fd.offset(), value);
-       } else if (strcmp(field_signature, "J") == 0) {
-         jlong value;
-         if (sscanf(string_value, JLONG_FORMAT, &value) != 1) {
-           fprintf(stderr, "Error parsing long: %s\n", string_value);
-           return;
-         }
-         java_mirror->long_field_put(fd.offset(), value);
-       } else if (strcmp(field_signature, "F") == 0) {
-         float value = atof(string_value);
-         java_mirror->float_field_put(fd.offset(), value);
-       } else if (strcmp(field_signature, "D") == 0) {
-         double value = atof(string_value);
-         java_mirror->double_field_put(fd.offset(), value);
-       } else if (strcmp(field_signature, "Ljava/lang/String;") == 0) {
-         Handle value = java_lang_String::create_from_str(string_value, CHECK);
-         java_mirror->obj_field_put(fd.offset(), value());
-       } else if (field_signature[0] == JVM_SIGNATURE_CLASS) {
-         Klass* k = resolve_klass(string_value, CHECK);
-         oop value = InstanceKlass::cast(k)->allocate_instance(CHECK);
-         java_mirror->obj_field_put(fd.offset(), value);
-       } else {
          report_error("unhandled staticfield");
        }
      }
    }
  
--- 971,230 ---
        }
  
      }
    }
  
!   class InlineTypeFieldInitializer : public FieldClosure {
!     oop _vt;
!     CompileReplay* _replay;
!   public:
!     InlineTypeFieldInitializer(oop vt, CompileReplay* replay)
!   : _vt(vt), _replay(replay) {}
! 
!     void do_field(fieldDescriptor* fd) {
!       BasicType bt = fd->field_type();
!       const char* string_value = bt != T_INLINE_TYPE ? _replay->parse_escaped_string() : NULL;
!       switch (bt) {
!       case T_BYTE: {
!         int value = atoi(string_value);
!         _vt->byte_field_put(fd->offset(), value);
!         break;
!       }
!       case T_BOOLEAN: {
!         int value = atoi(string_value);
!         _vt->bool_field_put(fd->offset(), value);
!         break;
!       }
!       case T_SHORT: {
!         int value = atoi(string_value);
!         _vt->short_field_put(fd->offset(), value);
!         break;
!       }
+       case T_CHAR: {
+         int value = atoi(string_value);
+         _vt->char_field_put(fd->offset(), value);
+         break;
+       }
+       case T_INT: {
+         int value = atoi(string_value);
+         _vt->int_field_put(fd->offset(), value);
+         break;
+       }
+       case T_LONG: {
+         jlong value;
+         if (sscanf(string_value, JLONG_FORMAT, &value) != 1) {
+           fprintf(stderr, "Error parsing long: %s\n", string_value);
+           break;
+         }
+         _vt->long_field_put(fd->offset(), value);
+         break;
+       }
+       case T_FLOAT: {
+         float value = atof(string_value);
+         _vt->float_field_put(fd->offset(), value);
+         break;
+       }
+       case T_DOUBLE: {
+         double value = atof(string_value);
+         _vt->double_field_put(fd->offset(), value);
+         break;
+       }
+       case T_ARRAY:
+       case T_OBJECT: {
+         JavaThread* THREAD = JavaThread::current();
+         bool res = _replay->process_staticfield_reference(string_value, _vt, fd, THREAD);
+         assert(res, "should succeed for arrays & objects");
+         break;
+       }
+       case T_INLINE_TYPE: {
+         InlineKlass* vk = InlineKlass::cast(fd->field_holder()->get_inline_type_field_klass(fd->index()));
+         if (fd->is_inlined()) {
+           int field_offset = fd->offset() - vk->first_field_offset();
+           oop obj = cast_to_oop(cast_from_oop<address>(_vt) + field_offset);
+           InlineTypeFieldInitializer init_fields(obj, _replay);
+           vk->do_nonstatic_fields(&init_fields);
+         } else {
+           oop value = vk->allocate_instance(JavaThread::current());
+           _vt->obj_field_put(fd->offset(), value);
+         }
+         break;
+       }
+       default: {
+         fatal("Unhandled type: %s", type2name(bt));
+       }
+       }
      }
+   };
  
!   bool process_staticfield_reference(const char* field_signature, oop java_mirror, fieldDescriptor* fd, TRAPS) {
      if (field_signature[0] == JVM_SIGNATURE_ARRAY) {
        int length = parse_int("array length");
        oop value = NULL;
  
        if (field_signature[1] == JVM_SIGNATURE_ARRAY) {
          // multi dimensional array
!         Klass* k = resolve_klass(field_signature, CHECK_(true));
!         ArrayKlass* kelem = (ArrayKlass *)k;
          int rank = 0;
          while (field_signature[rank] == JVM_SIGNATURE_ARRAY) {
            rank++;
          }
          jint* dims = NEW_RESOURCE_ARRAY(jint, rank);
          dims[0] = length;
          for (int i = 1; i < rank; i++) {
            dims[i] = 1; // These aren't relevant to the compiler
          }
!         value = kelem->multi_allocate(rank, dims, CHECK_(true));
        } else {
          if (strcmp(field_signature, "[B") == 0) {
!           value = oopFactory::new_byteArray(length, CHECK_(true));
          } else if (strcmp(field_signature, "[Z") == 0) {
!           value = oopFactory::new_boolArray(length, CHECK_(true));
          } else if (strcmp(field_signature, "[C") == 0) {
!           value = oopFactory::new_charArray(length, CHECK_(true));
          } else if (strcmp(field_signature, "[S") == 0) {
!           value = oopFactory::new_shortArray(length, CHECK_(true));
          } else if (strcmp(field_signature, "[F") == 0) {
!           value = oopFactory::new_floatArray(length, CHECK_(true));
          } else if (strcmp(field_signature, "[D") == 0) {
!           value = oopFactory::new_doubleArray(length, CHECK_(true));
          } else if (strcmp(field_signature, "[I") == 0) {
!           value = oopFactory::new_intArray(length, CHECK_(true));
          } else if (strcmp(field_signature, "[J") == 0) {
!           value = oopFactory::new_longArray(length, CHECK_(true));
          } else if (field_signature[0] == JVM_SIGNATURE_ARRAY &&
                     field_signature[1] == JVM_SIGNATURE_CLASS) {
!           Klass* kelem = resolve_klass(field_signature + 1, CHECK_(true));
!           value = oopFactory::new_objArray(kelem, length, CHECK_(true));
+         } else if (field_signature[0] == JVM_SIGNATURE_ARRAY &&
+                    field_signature[1] == JVM_SIGNATURE_INLINE_TYPE) {
+           Klass* kelem = resolve_klass(field_signature + 1, CHECK_(true));
+           value = oopFactory::new_flatArray(kelem, length, CHECK_(true));
          } else {
            report_error("unhandled array staticfield");
          }
        }
+       java_mirror->obj_field_put(fd->offset(), value);
+       return true;
+     } else if (strcmp(field_signature, "Ljava/lang/String;") == 0) {
+       const char* string_value = parse_escaped_string();
+       Handle value = java_lang_String::create_from_str(string_value, CHECK_(true));
+       java_mirror->obj_field_put(fd->offset(), value());
+       return true;
+     } else if (field_signature[0] == 'L') {
+       const char* instance = parse_escaped_string();
+       Klass* k = resolve_klass(instance, CHECK_(true));
+       oop value = InstanceKlass::cast(k)->allocate_instance(CHECK_(true));
+       java_mirror->obj_field_put(fd->offset(), value);
+       return true;
+     }
+     return false;
+   }
+ 
+   // Initialize a class and fill in the value for a static field.
+   // This is useful when the compile was dependent on the value of
+   // static fields but it's impossible to properly rerun the static
+   // initializer.
+   void process_staticfield(TRAPS) {
+     InstanceKlass* k = (InstanceKlass *)parse_klass(CHECK);
+ 
+     if (k == NULL || ReplaySuppressInitializers == 0 ||
+         (ReplaySuppressInitializers == 2 && k->class_loader() == NULL)) {
+       return;
+     }
+ 
+     assert(k->is_initialized(), "must be");
+ 
+     const char* field_name = parse_escaped_string();
+     const char* field_signature = parse_string();
+     fieldDescriptor fd;
+     Symbol* name = SymbolTable::new_symbol(field_name);
+     Symbol* sig = SymbolTable::new_symbol(field_signature);
+     if (!k->find_local_field(name, sig, &fd) ||
+         !fd.is_static() ||
+         fd.has_initial_value()) {
+       report_error(field_name);
+       return;
+     }
+ 
+     oop java_mirror = k->java_mirror();
+     if (strcmp(field_signature, "I") == 0) {
+       const char* string_value = parse_escaped_string();
+       int value = atoi(string_value);
+       java_mirror->int_field_put(fd.offset(), value);
+     } else if (strcmp(field_signature, "B") == 0) {
+       const char* string_value = parse_escaped_string();
+       int value = atoi(string_value);
+       java_mirror->byte_field_put(fd.offset(), value);
+     } else if (strcmp(field_signature, "C") == 0) {
+       const char* string_value = parse_escaped_string();
+       int value = atoi(string_value);
+       java_mirror->char_field_put(fd.offset(), value);
+     } else if (strcmp(field_signature, "S") == 0) {
+       const char* string_value = parse_escaped_string();
+       int value = atoi(string_value);
+       java_mirror->short_field_put(fd.offset(), value);
+     } else if (strcmp(field_signature, "Z") == 0) {
+       const char* string_value = parse_escaped_string();
+       int value = atoi(string_value);
+       java_mirror->bool_field_put(fd.offset(), value);
+     } else if (strcmp(field_signature, "J") == 0) {
+       const char* string_value = parse_escaped_string();
+       jlong value;
+       if (sscanf(string_value, JLONG_FORMAT, &value) != 1) {
+         fprintf(stderr, "Error parsing long: %s\n", string_value);
+         return;
+       }
+       java_mirror->long_field_put(fd.offset(), value);
+     } else if (strcmp(field_signature, "F") == 0) {
+       const char* string_value = parse_escaped_string();
+       float value = atof(string_value);
+       java_mirror->float_field_put(fd.offset(), value);
+     } else if (strcmp(field_signature, "D") == 0) {
+       const char* string_value = parse_escaped_string();
+       double value = atof(string_value);
+       java_mirror->double_field_put(fd.offset(), value);
+     } else if (field_signature[0] == JVM_SIGNATURE_INLINE_TYPE) {
+       Klass* kelem = resolve_klass(field_signature, CHECK);
+       InlineKlass* vk = InlineKlass::cast(kelem);
+       oop value = vk->allocate_instance(CHECK);
+       InlineTypeFieldInitializer init_fields(value, this);
+       vk->do_nonstatic_fields(&init_fields);
        java_mirror->obj_field_put(fd.offset(), value);
      } else {
!       bool res = process_staticfield_reference(field_signature, java_mirror, &fd, CHECK);
!       if (!res)  {
          report_error("unhandled staticfield");
        }
      }
    }
  
< prev index next >