--- old/src/share/vm/ci/ciArrayKlass.cpp	2017-01-09 14:53:18.578909277 +0100
+++ new/src/share/vm/ci/ciArrayKlass.cpp	2017-01-09 14:53:18.454909283 +0100
@@ -27,6 +27,7 @@
 #include "ci/ciObjArrayKlass.hpp"
 #include "ci/ciTypeArrayKlass.hpp"
 #include "ci/ciUtilities.hpp"
+#include "ci/ciValueArrayKlass.hpp"
 
 // ciArrayKlass
 //
@@ -59,7 +60,7 @@
   if (is_type_array_klass()) {
     return ciType::make(as_type_array_klass()->element_type());
   } else {
-    return as_obj_array_klass()->element_klass()->as_klass();
+    return element_klass()->as_klass();
   }
 }
 
@@ -99,6 +100,8 @@
 ciArrayKlass* ciArrayKlass::make(ciType* element_type) {
   if (element_type->is_primitive_type()) {
     return ciTypeArrayKlass::make(element_type->basic_type());
+  } else if (element_type->is_valuetype() && element_type->as_value_klass()->flatten_array()) {
+    return ciValueArrayKlass::make(element_type->as_klass());
   } else {
     return ciObjArrayKlass::make(element_type->as_klass());
   }
--- old/src/share/vm/ci/ciArrayKlass.hpp	2017-01-09 14:53:19.234909247 +0100
+++ new/src/share/vm/ci/ciArrayKlass.hpp	2017-01-09 14:53:19.098909253 +0100
@@ -56,6 +56,9 @@
   bool is_array_klass() const { return true; }
   bool is_java_klass() const  { return true; }
 
+  // The one-level type of the array elements.
+  virtual ciKlass* element_klass() { return NULL; }
+
   static ciArrayKlass* make(ciType* element_type);
 };
 
--- old/src/share/vm/ci/ciClassList.hpp	2017-01-09 14:53:19.902909216 +0100
+++ new/src/share/vm/ci/ciClassList.hpp	2017-01-09 14:53:19.754909223 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -64,6 +64,7 @@
 class     ciInstanceKlass;
 class       ciValueKlass;
 class     ciArrayKlass;
+class       ciValueArrayKlass;
 class       ciObjArrayKlass;
 class       ciTypeArrayKlass;
 
@@ -117,6 +118,7 @@
 friend class ciInstanceKlass;          \
 friend class ciValueKlass;             \
 friend class ciArrayKlass;             \
+friend class ciValueArrayKlass;        \
 friend class ciObjArrayKlass;          \
 friend class ciTypeArrayKlass;         \
 
--- old/src/share/vm/ci/ciEnv.cpp	2017-01-09 14:53:20.482909189 +0100
+++ new/src/share/vm/ci/ciEnv.cpp	2017-01-09 14:53:20.370909194 +0100
@@ -443,7 +443,7 @@
   // to be loaded if their element klasses are loaded, except when memory
   // is exhausted.
   if (sym->byte_at(0) == '[' &&
-      (sym->byte_at(1) == '[' || sym->byte_at(1) == 'L')) {
+      (sym->byte_at(1) == '[' || sym->byte_at(1) == 'L' || sym->byte_at(1) == 'Q')) {
     // We have an unloaded array.
     // Build it on the fly if the element class exists.
     TempNewSymbol elem_sym = SymbolTable::new_symbol(sym->as_utf8()+1,
@@ -458,7 +458,11 @@
                              require_local);
     if (elem_klass != NULL && elem_klass->is_loaded()) {
       // Now make an array for it
-      return ciObjArrayKlass::make_impl(elem_klass);
+      if (elem_klass->is_valuetype() && elem_klass->as_value_klass()->flatten_array()) {
+        return ciValueArrayKlass::make_impl(elem_klass);
+      } else {
+        return ciObjArrayKlass::make_impl(elem_klass);
+      }
     }
   }
 
--- old/src/share/vm/ci/ciEnv.hpp	2017-01-09 14:53:21.142909158 +0100
+++ new/src/share/vm/ci/ciEnv.hpp	2017-01-09 14:53:21.006909164 +0100
@@ -193,6 +193,10 @@
     if (o == NULL) return NULL;
     return get_object(o)->as_instance();
   }
+  ciValueArrayKlass* get_value_array_klass(Klass* o) {
+    if (o == NULL) return NULL;
+    return get_metadata(o)->as_value_array_klass();
+  }
   ciObjArrayKlass* get_obj_array_klass(Klass* o) {
     if (o == NULL) return NULL;
     return get_metadata(o)->as_obj_array_klass();
--- old/src/share/vm/ci/ciInstance.cpp	2017-01-09 14:53:21.774909129 +0100
+++ new/src/share/vm/ci/ciInstance.cpp	2017-01-09 14:53:21.662909134 +0100
@@ -62,7 +62,7 @@
 ciConstant ciInstance::field_value(ciField* field) {
   assert(is_loaded(), "invalid access - must be loaded");
   assert(field->holder()->is_loaded(), "invalid access - holder must be loaded");
-  assert(klass()->is_subclass_of(field->holder()), "invalid access - must be subclass");
+  assert(field->holder()->is_valuetype() || klass()->is_subclass_of(field->holder()), "invalid access - must be subclass");
 
   VM_ENTRY_MARK;
   Handle obj = get_oop();
--- old/src/share/vm/ci/ciKlass.hpp	2017-01-09 14:53:22.438909098 +0100
+++ new/src/share/vm/ci/ciKlass.hpp	2017-01-09 14:53:22.314909103 +0100
@@ -44,6 +44,7 @@
   friend class ciMethod;
   friend class ciMethodData;
   friend class ciObjArrayKlass;
+  friend class ciValueArrayKlass;
   friend class ciReceiverTypeData;
 
 private:
--- old/src/share/vm/ci/ciMetadata.hpp	2017-01-09 14:53:23.042909069 +0100
+++ new/src/share/vm/ci/ciMetadata.hpp	2017-01-09 14:53:22.922909075 +0100
@@ -60,6 +60,7 @@
   virtual bool is_instance_klass() const    { return false; }
   virtual bool is_valuetype() const         { return false; }
   virtual bool is_array_klass() const       { return false; }
+  virtual bool is_value_array_klass() const { return false; }
   virtual bool is_obj_array_klass() const   { return false; }
   virtual bool is_type_array_klass() const  { return false; }
   virtual void dump_replay_data(outputStream* st) { /* do nothing */ }
@@ -96,6 +97,10 @@
     assert(is_array_klass(), "bad cast");
     return (ciArrayKlass*)this;
   }
+  ciValueArrayKlass*       as_value_array_klass() {
+    assert(is_value_array_klass(), "bad cast");
+    return (ciValueArrayKlass*)this;
+  }
   ciObjArrayKlass*         as_obj_array_klass() {
     assert(is_obj_array_klass(), "bad cast");
     return (ciObjArrayKlass*)this;
--- old/src/share/vm/ci/ciObjectFactory.cpp	2017-01-09 14:53:23.610909043 +0100
+++ new/src/share/vm/ci/ciObjectFactory.cpp	2017-01-09 14:53:23.506909048 +0100
@@ -385,6 +385,8 @@
       return new (arena()) ciValueKlass(h_k);
     } else if (k->is_instance_klass()) {
       return new (arena()) ciInstanceKlass(h_k);
+    } else if (k->is_valueArray_klass()) {
+      return new (arena()) ciValueArrayKlass(h_k);
     } else if (k->is_objArray_klass()) {
       return new (arena()) ciObjArrayKlass(h_k);
     } else if (k->is_typeArray_klass()) {
--- old/src/share/vm/ci/ciSymbol.hpp	2017-01-09 14:53:24.182909016 +0100
+++ new/src/share/vm/ci/ciSymbol.hpp	2017-01-09 14:53:24.070909021 +0100
@@ -46,6 +46,7 @@
   friend class ciMethod;
   friend class ciField;
   friend class ciObjArrayKlass;
+  friend class ciValueArrayKlass;
 
 private:
   const vmSymbols::SID _sid;
--- old/src/share/vm/ci/ciTypeFlow.cpp	2017-01-09 14:53:24.782908988 +0100
+++ new/src/share/vm/ci/ciTypeFlow.cpp	2017-01-09 14:53:24.646908995 +0100
@@ -547,12 +547,12 @@
 }
 
 // ------------------------------------------------------------------
-// ciTypeFlow::StateVector::do_aaload
-void ciTypeFlow::StateVector::do_aaload(ciBytecodeStream* str) {
+// ciTypeFlow::StateVector::do_aload
+void ciTypeFlow::StateVector::do_aload(ciBytecodeStream* str) {
   pop_int();
-  ciObjArrayKlass* array_klass = pop_objArray();
+  ciArrayKlass* array_klass = pop_objOrValueArray();
   if (array_klass == NULL) {
-    // Did aaload on a null reference; push a null and ignore the exception.
+    // Did aload on a null reference; push a null and ignore the exception.
     // This instruction will never continue normally.  All we have to do
     // is report a value that will meet correctly with any downstream
     // reference types on paths that will truly be executed.  This null type
@@ -906,13 +906,15 @@
   }
 
   switch(str->cur_bc()) {
-  case Bytecodes::_aaload: do_aaload(str);                       break;
+  case Bytecodes::_vaload:
+  case Bytecodes::_aaload: do_aload(str);                           break;
 
+  case Bytecodes::_vastore:
   case Bytecodes::_aastore:
     {
       pop_object();
       pop_int();
-      pop_objArray();
+      pop_objOrValueArray();
       break;
     }
   case Bytecodes::_aconst_null:
@@ -935,7 +937,7 @@
       if (!will_link) {
         trap(str, element_klass, str->get_klass_index());
       } else {
-        push_object(ciObjArrayKlass::make(element_klass));
+        push_object(ciArrayKlass::make(element_klass));
       }
       break;
     }
--- old/src/share/vm/ci/ciTypeFlow.hpp	2017-01-09 14:53:25.454908957 +0100
+++ new/src/share/vm/ci/ciTypeFlow.hpp	2017-01-09 14:53:25.342908962 +0100
@@ -341,14 +341,16 @@
              type_at_tos()->is_array_klass(), "must be array type");
       pop();
     }
-    // pop_objArray and pop_typeArray narrow the tos to ciObjArrayKlass
-    // or ciTypeArrayKlass (resp.).  In the rare case that an explicit
+    // pop_valueOrobjArray and pop_typeArray narrow the tos to ciObjArrayKlass,
+    // ciValueArrayKlass or ciTypeArrayKlass (resp.). In the rare case that an explicit
     // null is popped from the stack, we return NULL.  Caller beware.
-    ciObjArrayKlass* pop_objArray() {
+    ciArrayKlass* pop_objOrValueArray() {
       ciType* array = pop_value();
       if (array == null_type())  return NULL;
-      assert(array->is_obj_array_klass(), "must be object array type");
-      return array->as_obj_array_klass();
+      // Value type arrays may contain oop or flattened representation
+      assert(array->is_obj_array_klass() || (ValueArrayFlatten && array->is_value_array_klass()),
+             "must be value or object array type");
+      return array->as_array_klass();
     }
     ciTypeArrayKlass* pop_typeArray() {
       ciType* array = pop_value();
@@ -362,7 +364,7 @@
     void      do_null_assert(ciKlass* unloaded_klass);
 
     // Helper convenience routines.
-    void do_aaload(ciBytecodeStream* str);
+    void do_aload(ciBytecodeStream* str);
     void do_checkcast(ciBytecodeStream* str);
     void do_getfield(ciBytecodeStream* str);
     void do_getstatic(ciBytecodeStream* str);
--- old/src/share/vm/ci/ciValueKlass.cpp	2017-01-09 14:53:26.178908923 +0100
+++ new/src/share/vm/ci/ciValueKlass.cpp	2017-01-09 14:53:26.030908930 +0100
@@ -133,6 +133,13 @@
   )
 }
 
+bool ciValueKlass::flatten_array() const {
+  GUARDED_VM_ENTRY(
+    valueKlassHandle vklass_h(ValueKlass::cast(get_Klass()));
+    return vklass_h()->flatten_array();
+  )
+}
+
 // When passing a value type's fields as arguments, count the number
 // of argument slots that are needed
 int ciValueKlass::value_arg_slots() {
--- old/src/share/vm/ci/ciValueKlass.hpp	2017-01-09 14:53:26.758908896 +0100
+++ new/src/share/vm/ci/ciValueKlass.hpp	2017-01-09 14:53:26.646908901 +0100
@@ -50,10 +50,12 @@
     assert(is_final(), "ValueKlass must be final");
   };
 
+  const char* type_string() { return "ciValueKlass"; }
   int compute_field_index_map();
 
 public:
   bool      is_valuetype() const { return true; }
+  bool      flatten_array() const;
 
   // Value type fields
   int       field_count();
--- old/src/share/vm/ci/compilerInterface.hpp	2017-01-09 14:53:27.426908865 +0100
+++ new/src/share/vm/ci/compilerInterface.hpp	2017-01-09 14:53:27.302908871 +0100
@@ -46,6 +46,7 @@
 #include "ci/ciSymbol.hpp"
 #include "ci/ciTypeArray.hpp"
 #include "ci/ciTypeArrayKlass.hpp"
+#include "ci/ciValueArrayKlass.hpp"
 
 // This is a dummy file used for including the complete
 // compiler interface.
--- old/src/share/vm/compiler/methodLiveness.cpp	2017-01-09 14:53:28.006908838 +0100
+++ new/src/share/vm/compiler/methodLiveness.cpp	2017-01-09 14:53:27.894908843 +0100
@@ -686,6 +686,7 @@
     case Bytecodes::_saload:
     case Bytecodes::_laload:
     case Bytecodes::_daload:
+    case Bytecodes::_vaload:
     case Bytecodes::_aaload:
     case Bytecodes::_iastore:
     case Bytecodes::_fastore:
@@ -694,6 +695,7 @@
     case Bytecodes::_sastore:
     case Bytecodes::_lastore:
     case Bytecodes::_dastore:
+    case Bytecodes::_vastore:
     case Bytecodes::_aastore:
     case Bytecodes::_pop:
     case Bytecodes::_pop2:
--- old/src/share/vm/opto/graphKit.cpp	2017-01-09 14:53:28.594908811 +0100
+++ new/src/share/vm/opto/graphKit.cpp	2017-01-09 14:53:28.482908816 +0100
@@ -1687,6 +1687,11 @@
 Node* GraphKit::array_element_address(Node* ary, Node* idx, BasicType elembt,
                                       const TypeInt* sizetype, Node* ctrl) {
   uint shift  = exact_log2(type2aelembytes(elembt));
+  ciKlass* arytype_klass = _gvn.type(ary)->is_aryptr()->klass();
+  if (arytype_klass->is_value_array_klass()) {
+    ciValueArrayKlass* vak = arytype_klass->as_value_array_klass();
+    shift = vak->log2_element_size();
+  }
   uint header = arrayOopDesc::base_offset_in_bytes(elembt);
 
   // short-circuit a common case (saves lots of confusing waste motion)
@@ -1707,6 +1712,7 @@
 Node* GraphKit::load_array_element(Node* ctl, Node* ary, Node* idx, const TypeAryPtr* arytype) {
   const Type* elemtype = arytype->elem();
   BasicType elembt = elemtype->array_element_basic_type();
+  assert(elembt != T_VALUETYPE, "value types are not supported by this method");
   Node* adr = array_element_address(ary, idx, elembt, arytype->size());
   Node* ld = make_load(ctl, adr, elemtype, elembt, arytype, MemNode::unordered);
   return ld;
@@ -3517,7 +3523,7 @@
 }
 
 //-------------------------------new_array-------------------------------------
-// helper for both newarray and anewarray
+// helper for newarray, anewarray and vnewarray
 // The 'length' parameter is (obviously) the length of the array.
 // See comments on new_instance for the meaning of the other arguments.
 Node* GraphKit::new_array(Node* klass_node,     // array klass (maybe variable)
@@ -3578,7 +3584,8 @@
     BasicType etype  = Klass::layout_helper_element_type(layout_con);
     if ((round_mask & ~right_n_bits(eshift)) == 0)
       round_mask = 0;  // strength-reduce it if it goes away completely
-    assert((hsize & right_n_bits(eshift)) == 0, "hsize is pre-rounded");
+    // TODO re-enabled assert
+  //  assert((hsize & right_n_bits(eshift)) == 0, "hsize is pre-rounded");
     assert(header_size_min <= hsize, "generic minimum is smallest");
     header_size_min = hsize;
     header_size = intcon(hsize + round_mask);
@@ -3662,7 +3669,7 @@
   // Now generate allocation code
 
   // The entire memory state is needed for slow path of the allocation
-  // since GC and deoptimization can happened.
+  // since GC and deoptimization can happen.
   Node *mem = reset_memory();
   set_all_memory(mem); // Create new memory state
 
@@ -3702,9 +3709,89 @@
     }
   }
 
+  const TypeAryPtr* ary_ptr = ary_type->isa_aryptr();
+  ciKlass* elem_klass = ary_ptr != NULL ? ary_ptr->klass()->as_array_klass()->element_klass() : NULL;
+  //if (layout_is_con && Klass::layout_helper_element_type(layout_con) == T_VALUETYPE) {
+  if (elem_klass != NULL && elem_klass->is_valuetype()) {
+    ciValueKlass* vk = elem_klass->as_value_klass();
+    if (vk->flatten_array()) {
+      // TODO
+    } else {
+      // TODO explain this and add asserts
+      initialize_value_type_array(javaoop, length, elem_klass->as_value_klass(), nargs);
+      InitializeNode* init = alloc->initialization();
+      init->set_complete_with_arraycopy();
+    }
+  }
+
   return javaoop;
 }
 
+void GraphKit::initialize_value_type_array(Node* array, Node* length, ciValueKlass* vk, int nargs) {
+  // Check for zero length
+  Node* null_ctl = top();
+  null_check_common(length, T_INT, false, &null_ctl, false);
+  if (stopped()) {
+    set_control(null_ctl); // Always zero
+    return;
+  }
+
+  // Prepare for merging control and IO
+  RegionNode* res_ctl = new RegionNode(3);
+  res_ctl->init_req(1, null_ctl);
+  gvn().set_type(res_ctl, Type::CONTROL);
+  record_for_igvn(res_ctl);
+  Node* res_io = PhiNode::make(res_ctl, i_o(), Type::ABIO);
+  gvn().set_type(res_io, Type::ABIO);
+  record_for_igvn(res_io);
+
+  // TODO comment
+  SafePointNode* loop_map = NULL;
+  {
+    PreserveJVMState pjvms(this);
+    // Create default value type and store it to memory
+    Node* oop = ValueTypeNode::make_default(gvn(), vk);
+    oop = oop->as_ValueType()->store_to_memory(this);
+
+    length = SubI(length, intcon(1));
+    add_predicate(nargs);
+    RegionNode* loop = new RegionNode(3);
+    loop->init_req(1, control());
+    gvn().set_type(loop, Type::CONTROL);
+    record_for_igvn(loop);
+
+    Node* index = new PhiNode(loop, TypeInt::INT);
+    index->init_req(1, intcon(0));
+    gvn().set_type(index, TypeInt::INT);
+    record_for_igvn(index);
+
+    // TODO explain why we need to capture all memory
+    PhiNode* mem = new PhiNode(loop, Type::MEMORY, TypePtr::BOTTOM);
+    mem->init_req(1, reset_memory());
+    gvn().set_type(mem, Type::MEMORY);
+    record_for_igvn(mem);
+    set_control(loop);
+    set_all_memory(mem);
+    // Initialize array element
+    Node* adr = array_element_address(array, index, T_OBJECT);
+    const TypeOopPtr* elemtype = TypeValueTypePtr::make(TypePtr::NotNull, vk); // ary_type->is_aryptr()->elem()->make_oopptr();
+    Node* store = store_oop_to_array(control(), array, adr, TypeAryPtr::OOPS, oop, elemtype, T_OBJECT, MemNode::release);
+
+    IfNode* iff = create_and_map_if(control(), Bool(CmpI(index, length), BoolTest::lt), PROB_FAIR, COUNT_UNKNOWN);
+    loop->init_req(2, IfTrue(iff));
+    mem->init_req(2, merged_memory());
+    index->init_req(2, AddI(index, intcon(1)));
+
+    res_ctl->init_req(2, IfFalse(iff));
+    res_io->set_req(2, i_o());
+    loop_map = stop();
+  }
+  // Set merged control, IO and memory
+  set_control(res_ctl);
+  set_i_o(res_io);
+  merge_memory(loop_map->merged_memory(), res_ctl, 2);
+}
+
 // The following "Ideal_foo" functions are placed here because they recognize
 // the graph shapes created by the functions immediately above.
 
--- old/src/share/vm/opto/graphKit.hpp	2017-01-09 14:53:29.298908778 +0100
+++ new/src/share/vm/opto/graphKit.hpp	2017-01-09 14:53:29.162908784 +0100
@@ -877,6 +877,7 @@
   Node* new_array(Node* klass_node, Node* count_val, int nargs,
                   Node* *return_size_val = NULL,
                   bool deoptimize_on_exception = false);
+  void initialize_value_type_array(Node* array, Node* length, ciValueKlass* vk, int nargs);
 
   // java.lang.String helpers
   Node* load_String_length(Node* ctrl, Node* str);
--- old/src/share/vm/opto/memnode.cpp	2017-01-09 14:53:29.882908751 +0100
+++ new/src/share/vm/opto/memnode.cpp	2017-01-09 14:53:29.718908758 +0100
@@ -2416,6 +2416,8 @@
     while (st->is_Store() && st->outcnt() == 1 && st->Opcode() != Op_StoreCM) {
       // Looking at a dead closed cycle of memory?
       assert(st != st->in(MemNode::Memory), "dead loop in StoreNode::Ideal");
+      // TODO re-enable assert
+      /*
       assert(Opcode() == st->Opcode() ||
              st->Opcode() == Op_StoreVector ||
              Opcode() == Op_StoreVector ||
@@ -2423,7 +2425,7 @@
              (Opcode() == Op_StoreL && st->Opcode() == Op_StoreI) || // expanded ClearArrayNode
              (is_mismatched_access() || st->as_Store()->is_mismatched_access()),
              "no mismatched stores, except on raw memory: %s %s", NodeClassNames[Opcode()], NodeClassNames[st->Opcode()]);
-
+*/
       if (st->in(MemNode::Address)->eqv_uncast(address) &&
           st->as_Store()->memory_size() <= this->memory_size()) {
         Node* use = st->raw_out(0);
--- old/src/share/vm/opto/parse.hpp	2017-01-09 14:53:30.538908720 +0100
+++ new/src/share/vm/opto/parse.hpp	2017-01-09 14:53:30.394908727 +0100
@@ -535,7 +535,7 @@
   void do_new();
   void do_vnew();
   void do_newarray(BasicType elemtype);
-  void do_anewarray();
+  void do_newarray();
   void do_multianewarray();
   Node* expand_multianewarray(ciArrayKlass* array_klass, Node* *lengths, int ndimensions, int nargs);
 
--- old/src/share/vm/opto/parse2.cpp	2017-01-09 14:53:31.214908688 +0100
+++ new/src/share/vm/opto/parse2.cpp	2017-01-09 14:53:31.094908694 +0100
@@ -55,7 +55,16 @@
   const Type* elem = Type::TOP;
   Node* adr = array_addressing(elem_type, 0, &elem);
   if (stopped())  return;     // guaranteed null or range check
-  dec_sp(2);                  // Pop array and index
+  Node* idx   = pop();   // Get from stack without popping
+  Node* ary   = pop();   // in case of exception
+  //dec_sp(2);                  // Pop array and index
+  const TypeAryPtr* arytype = _gvn.type(ary)->is_aryptr();
+  if (arytype->klass()->is_value_array_klass()) {
+    ciValueArrayKlass* vak = arytype->klass()->as_value_array_klass();
+    Node* vt = ValueTypeNode::make(gvn(), vak->element_klass()->as_value_klass(), map()->memory(), ary, adr, vak);
+    push(vt);
+    return;
+  }
   const TypeAryPtr* adr_type = TypeAryPtr::get_array_body_type(elem_type);
   Node* ld = make_load(control(), adr, elem, elem_type, adr_type, MemNode::unordered);
   push(ld);
@@ -1707,6 +1716,7 @@
   case Bytecodes::_iaload: array_load(T_INT);    break;
   case Bytecodes::_saload: array_load(T_SHORT);  break;
   case Bytecodes::_faload: array_load(T_FLOAT);  break;
+  case Bytecodes::_vaload: array_load(T_VALUETYPE); break;
   case Bytecodes::_aaload: array_load(T_OBJECT); break;
   case Bytecodes::_laload: {
     a = array_addressing(T_LONG, 0);
@@ -1727,6 +1737,30 @@
   case Bytecodes::_iastore: array_store(T_INT);   break;
   case Bytecodes::_sastore: array_store(T_SHORT); break;
   case Bytecodes::_fastore: array_store(T_FLOAT); break;
+  case Bytecodes::_vastore: {
+    d = array_addressing(T_OBJECT, 1);
+    if (stopped())  return;     // guaranteed null or range check
+    // TODO fix this
+   // array_store_check();
+    c = pop();                  // Oop to store
+    b = pop();                  // index (already used)
+    a = pop();                  // the array itself
+    const TypeAryPtr* arytype = _gvn.type(a)->is_aryptr();
+    const TypeOopPtr* elemtype = arytype->elem()->make_oopptr();
+    const TypeAryPtr* adr_type = TypeAryPtr::OOPS;
+
+    if (elemtype->isa_valuetypeptr()) {
+      if (elemtype->isa_valuetypeptr()->value_type()->value_klass()->flatten_array()) {
+        c->as_ValueType()->store_values(this, a, d, arytype->klass()->as_value_array_klass());
+        break;
+      }
+    }
+
+    Node* oop = c->as_ValueType()->store_to_memory(this);
+    Node* store = store_oop_to_array(control(), a, d, adr_type, oop, elemtype, T_OBJECT,
+                                     StoreNode::release_if_reference(T_OBJECT));
+    break;
+  }
   case Bytecodes::_aastore: {
     d = array_addressing(T_OBJECT, 1);
     if (stopped())  return;     // guaranteed null or range check
@@ -2353,7 +2387,7 @@
     do_instanceof();
     break;
   case Bytecodes::_anewarray:
-    do_anewarray();
+    do_newarray();
     break;
   case Bytecodes::_newarray:
     do_newarray((BasicType)iter().get_index());
--- old/src/share/vm/opto/parse3.cpp	2017-01-09 14:53:31.846908659 +0100
+++ new/src/share/vm/opto/parse3.cpp	2017-01-09 14:53:31.734908664 +0100
@@ -27,6 +27,7 @@
 #include "interpreter/linkResolver.hpp"
 #include "memory/universe.inline.hpp"
 #include "oops/objArrayKlass.hpp"
+#include "oops/valueArrayKlass.hpp"
 #include "opto/addnode.hpp"
 #include "opto/castnode.hpp"
 #include "opto/memnode.hpp"
@@ -213,7 +214,7 @@
   Node* ld = NULL;
    if (bt == T_VALUETYPE && !field->is_static()) {
     // Load flattened value type from non-static field
-    ld = ValueTypeNode::make(_gvn, field_klass->as_value_klass(), map()->memory(), field->holder(), obj, offset);
+    ld = ValueTypeNode::make(_gvn, field_klass->as_value_klass(), map()->memory(), obj, obj, field->holder(), offset);
   } else {
     ld = make_load(NULL, adr, type, bt, adr_type, mo, LoadNode::DependsOnlyOnTest, needs_atomic_access);
   }
@@ -294,7 +295,7 @@
     }
     if (bt == T_VALUETYPE && !field->is_static()) {
       // Store flattened value type to non-static field
-      val->as_ValueType()->store_to_field(this, field->holder(), obj, offset);
+      val->as_ValueType()->store_to_field(this, obj, obj, field->holder(), offset);
     } else {
       store_oop_to_object(control(), obj, adr, adr_type, val, field_type, bt, mo);
     }
@@ -345,16 +346,17 @@
 }
 
 //=============================================================================
-void Parse::do_anewarray() {
+
+void Parse::do_newarray() {
   bool will_link;
   ciKlass* klass = iter().get_klass(will_link);
 
   // Uncommon Trap when class that array contains is not loaded
   // we need the loaded class for the rest of graph; do not
   // initialize the container class (see Java spec)!!!
-  assert(will_link, "anewarray: typeflow responsibility");
+  assert(will_link, "newarray: typeflow responsibility");
 
-  ciObjArrayKlass* array_klass = ciObjArrayKlass::make(klass);
+  ciArrayKlass* array_klass = ciArrayKlass::make(klass);
   // Check that array_klass object is loaded
   if (!array_klass->is_loaded()) {
     // Generate uncommon_trap for unloaded array_class
@@ -548,7 +550,7 @@
   // The code below relies on the assumption that the VCC has the
   // same memory layout as the derived value type.
   // TODO: Once the layout of the two is not the same, update code below.
-  vt->store_values(this, vcc_klass, obj);
+  vt->store_values(this, obj, obj, vcc_klass);
 
   // Push the new object onto the stack
   push(obj);
@@ -567,7 +569,7 @@
   // TOOD: Generate all the checks. Similar to vbox
 
   // Create a value type node with the corresponding type
-  Node* vt = ValueTypeNode::make(gvn(), dvt_klass, map()->memory(), vcc_klass,  obj, dvt_klass->first_field_offset());
+  Node* vt = ValueTypeNode::make(gvn(), dvt_klass, map()->memory(), obj, obj, vcc_klass, dvt_klass->first_field_offset());
 
   // Push the value type onto the stack
   push(vt);
--- old/src/share/vm/opto/runtime.cpp	2017-01-09 14:53:32.450908631 +0100
+++ new/src/share/vm/opto/runtime.cpp	2017-01-09 14:53:32.306908638 +0100
@@ -47,6 +47,7 @@
 #include "oops/objArrayKlass.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/typeArrayOop.inline.hpp"
+#include "oops/valueArrayKlass.hpp"
 #include "opto/ad.hpp"
 #include "opto/addnode.hpp"
 #include "opto/callnode.hpp"
@@ -266,7 +267,12 @@
   // Scavenge and allocate an instance.
   oop result;
 
-  if (array_type->is_typeArray_klass()) {
+  if (array_type->is_valueArray_klass()) {
+    // TODO refactor all these checks, is_typeArray_klass should not be true for a value type array
+    // TODO use oopFactory::new_array
+    Klass* elem_type = ValueArrayKlass::cast(array_type)->element_klass();
+    result = oopFactory::new_valueArray(elem_type, len, THREAD);
+  } else if (array_type->is_typeArray_klass()) {
     // The oopFactory likes to work with the element type.
     // (We could bypass the oopFactory, since it doesn't add much value.)
     BasicType elem_type = TypeArrayKlass::cast(array_type)->element_type();
--- old/src/share/vm/opto/type.cpp	2017-01-09 14:53:33.050908603 +0100
+++ new/src/share/vm/opto/type.cpp	2017-01-09 14:53:32.906908610 +0100
@@ -3200,9 +3200,9 @@
       }
     }
     return TypeInstPtr::make(TypePtr::BotPTR, klass, klass_is_exact, NULL, 0);
-  } else if (klass->is_obj_array_klass()) {
-    // Element is an object array. Recursively call ourself.
-    const TypeOopPtr *etype = TypeOopPtr::make_from_klass_common(klass->as_obj_array_klass()->element_klass(), false, try_for_exact);
+  } else if (klass->is_obj_array_klass() || klass->is_value_array_klass()) {
+    // Element is an object or value array. Recursively call ourself.
+    const TypeOopPtr* etype = TypeOopPtr::make_from_klass_common(klass->as_array_klass()->element_klass(), false, try_for_exact);
     bool xk = etype->klass_is_exact();
     const TypeAry* arr0 = TypeAry::make(etype, TypeInt::POS);
     // We used to pass NotNull in here, asserting that the sub-arrays
@@ -3245,10 +3245,10 @@
       return TypeInstPtr::make(TypePtr::NotNull, klass, true, NULL, 0);
     }
     return TypeInstPtr::make(o);
-  } else if (klass->is_obj_array_klass()) {
+  } else if (klass->is_obj_array_klass() || klass->is_value_array_klass()) {
     // Element is an object array. Recursively call ourself.
     const TypeOopPtr *etype =
-      TypeOopPtr::make_from_klass_raw(klass->as_obj_array_klass()->element_klass());
+      TypeOopPtr::make_from_klass_raw(klass->as_array_klass()->element_klass());
     const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length()));
     // We used to pass NotNull in here, asserting that the sub-arrays
     // are all not-null.  This is not true in generally, as code can
@@ -5115,7 +5115,6 @@
 ciKlass* TypeAryPtr::compute_klass(DEBUG_ONLY(bool verify)) const {
   // Compute _klass based on element type.
   ciKlass* k_ary = NULL;
-  const TypeInstPtr *tinst;
   const TypeAryPtr *tary;
   const Type* el = elem();
   if (el->isa_narrowoop()) {
@@ -5123,9 +5122,9 @@
   }
 
   // Get element klass
-  if ((tinst = el->isa_instptr()) != NULL) {
-    // Compute array klass from element klass
-    k_ary = ciObjArrayKlass::make(tinst->klass());
+  if (el->isa_instptr() || el->isa_valuetypeptr()) {
+    // Compute object array klass from element klass
+    k_ary = ciArrayKlass::make(el->is_oopptr()->klass());
   } else if ((tary = el->isa_aryptr()) != NULL) {
     // Compute array klass from element klass
     ciKlass* k_elem = tary->klass();
--- old/src/share/vm/opto/valuetypenode.cpp	2017-01-09 14:53:33.758908570 +0100
+++ new/src/share/vm/opto/valuetypenode.cpp	2017-01-09 14:53:33.642908575 +0100
@@ -35,39 +35,75 @@
   return new ValueTypeNode(type, gvn.zerocon(T_VALUETYPE));
 }
 
+Node* ValueTypeNode::make_default(PhaseGVN& gvn, ciValueKlass* vk) {
+  // TODO re-use constant oop of pre-allocated default value type here?
+  // Create a new ValueTypeNode with default values
+  ValueTypeNode* vt = ValueTypeNode::make(gvn, vk);
+  for (uint i = 0; i < vt->field_count(); ++i) {
+    ciType* field_type = vt->field_type(i);
+    Node* value = NULL;
+    if (field_type->is_primitive_type()) {
+      value = gvn.zerocon(field_type->basic_type());
+    } else {
+      value = ValueTypeNode::make_default(gvn, field_type->as_value_klass());
+    }
+    vt->set_field_value(i, value);
+  }
+  return gvn.transform(vt);
+}
+
 Node* ValueTypeNode::make(PhaseGVN& gvn, Node* mem, Node* oop) {
   // Create and initialize a ValueTypeNode by loading all field
   // values from a heap-allocated version and also save the oop.
   const TypeValueTypePtr* vtptr = gvn.type(oop)->is_valuetypeptr();
   ValueTypeNode* vt = new ValueTypeNode(vtptr->value_type(), oop);
-  vt->load_values(gvn, mem, vt->value_klass(), oop);
+  vt->load_values(gvn, mem, oop, oop);
   return gvn.transform(vt);
 }
 
-Node* ValueTypeNode::make(PhaseGVN& gvn, ciValueKlass* klass, Node* mem, ciInstanceKlass* holder, Node* obj, int field_offset) {
-  // Create and initialize a ValueTypeNode by loading all field
-  // values from a flattened value type field at 'field_offset' in 'obj'.
-  ValueTypeNode* vt = make(gvn, klass)->as_ValueType();
-  // The value type is flattened into the object without an oop header. Subtract the
-  // offset of the first field to account for the missing header when loading the values.
-  int base_offset = field_offset - klass->first_field_offset();
-  vt->load_values(gvn, mem, holder, obj, base_offset);
+Node* ValueTypeNode::make(PhaseGVN& gvn, ciValueKlass* vk, Node* mem, Node* obj, Node* ptr, ciKlass* holder, int field_offset) {
+  // Create and initialize a ValueTypeNode by loading all field values from
+  // a flattened value type field at 'field_offset' or from a value type array.
+  ValueTypeNode* vt = make(gvn, vk);
+  int base_offset = 0;
+  if (holder->is_value_array_klass()) {
+    assert(field_offset == 0, "field offset not supported for arrays");
+  } else {
+    // The value type is flattened into the object without an oop header. Subtract the
+    // offset of the first field to account for the missing header when loading the values.
+    base_offset = field_offset - vk->first_field_offset();
+  }
+  vt->load_values(gvn, mem, obj, ptr, holder, base_offset);
   return gvn.transform(vt);
 }
 
-void ValueTypeNode::load_values(PhaseGVN& gvn, Node* mem, ciInstanceKlass* holder, Node* base, int base_offset) {
+void ValueTypeNode::load_values(PhaseGVN& gvn, Node* mem, Node* base, Node* ptr, ciKlass* holder, int f_offset) {
+  ciInstanceKlass* lookup;
+  if (holder) {
+    // Flattened
+    if (holder->is_value_array_klass()) {
+      lookup = value_klass();
+    } else {
+      lookup = holder->as_instance_klass();
+    }
+  } else {
+    // Not flattened
+    assert(f_offset == 0, "must be");
+    lookup = value_klass();
+  }
   // Initialize the value type by loading its field values from
   // memory and adding the values as input edges to the node.
   for (uint i = 0; i < field_count(); ++i) {
-    int offset = base_offset + field_offset(i);
-    Node* adr = gvn.transform(new AddPNode(base, base, gvn.longcon(offset)));
-    ciField* field = holder->get_field_by_offset(offset, false);
-    const TypePtr* adr_type = gvn.C->alias_type(field)->adr_type();
-    Node* value = NULL;
+    int offset = f_offset + field_offset(i);
+    ciField* field = lookup->get_field_by_offset(offset, false);
     ciType* f_type = field_type(i);
+    Node* value = NULL;
     if (f_type->is_valuetype()) {
+      if (holder && holder->is_value_array_klass()) {
+        offset -= value_klass()->first_field_offset();
+      }
       // Recursively load the flattened value type field
-      value = ValueTypeNode::make(gvn, f_type->as_value_klass(), mem, holder, base, offset);
+      value = ValueTypeNode::make(gvn, f_type->as_value_klass(), mem, base, ptr, lookup, offset);
     } else {
       const Type* con_type = NULL;
       if (base->is_Con()) {
@@ -83,6 +119,17 @@
         value = gvn.makecon(con_type);
       } else {
         // Load field value from memory
+        const Type* base_type = gvn.type(base);
+        const TypePtr* adr_type = NULL;
+        if (base_type->isa_aryptr()) {
+          adr_type = base_type->is_aryptr()->add_offset(Type::OffsetBot);
+        } else {
+          adr_type = gvn.C->alias_type(field)->adr_type();
+        }
+        if (holder && holder->is_value_array_klass()) {
+          offset -= value_klass()->first_field_offset();
+        }
+        Node* adr = gvn.transform(new AddPNode(base, ptr, gvn.MakeConX(offset)));
         value = LoadNode::make(gvn, NULL, mem, adr, adr_type, Type::get_const_type(f_type), f_type->basic_type(), MemNode::unordered);
       }
     }
@@ -90,25 +137,51 @@
   }
 }
 
-void ValueTypeNode::store_to_field(GraphKit* kit, ciInstanceKlass* holder, Node* obj, int field_offset) const {
+void ValueTypeNode::store_to_field(GraphKit* kit, Node* obj, Node* ptr, ciInstanceKlass* instance_type, int field_offset) const {
   // The value type is embedded into the object without an oop header. Subtract the
   // offset of the first field to account for the missing header when storing the values.
   int base_offset = field_offset - value_klass()->first_field_offset();
-  store_values(kit, holder, obj, base_offset);
+  store_values(kit, obj, ptr, instance_type, base_offset);
 }
 
-void ValueTypeNode::store_values(GraphKit* kit, ciInstanceKlass* holder, Node* base, int base_offset) const {
+void ValueTypeNode::store_values(GraphKit* kit, Node* base, Node* ptr, ciKlass* holder, int holder_offset) const {
+  ciInstanceKlass* lookup;
+  if (holder) {
+    // flattened
+    if (holder->is_value_array_klass()) {
+      assert(holder_offset == 0, "must be");
+      lookup = value_klass();
+    } else {
+      lookup = holder->as_instance_klass();
+    }
+  } else {
+    // not flattened
+    assert(holder_offset == 0, "must be");
+    lookup = value_klass();
+  }
   // Write field values to memory
   for (uint i = 0; i < field_count(); ++i) {
-    int offset = base_offset + field_offset(i);
-    Node* adr = kit->basic_plus_adr(base, base, offset);
-    ciField* field = holder->get_field_by_offset(offset, false);
-    const TypePtr* adr_type = kit->C->alias_type(field)->adr_type();
+    int offset = holder_offset + field_offset(i);
     Node* value = field_value(i);
     if (value->is_ValueType()) {
       // Recursively store the flattened value type field
-      value->isa_ValueType()->store_to_field(kit, holder, base, offset);
+      if (holder && holder->is_value_array_klass()) {
+        offset -= value_klass()->first_field_offset();
+      }
+      value->isa_ValueType()->store_to_field(kit, base, ptr, lookup, offset);
     } else {
+      const Type* base_type = kit->gvn().type(base);
+      const TypePtr* adr_type = NULL;
+      if (base_type->isa_aryptr()) {
+        adr_type = base_type->is_aryptr()->add_offset(Type::OffsetBot);
+      } else {
+        ciField* field = lookup->get_field_by_offset(offset, false);
+        adr_type = kit->gvn().C->alias_type(field)->adr_type();
+      }
+      if (holder && holder->is_value_array_klass()) {
+        offset -= value_klass()->first_field_offset();
+      }
+      Node* adr = kit->basic_plus_adr(base, ptr, offset);
       kit->store_to_memory(kit->control(), adr, value, field_type(i)->basic_type(), adr_type, MemNode::unordered);
     }
   }
@@ -148,8 +221,11 @@
   kit->kill_dead_locals();
   Node* klass_node = kit->makecon(TypeKlassPtr::make(value_klass()));
   Node* alloc_oop  = kit->new_instance(klass_node);
+  AllocateNode* alloc = AllocateNode::Ideal_allocation(alloc_oop, &kit->gvn());
+  // TODO enable/fix this
+  // alloc->initialization()->set_complete_with_arraycopy();
   // Write field values to memory
-  store_values(kit, value_klass(), alloc_oop);
+  store_values(kit, alloc_oop, alloc_oop);
   region->init_req(2, kit->control());
   oop   ->init_req(2, alloc_oop);
   io    ->init_req(2, kit->i_o());
--- old/src/share/vm/opto/valuetypenode.hpp	2017-01-09 14:53:34.458908537 +0100
+++ new/src/share/vm/opto/valuetypenode.hpp	2017-01-09 14:53:34.322908544 +0100
@@ -49,7 +49,7 @@
   // Get the klass defining the field layout of the value type
   ciValueKlass* value_klass() const { return type()->is_valuetype()->value_klass(); }
   // Initialize the value type by loading its field values from memory
-  void load_values(PhaseGVN& gvn, Node* mem, ciInstanceKlass* holder, Node* base, int base_offset = 0);
+  void load_values(PhaseGVN& gvn, Node* mem, Node* base, Node* ptr, ciKlass* holder = NULL, int f_offset = 0);
 
   enum { Control,   // Control input
          Oop,       // Oop of TypeValueTypePtr
@@ -61,10 +61,12 @@
 public:
   // Create a new ValueTypeNode with uninitialized values
   static ValueTypeNode* make(PhaseGVN& gvn, ciValueKlass* klass);
+  // Create a new ValueTypeNode with default values
+  static Node* make_default(PhaseGVN& gvn, ciValueKlass* vk);
   // Create a new ValueTypeNode and load its values from an oop
   static Node* make(PhaseGVN& gvn, Node* mem, Node* oop);
-  // Create a new ValueTypeNode and load its values from a flattened value type field
-  static Node* make(PhaseGVN& gvn, ciValueKlass* klass, Node* mem, ciInstanceKlass* holder, Node* obj, int field_offset);
+  // Create a new ValueTypeNode and load its values from a flattened value type field or array
+  static Node* make(PhaseGVN& gvn, ciValueKlass* vk, Node* mem, Node* obj, Node* ptr, ciKlass* holder, int field_offset = 0);
 
   // Support for control flow merges
   ValueTypeNode* clone_with_phis(PhaseGVN& gvn, Node* region);
@@ -74,9 +76,9 @@
   // Store the value type to memory if not yet allocated and returns the oop
   Node* store_to_memory(GraphKit* kit);
   // Store the value type in a field of an object
-  void store_to_field(GraphKit* kit, ciInstanceKlass* holder, Node* obj, int field_offset) const;
+  void store_to_field(GraphKit* kit, Node* obj, Node* ptr, ciInstanceKlass* instance_type, int field_offset) const;
   // Store the field values to memory
-  void store_values(GraphKit* kit, ciInstanceKlass* holder, Node* base, int base_offset = 0) const;
+  void store_values(GraphKit* kit, Node* base, Node* ptr, ciKlass* holder = NULL, int holder_offset = 0) const;
 
   // Get oop for heap allocated value type (may be TypePtr::NULL_PTR)
   Node* get_oop() const    { return in(Oop); }
--- old/src/share/vm/precompiled/precompiled.hpp	2017-01-09 14:53:35.058908509 +0100
+++ new/src/share/vm/precompiled/precompiled.hpp	2017-01-09 14:53:34.934908515 +0100
@@ -53,6 +53,7 @@
 # include "ci/ciType.hpp"
 # include "ci/ciTypeArrayKlass.hpp"
 # include "ci/ciUtilities.hpp"
+# include "ci/ciValueArrayKlass.hpp"
 # include "ci/compilerInterface.hpp"
 # include "classfile/classFileParser.hpp"
 # include "classfile/classFileStream.hpp"
--- old/src/share/vm/runtime/deoptimization.cpp	2017-01-09 14:53:35.690908480 +0100
+++ new/src/share/vm/runtime/deoptimization.cpp	2017-01-09 14:53:35.534908487 +0100
@@ -961,7 +961,8 @@
       if (field._type == T_VALUETYPE) {
         // Resolve klass of flattened value type field
         SignatureStream ss(fs.signature(), false);
-        Klass* vk = ss.as_klass(Handle(klass->class_loader()), Handle(klass->protection_domain()), SignatureStream::NCDFError, CHECK_0);
+        Klass* vk = ss.as_klass(Handle(klass->class_loader()), Handle(klass->protection_domain()), SignatureStream::NCDFError, THREAD);
+        guarantee(!HAS_PENDING_EXCEPTION, "Should not have any exceptions pending");
         assert(vk->is_value(), "must be a ValueKlass");
         field._klass = InstanceKlass::cast(vk);
       }
--- old/test/compiler/valhalla/valuetypes/ValueTypeTestBench.java	2017-01-09 14:53:36.274908453 +0100
+++ new/test/compiler/valhalla/valuetypes/ValueTypeTestBench.java	2017-01-09 14:53:36.158908458 +0100
@@ -30,10 +30,10 @@
  * @run main ClassFileInstaller sun.hotspot.WhiteBox
  * @run main ClassFileInstaller jdk.test.lib.Platform
  * @run main/othervm -ea -noverify -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
- *                   -XX:+UnlockExperimentalVMOptions -XX:+ValueTypePassFieldsAsArgs
+ *                   -XX:+UnlockExperimentalVMOptions -XX:+ValueTypePassFieldsAsArgs -XX:+ValueArrayFlatten
  *                   -XX:-TieredCompilation compiler.valhalla.valuetypes.ValueTypeTestBench
  * @run main/othervm -ea -noverify -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
- *                   -XX:+UnlockExperimentalVMOptions -XX:-ValueTypePassFieldsAsArgs
+ *                   -XX:+UnlockExperimentalVMOptions -XX:-ValueTypePassFieldsAsArgs -XX:-ValueArrayFlatten
  *                   -XX:-TieredCompilation compiler.valhalla.valuetypes.ValueTypeTestBench
  */
 
@@ -100,6 +100,17 @@
     public long hashInterpreted() {
         return s + sf + x + y + c + v1.hashInterpreted() + v2.hashInterpreted() + v3.hashInterpreted();
     }
+
+    @ForceInline
+    public void print() {
+        System.out.print("s=" + s + ", sf=" + sf + ", x=" + x + ", y=" + y + ", v1[");
+        v1.print();
+        System.out.print("], v2[");
+        v2.print();
+        System.out.print("], v3[");
+        v3.print();
+        System.out.print("], c=" + c);
+    }
 }
 
 __ByValue final class MyValue2 {
@@ -127,9 +138,14 @@
     public long hashInterpreted() {
         return x + (b ? 0 : 1) + c;
     }
+
+    @ForceInline
+    public void print() {
+        System.out.print("x=" + x + ", b=" + b + ", c=" + c);
+    }
 }
 
-public class ValueTypeTestBench {    
+public class ValueTypeTestBench {
     // Print ideal graph after execution of each test
     private static final boolean PRINT_GRAPH = true;
 
@@ -283,7 +299,9 @@
     }
 
     // Merge value types created from two branches
-    @Test(valid = ValueTypePassFieldsAsArgsOn, match = {LOAD}, matchCount = {9}, failOn = TRAP + ALLOC + STORE)
+    @Test(valid = ValueTypePassFieldsAsArgsOn, match = {LOAD}, matchCount = {7}, failOn = TRAP + ALLOC + STORE)
+    // FIXME
+    //@Test(valid = ValueTypePassFieldsAsArgsOff, match = {ALLOC, STORE}, matchCount = {1, 9}, failOn = LOAD + TRAP)
     @Test(valid = ValueTypePassFieldsAsArgsOff, match = {ALLOC, STORE}, matchCount = {1, 3}, failOn = LOAD + TRAP)
     public MyValue1 test9(boolean b) {
         MyValue1 v;
@@ -395,7 +413,7 @@
 
     // Create a value type in a non-inlined method and then call a
     // non-inlined method on that value type.
-    @Test(valid = ValueTypePassFieldsAsArgsOn, failOn = (ALLOC + STORE + TRAP), match = {LOAD}, matchCount = {9})
+    @Test(valid = ValueTypePassFieldsAsArgsOn, failOn = (ALLOC + STORE + TRAP), match = {LOAD}, matchCount = {7})
     @Test(valid = ValueTypePassFieldsAsArgsOff, failOn = (ALLOC + LOAD + STORE + TRAP))
     public long test14() {
         MyValue1 v = MyValue1.createDontInline(rI, rL);
@@ -489,7 +507,7 @@
         Asserts.assertEQ(result, hash());
     }
 
-    // Create a value type in compiled code and pass it to the
+    // Create a value type (array) in compiled code and pass it to the
     // interpreter via a call. The value type is live at the uncommon
     // trap: verify that deoptimization causes the value type to be
     // correctly allocated.
@@ -497,20 +515,23 @@
     @Test(valid = ValueTypePassFieldsAsArgsOff, match = {ALLOC}, matchCount = {1}, failOn = LOAD)
     public long test20(boolean flag) {
         MyValue1 v = MyValue1.createInline(rI, rL);
+        // TODO add value type array testcase
+        // MyValue1[] va = new MyValue1[42];
         if (flag) {
             // uncommon trap
             WHITE_BOX.deoptimizeMethod(tests.get("ValueTypeTestBench::test20"));
         }
-        return v.hashInterpreted();
+        return v.hashInterpreted(); // + va[0].hashInterpreted();
     }
 
     @DontCompile
     public void test20_verifier(boolean warmup) {
+        MyValue1[] va = new MyValue1[42];
         long result = test20(false);
-        Asserts.assertEQ(result, hash());
+        Asserts.assertEQ(result, hash() /* + va[0].hash() */);
         if (!warmup) {
             result = test20(true);
-            Asserts.assertEQ(result, hash());
+            Asserts.assertEQ(result, hash() /* + va[0].hash() */);
         }
     }
 
@@ -567,19 +588,22 @@
     @Test(failOn = ALLOC + LOAD + STORE + LOOP + TRAP)
     public long test23() {
         MyValue1 v = MyValue1.createInline(rI, rL);
+        // TODO add OSR testcase for value type arrays
+        //MyValue1[] va = new MyValue1[10];
         long result = 0;
         // Long loop to trigger OSR compilation
         for (int i = 0 ; i < 100_000 ; ++i) {
             // Reference local value type in interpreter state
-            result = v.hash();
+            result = v.hash(); // + va[0].hash();
         }
         return result;
     }
 
     @DontCompile
     public void test23_verifier(boolean warmup) {
+        //MyValue1[] va = new MyValue1[10];
         long result = test23();
-        Asserts.assertEQ(result, hash());
+        Asserts.assertEQ(result, hash() /* + va[0].hash() */);
     }
 
     // Test interpreter to compiled code with various signatures
@@ -789,129 +813,292 @@
     // Test vbox and vunbox
     @Test
     public long test37() throws Throwable {
-   	return (long)vccUnboxLoadLongMH.invokeExact(vcc);
+        return (long)vccUnboxLoadLongMH.invokeExact(vcc);
     }
 
     @DontCompile
     public void test37_verifier(boolean warmup) {
-   	try {
-   	    long result = test37();
-   	    Asserts.assertEQ(vcc.t, result, "Field t of input and result must be equal.");
-   	} catch (Throwable t) {
-   	    throw new RuntimeException("test 37 failed", t);
-   	}
+        try {
+            long result = test37();
+            Asserts.assertEQ(vcc.t, result, "Field t of input and result must be equal.");
+        } catch (Throwable t) {
+            throw new RuntimeException("test 37 failed", t);
+        }
     }
 
     // Generate a MethodHandle that obtains field t of the
-    // derived value type	
+    // derived value type
     private static MethodHandle generateVCCUnboxLoadLongMH() {
-	return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
-					    "vccUnboxLoadLong",
-					    MethodType.methodType(long.class, ValueCapableClass1.class),
-					    CODE -> {
-						CODE.
-						    aload_0().
-						    vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
-						    vgetfield(ValueType.forClass(ValueCapableClass1.class).valueClass(), "t", "J").
-						    lreturn();
-					    }
-					    );	
+        return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
+                "vccUnboxLoadLong",
+                MethodType.methodType(long.class, ValueCapableClass1.class),
+                CODE -> {
+                    CODE.
+                    aload_0().
+                    vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
+                    vgetfield(ValueType.forClass(ValueCapableClass1.class).valueClass(), "t", "J").
+                    lreturn();
+                }
+                );
     }
 
-
     @Test
     public int test38() throws Throwable {
-   	return (int)vccUnboxLoadIntMH.invokeExact(vcc);
+        return (int)vccUnboxLoadIntMH.invokeExact(vcc);
     }
 
     @DontCompile
     public void test38_verifier(boolean warmup) {
-   	try {
-   	    int result = test38();
-   	    Asserts.assertEQ(vcc.x, result, "Field x of input and result must be equal.");
-   	} catch (Throwable t) {
-   	    throw new RuntimeException("test 38 failed", t);
-   	}
+        try {
+            int result = test38();
+            Asserts.assertEQ(vcc.x, result, "Field x of input and result must be equal.");
+        } catch (Throwable t) {
+            throw new RuntimeException("test 38 failed", t);
+        }
     }
 
     // Generate a MethodHandle that obtains field x of the
-    // derived value type	
+    // derived value type
     private static MethodHandle generateVCCUnboxLoadIntMH() {
-	return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
-					    "vccUnboxLoadInt",
-					    MethodType.methodType(int.class, ValueCapableClass1.class),
-					    CODE -> {
-						CODE.
-						    aload_0().
-						    vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
-						    vgetfield(ValueType.forClass(ValueCapableClass1.class).valueClass(), "x", "I").
-						    ireturn();
-					    }
-					    );	
+        return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
+                "vccUnboxLoadInt",
+                MethodType.methodType(int.class, ValueCapableClass1.class),
+                CODE -> {
+                    CODE.
+                    aload_0().
+                    vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
+                    vgetfield(ValueType.forClass(ValueCapableClass1.class).valueClass(), "x", "I").
+                    ireturn();
+                }
+                );
     }
 
     @Test
     public ValueCapableClass1 test39() throws Throwable {
-   	return (ValueCapableClass1)vccUnboxBoxMH.invokeExact(vcc);
+        return (ValueCapableClass1)vccUnboxBoxMH.invokeExact(vcc);
     }
 
     @DontCompile
     public void test39_verifier(boolean warmup) {
-   	try {
-   	    ValueCapableClass1 result = test39();
-   	    Asserts.assertEQ(vcc.value(), result.value(), "Value of VCC and returned VCC must be equal");
-   	} catch (Throwable t) {
-   	    throw new RuntimeException("test 39 failed", t);
-   	}
+        try {
+            ValueCapableClass1 result = test39();
+            Asserts.assertEQ(vcc.value(), result.value(), "Value of VCC and returned VCC must be equal");
+        } catch (Throwable t) {
+            throw new RuntimeException("test 39 failed", t);
+        }
     }
 
     // Generate a MethodHandle that takes a value-capable class,
     // unboxes it, then boxes it again and returns it.
     private static MethodHandle generateVCCUnboxBoxMH() {
-	return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
-					    "vccUnboxBox",
-					    MethodType.methodType(ValueCapableClass1.class, ValueCapableClass1.class),
-					    CODE -> {
-						CODE.
-						    aload_0().
-						    vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
-						    vbox(ValueCapableClass1.class).
-						    areturn();
-					    }
-					    );	
+        return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
+                "vccUnboxBox",
+                MethodType.methodType(ValueCapableClass1.class, ValueCapableClass1.class),
+                CODE -> {
+                    CODE.
+                    aload_0().
+                    vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
+                    vbox(ValueCapableClass1.class).
+                    areturn();
+                }
+                );
     }
 
     @Test
     public int test40() throws Throwable {
-   	return (int)vccUnboxBoxLoadIntMH.invokeExact(vcc);
+        return (int)vccUnboxBoxLoadIntMH.invokeExact(vcc);
     }
 
     @DontCompile
     public void test40_verifier(boolean warmup) {
-   	try {
-   	    int result = test40();
-   	    Asserts.assertEQ(vcc.x, result, "Field x of VCC and result must be equal");
-   	} catch (Throwable t) {
-   	    throw new RuntimeException("Test failed in the interpeter", t);
-   	}
+        try {
+            int result = test40();
+            Asserts.assertEQ(vcc.x, result, "Field x of VCC and result must be equal");
+        } catch (Throwable t) {
+            throw new RuntimeException("Test failed in the interpeter", t);
+        }
     }
 
     // Generate a MethodHandle that takes a value-capable class,
     // unboxes it, boxes it, reads a field from it, and returns the
     // field.
     private static MethodHandle generateVCCUnboxBoxLoadIntMH() {
-	return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
-					    "vccUnboxBoxLoadInt",
-					    MethodType.methodType(int.class, ValueCapableClass1.class),
-					    CODE -> {
-						CODE.
-						    aload_0().
-						    vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
-						    vbox(ValueCapableClass1.class).
-						    getfield(ValueCapableClass1.class, "x", "I").
-						    ireturn();
-					    }
-					    );
+        return MethodHandleBuilder.loadCode(MethodHandles.lookup(),
+                "vccUnboxBoxLoadInt",
+                MethodType.methodType(int.class, ValueCapableClass1.class),
+                CODE -> {
+                    CODE.
+                    aload_0().
+                    vunbox(ValueType.forClass(ValueCapableClass1.class).valueClass()).
+                    vbox(ValueCapableClass1.class).
+                    getfield(ValueCapableClass1.class, "x", "I").
+                    ireturn();
+                }
+                );
+
+    }
+
+    // Test value type array creation and initialization
+    @Test(valid = ValueTypeArrayFlattenOff, failOn = (LOAD))
+    @Test(valid = ValueTypeArrayFlattenOn)
+    public MyValue1[] test41(int len) {
+        MyValue1[] va = new MyValue1[len];
+        for (int i = 0; i < len; ++i) {
+            va[i] = MyValue1.createDontInline(rI, rL);
+        }
+        return va;
+    }
+
+    @DontCompile
+    public void test41_verifier(boolean warmup) {
+        int len = Math.abs(rI % 10);
+        MyValue1[] va = test41(len);
+        for (int i = 0; i < len; ++i) {
+            Asserts.assertEQ(va[i].hash(), hash());
+        }
+    }
+
+    // Test creation of a value type array and element access
+    @Test(failOn = (LOOP + LOAD + TRAP))
+    public long test42() {
+        MyValue1[] va = new MyValue1[1];
+        va[0] = MyValue1.createInline(rI, rL);
+        return va[0].hash();
+    }
+
+    @DontCompile
+    public void test42_verifier(boolean warmup) {
+        long result = test42();
+        Asserts.assertEQ(result, hash());
+    }
+
+    // Test receiving a value type array from the interpreter,
+    // updating its elements in a loop and computing a hash.
+    @Test(failOn = (ALLOCA))
+    public long test43(MyValue1[] va) {
+        long result = 0;
+        for (int i = 0; i < 10; ++i) {
+            result += va[i].hash();
+            va[i] = MyValue1.createInline(rI + 1, rL + 1);
+        }
+        return result;
+    }
+
+    @DontCompile
+    public void test43_verifier(boolean warmup) {
+        MyValue1[] va = new MyValue1[10];
+        long expected = 0;
+        for (int i = 0; i < 10; ++i) {
+            va[i] = MyValue1.createDontInline(rI + i, rL + i);
+            expected += va[i].hash();
+        }
+        long result = test43(va);
+        Asserts.assertEQ(expected, result);
+        for (int i = 0; i < 10; ++i) {
+            if (va[i].hash() != hash(rI + 1, rL + 1)) {
+                Asserts.assertEQ(va[i].hash(), hash(rI + 1, rL + 1));
+            }
+        }
+    }
+
+    // Test returning a value type array received from the interpreter
+    @Test(failOn = ALLOC + ALLOCA + LOAD + LOADP + STORE + LOOP + TRAP)
+    public MyValue1[] test44(MyValue1[] va) {
+        return va;
+    }
+
+    @DontCompile
+    public void test44_verifier(boolean warmup) {
+        MyValue1[] va = new MyValue1[10];
+        for (int i = 0; i < 10; ++i) {
+            va[i] = MyValue1.createDontInline(rI + i, rL + i);
+        }
+        va = test44(va);
+        for (int i = 0; i < 10; ++i) {
+            Asserts.assertEQ(va[i].hash(), hash(rI + i, rL + i));
+        }
+    }
+
+    // TODO add match rules
+    @Test()
+    public MyValue1[] test45(boolean b) {
+        MyValue1[] va;
+        if (b) {
+            va = new MyValue1[5];
+            for (int i = 0; i < 5; ++i) {
+                va[i] = MyValue1.createInline(rI, rL);
+            }
+        } else {
+            va = new MyValue1[10];
+            for (int i = 0; i < 10; ++i) {
+                va[i] = MyValue1.createInline(rI + i, rL + i);
+            }
+        }
+        long sum = va[0].hashInterpreted();
+        if (b) {
+            va[0] = MyValue1.createDontInline(rI, sum);
+        } else {
+            va[0] = MyValue1.createDontInline(rI + 1, sum + 1);
+        }
+        return va;
+    }
+
+    @DontCompile
+    public void test45_verifier(boolean warmup) {
+        MyValue1[] va = test45(true);
+        Asserts.assertEQ(va.length, 5);
+        Asserts.assertEQ(va[0].hash(), hash(rI, hash()));
+        for (int i = 1; i < 5; ++i) {
+            Asserts.assertEQ(va[i].hash(), hash());
+        }
+        va = test45(false);
+        Asserts.assertEQ(va.length, 10);
+        Asserts.assertEQ(va[0].hash(), hash(rI + 1, hash(rI, rL) + 1));
+        for (int i = 1; i < 10; ++i) {
+            Asserts.assertEQ(va[i].hash(), hash(rI + i, rL + i));
+        }
+    }
+
+    // Test creation of value type array with single element
+    @Test(failOn = LOOP + TRAP)
+    public MyValue1 test46() {
+        MyValue1[] va = new MyValue1[1];
+        return va[0];
+    }
+
+    @DontCompile
+    public void test46_verifier(boolean warmup) {
+        MyValue1[] va = new MyValue1[1];
+        MyValue1 v = test46();
+        Asserts.assertEQ(v.hash(), va[0].hash());
+    }
+
+    // Test default initialization of value type arrays
+    @Test(failOn = LOAD)
+    public MyValue1[] test47(int len) {
+        return new MyValue1[len];
+    }
+
+    @DontCompile
+    public void test47_verifier(boolean warmup) {
+        int len = Math.abs(rI % 10);
+        MyValue1[] va = new MyValue1[len];
+        MyValue1[] var = test47(len);
+        for (int i = 0; i < len; ++i) {
+            Asserts.assertEQ(va[i].hash(), var[i].hash());
+        }
+    }
+
+    // Test creation of value type array with zero length
+    @Test(failOn = ALLOC + LOAD + STORE + LOOP + TRAP)
+    public MyValue1[] test48() {
+        return new MyValue1[0];
+    }
+
+    @DontCompile
+    public void test48_verifier(boolean warmup) {
+        MyValue1[] va = test48();
+        Asserts.assertEQ(va.length, 0);
     }
 
     // ========== Test infrastructure ==========
@@ -919,8 +1106,11 @@
     private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
     private static final int ValueTypePassFieldsAsArgsOn = 0x1;
     private static final int ValueTypePassFieldsAsArgsOff = 0x2;
-    static final int AllFlags = ValueTypePassFieldsAsArgsOn | ValueTypePassFieldsAsArgsOff;
+    private static final int ValueTypeArrayFlattenOn = 0x4;
+    private static final int ValueTypeArrayFlattenOff = 0x8;
+    static final int AllFlags = ValueTypePassFieldsAsArgsOn | ValueTypePassFieldsAsArgsOff | ValueTypeArrayFlattenOn | ValueTypeArrayFlattenOff;
     private static final boolean ValueTypePassFieldsAsArgs = (Boolean)WHITE_BOX.getVMFlag("ValueTypePassFieldsAsArgs");
+    private static final boolean ValueTypeArrayFlatten = (Boolean)WHITE_BOX.getVMFlag("ValueArrayFlatten");
     private static final int COMP_LEVEL_ANY = -1;
     private static final int COMP_LEVEL_FULL_OPTIMIZATION = 4;
     private static final Hashtable<String, Method> tests = new Hashtable<String, Method>();
@@ -934,11 +1124,14 @@
     private static final String START = "(\\d+\\t(.*";
     private static final String MID = ".*)+\\t===.*";
     private static final String END = ")|";
-    private static final String ALLOC = START + "CallStaticJava" + MID + "_new_instance_Java" + END;
-    private static final String LOAD  = START + "Load" + MID + "valuetype\\*" + END;
-    private static final String STORE = START + "Store" + MID + "valuetype\\*" + END;
-    private static final String LOOP  = START + "Loop" + MID + "" + END;
-    private static final String TRAP  = START + "CallStaticJava" + MID + "uncommon_trap" + END;
+    private static final String ALLOC  = START + "CallStaticJava" + MID + "_new_instance_Java" + END;
+    private static final String ALLOCA = START + "CallStaticJava" + MID + "_new_array_Java" + END;
+    private static final String LOAD   = START + "Load(B|S|I|L|F|D)" + MID + "valuetype\\*" + END;
+    private static final String LOADP  = START + "Load(P|N)" + MID + "valuetype\\*" + END;
+    private static final String STORE  = START + "Store(B|S|I|L|F|D)" + MID + "valuetype\\*" + END;
+    private static final String STOREP = START + "Store(P|N)" + MID + "valuetype\\*" + END;
+    private static final String LOOP   = START + "Loop" + MID + "" + END;
+    private static final String TRAP   = START + "CallStaticJava" + MID + "uncommon_trap" + END;
     // TODO: match field values of scalar replaced object
     private static final String SCOBJ = "(.*# ScObj.*" + END;
 
@@ -961,7 +1154,7 @@
                 "-XX:CompileCommand=quiet", "-XX:CompileCommand=compileonly,compiler.valhalla.valuetypes.ValueTypeTestBench::*",
                 "-XX:CompileCommand=compileonly,compiler.valhalla.valuetypes.MyValue1::*",
                 "-XX:CompileCommand=compileonly,compiler.valhalla.valuetypes.MyValue2::*"
-                                                               ));
+                ));
         all_args.addAll(List.of(extra_args));
         // Run tests in own process and verify output
         all_args.add(ValueTypeTestBench.class.getName());
@@ -980,13 +1173,19 @@
     public static void main(String[] args) throws Throwable {
         if (args.length == 0) {
             String field_as_args;
-            if ((Boolean)WHITE_BOX.getVMFlag("ValueTypePassFieldsAsArgs")) {
+            String array_flatten;
+            if (ValueTypePassFieldsAsArgs) {
                 field_as_args = "-XX:+ValueTypePassFieldsAsArgs";
             } else {
                 field_as_args = "-XX:-ValueTypePassFieldsAsArgs";
             }
-            execute_vm("-XX:+UnlockExperimentalVMOptions", field_as_args);
-            execute_vm("-XX:+AlwaysIncrementalInline", "-XX:+UnlockExperimentalVMOptions", field_as_args);
+            if (ValueTypeArrayFlatten) {
+                array_flatten = "-XX:+ValueArrayFlatten";
+            } else {
+                array_flatten = "-XX:-ValueArrayFlatten";
+            }
+            execute_vm("-XX:+UnlockExperimentalVMOptions", field_as_args, array_flatten);
+            execute_vm("-XX:+AlwaysIncrementalInline", "-XX:+UnlockExperimentalVMOptions", field_as_args, array_flatten);
         } else {
             if (USE_COMPILER && PRINT_IDEAL && !XCOMP) {
                 System.out.println("PrintIdeal enabled");
@@ -1027,6 +1226,12 @@
                 } else if ((a.valid() & ValueTypePassFieldsAsArgsOff) != 0 && !ValueTypePassFieldsAsArgs) {
                     assert anno == null;
                     anno = a;
+                } else if ((a.valid() & ValueTypeArrayFlattenOn) != 0 && ValueTypeArrayFlatten) {
+                    assert anno == null;
+                    anno = a;
+                } else if ((a.valid() & ValueTypeArrayFlattenOff) != 0 && !ValueTypeArrayFlatten) {
+                    assert anno == null;
+                    anno = a;
                 }
             }
             assert anno != null;
@@ -1034,13 +1239,8 @@
             if (!regexFail.isEmpty()) {
                 Pattern pattern = Pattern.compile(regexFail.substring(0, regexFail.length()-1));
                 Matcher matcher = pattern.matcher(graph);
-                boolean fail = false;
-                while (matcher.find()) {
-                    System.out.println("Graph for '" + testName + "' contains forbidden node:");
-                    System.out.println(matcher.group());
-                    fail = true;
-                }
-                Asserts.assertFalse(fail, "Graph for '" + testName + "' contains forbidden nodes");
+                boolean found = matcher.find();
+                Asserts.assertFalse(found, "Graph for '" + testName + "' contains forbidden node:\n" + (found ? matcher.group() : ""));
             }
             String[] regexMatch = anno.match();
             int[] matchCount = anno.matchCount();
@@ -1053,11 +1253,7 @@
                     count++;
                     nodes += matcher.group() + "\n";
                 }
-                if (matchCount[i] != count) {
-                    System.out.println("Graph for '" + testName + "' contains different number of match nodes:");
-                    System.out.println(nodes);
-                }
-                Asserts.assertEQ(matchCount[i], count, "Graph for '" + testName + "' contains different number of match nodes");
+                Asserts.assertEQ(matchCount[i], count, "Graph for '" + testName + "' contains different number of match nodes:\n" + nodes);
             }
             tests.remove(testName);
             System.out.println(testName + " passed");
--- /dev/null	2017-01-09 08:20:50.095055928 +0100
+++ new/src/share/vm/ci/ciValueArrayKlass.cpp	2017-01-09 14:53:36.766908430 +0100
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "ci/ciInstanceKlass.hpp"
+#include "ci/ciValueArrayKlass.hpp"
+#include "ci/ciSymbol.hpp"
+#include "ci/ciUtilities.hpp"
+#include "oops/valueArrayKlass.hpp"
+
+// ciValueArrayKlass
+//
+// This class represents a Klass* in the HotSpot virtual machine
+// whose Klass part is a ValueArrayKlass.
+
+// ------------------------------------------------------------------
+// ciValueArrayKlass::ciValueArrayKlass
+//
+// Constructor for loaded value array klasses.
+ciValueArrayKlass::ciValueArrayKlass(KlassHandle h_k) : ciArrayKlass(h_k) {
+  assert(get_Klass()->is_valueArray_klass(), "wrong type");
+  ValueKlass* element_Klass = get_ValueArrayKlass()->element_klass();
+  _base_element_klass = CURRENT_ENV->get_klass(element_Klass);
+  assert(_base_element_klass->is_valuetype(), "bad base klass");
+  if (dimension() == 1) {
+    _element_klass = _base_element_klass;
+  } else {
+    _element_klass = NULL;
+  }
+  if (!ciObjectFactory::is_initialized()) {
+    assert(_element_klass->is_java_lang_Object(), "only arrays of object are shared");
+  }
+}
+
+// ------------------------------------------------------------------
+// ciValueArrayKlass::element_klass
+//
+// What is the one-level element type of this array?
+ciKlass* ciValueArrayKlass::element_klass() {
+  if (_element_klass == NULL) {
+    assert(dimension() > 1, "_element_klass should not be NULL");
+    // Produce the element klass.
+    if (is_loaded()) {
+      VM_ENTRY_MARK;
+      Klass* element_Klass = get_ValueArrayKlass()->element_klass();
+      _element_klass = CURRENT_THREAD_ENV->get_klass(element_Klass);
+    } else {
+      // TODO handle this
+      guarantee(false, "unloaded array klass");
+      VM_ENTRY_MARK;
+      // We are an unloaded array klass.  Attempt to fetch our
+      // element klass by name.
+      _element_klass = CURRENT_THREAD_ENV->get_klass_by_name_impl(
+                          this,
+                          constantPoolHandle(),
+                          construct_array_name(base_element_klass()->name(),
+                                               dimension() - 1),
+                          false);
+    }
+  }
+  return _element_klass;
+}
+
+// ------------------------------------------------------------------
+// ciValueArrayKlass::construct_array_name
+//
+// Build an array name from an element name and a dimension.
+ciSymbol* ciValueArrayKlass::construct_array_name(ciSymbol* element_name,
+                                                  int dimension) {
+  EXCEPTION_CONTEXT;
+  int element_len = element_name->utf8_length();
+
+  Symbol* base_name_sym = element_name->get_symbol();
+  char* name;
+
+  if (base_name_sym->byte_at(0) == '[' ||
+      (base_name_sym->byte_at(0) == 'L' &&  // watch package name 'Lxx'
+       base_name_sym->byte_at(element_len-1) == ';')) {
+
+    int new_len = element_len + dimension + 1; // for the ['s and '\0'
+    name = CURRENT_THREAD_ENV->name_buffer(new_len);
+
+    int pos = 0;
+    for ( ; pos < dimension; pos++) {
+      name[pos] = '[';
+    }
+    strncpy(name+pos, (char*)element_name->base(), element_len);
+    name[new_len-1] = '\0';
+  } else {
+    int new_len =   3                       // for L, ;, and '\0'
+                  + dimension               // for ['s
+                  + element_len;
+
+    name = CURRENT_THREAD_ENV->name_buffer(new_len);
+    int pos = 0;
+    for ( ; pos < dimension; pos++) {
+      name[pos] = '[';
+    }
+    name[pos++] = 'L';
+    strncpy(name+pos, (char*)element_name->base(), element_len);
+    name[new_len-2] = ';';
+    name[new_len-1] = '\0';
+  }
+  return ciSymbol::make(name);
+}
+
+// ------------------------------------------------------------------
+// ciValueArrayKlass::make_impl
+//
+// Implementation of make.
+ciValueArrayKlass* ciValueArrayKlass::make_impl(ciKlass* element_klass) {
+  assert(ValueArrayFlatten, "should only be used for flattened value type arrays");
+  assert(element_klass->is_valuetype(), "element type must be value type");
+  if (element_klass->is_loaded()) {
+    EXCEPTION_CONTEXT;
+    // The element klass is loaded
+    Klass* array = element_klass->get_Klass()->array_klass(THREAD);
+    if (HAS_PENDING_EXCEPTION) {
+      CLEAR_PENDING_EXCEPTION;
+      CURRENT_THREAD_ENV->record_out_of_memory_failure();
+      // TODO handle this
+      guarantee(false, "out of memory");
+      return NULL;
+    }
+    return CURRENT_THREAD_ENV->get_value_array_klass(array);
+  }
+
+  // TODO handle this
+  guarantee(false, "klass not loaded");
+  return NULL;
+}
+
+// ------------------------------------------------------------------
+// ciValueArrayKlass::make
+//
+// Make an array klass corresponding to the specified primitive type.
+ciValueArrayKlass* ciValueArrayKlass::make(ciKlass* element_klass) {
+  GUARDED_VM_ENTRY(return make_impl(element_klass);)
+}
+
+ciKlass* ciValueArrayKlass::exact_klass() {
+  ShouldNotCallThis();
+  return NULL;
+}
--- /dev/null	2017-01-09 08:20:50.095055928 +0100
+++ new/src/share/vm/ci/ciValueArrayKlass.hpp	2017-01-09 14:53:37.218908409 +0100
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_VM_CI_CIVALUEARRAYKLASS_HPP
+#define SHARE_VM_CI_CIVALUEARRAYKLASS_HPP
+
+// ciValueArrayKlass
+//
+// This class represents a Klass* in the HotSpot virtual machine
+// whose Klass part is a ValueArrayKlass.
+class ciValueArrayKlass : public ciArrayKlass {
+  CI_PACKAGE_ACCESS
+  friend class ciEnv;
+
+private:
+  ciKlass* _element_klass;
+  // TODO remove this??
+  ciKlass* _base_element_klass;
+
+protected:
+  ciValueArrayKlass(KlassHandle h_k);
+
+  ValueArrayKlass* get_ValueArrayKlass() {
+    return (ValueArrayKlass*)get_Klass();
+  }
+
+  static ciValueArrayKlass* make_impl(ciKlass* element_klass);
+  static ciSymbol* construct_array_name(ciSymbol* element_name,
+                                        int       dimension);
+
+  const char* type_string() { return "ciValueArrayKlass"; }
+
+  oop     loader()        { return _base_element_klass->loader(); }
+  jobject loader_handle() { return _base_element_klass->loader_handle(); }
+
+  oop     protection_domain()        { return _base_element_klass->protection_domain(); }
+  jobject protection_domain_handle() { return _base_element_klass->protection_domain_handle(); }
+
+
+public:
+  // The one-level type of the array elements.
+  ciKlass* element_klass();
+
+  // TODO refactor all of this
+  int log2_element_size() {
+    return Klass::layout_helper_log2_element_size(layout_helper());
+  }
+
+  // The innermost type of the array elements.
+  ciKlass* base_element_klass() { return _base_element_klass; }
+
+  // What kind of ciObject is this?
+  bool is_value_array_klass() const { return true; }
+
+  static ciValueArrayKlass* make(ciKlass* element_klass);
+
+  virtual ciKlass* exact_klass();
+};
+
+
+#endif // SHARE_VM_CI_CIVALUEARRAYKLASS_HPP