src/share/vm/opto/type.hpp

@@ -980,12 +980,12 @@
 
 //------------------------------TypeOopPtr-------------------------------------
 // Some kind of oop (Java pointer), either klass or instance or array.
 class TypeOopPtr : public TypePtr {
 protected:
-  TypeOopPtr(TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, Offset offset, int instance_id,
-             const TypePtr* speculative, int inline_depth);
+  TypeOopPtr(TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, Offset offset, Offset field_offset,
+             int instance_id, const TypePtr* speculative, int inline_depth);
 public:
   virtual bool eq( const Type *t ) const;
   virtual int  hash() const;             // Type specific hashing
   virtual bool singleton(void) const;    // TRUE if type is a singleton
   enum {

@@ -1172,14 +1172,14 @@
 };
 
 //------------------------------TypeAryPtr-------------------------------------
 // Class of Java array pointers
 class TypeAryPtr : public TypeOopPtr {
-  TypeAryPtr( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk,
+  TypeAryPtr(PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk,
               Offset offset, Offset field_offset, int instance_id, bool is_autobox_cache,
               const TypePtr* speculative, int inline_depth)
-    : TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id, speculative, inline_depth),
+    : TypeOopPtr(AryPtr, ptr, k, xk, o, offset, field_offset, instance_id, speculative, inline_depth),
     _ary(ary),
     _is_autobox_cache(is_autobox_cache),
     _field_offset(field_offset)
  {
 #ifdef ASSERT

@@ -1201,20 +1201,20 @@
   }
   virtual bool eq( const Type *t ) const;
   virtual int hash() const;     // Type specific hashing
   const TypeAry *_ary;          // Array we point into
   const bool     _is_autobox_cache;
-  Offset meet_field_offset(int offset) const;
+  // For flattened value type arrays, each field of the value type in
+  // the array has its own memory slice so we need to keep track of
+  // which field is accessed
+  const Offset _field_offset;
+  Offset meet_field_offset(const Type::Offset offset) const;
   Offset dual_field_offset() const;
 
   ciKlass* compute_klass(DEBUG_ONLY(bool verify = false)) const;
 
 public:
-  // For flattened value type arrays, each field of the value type in
-  // the array has its own memory slice so we need to keep track of
-  // which field is accessed
-  const Offset   _field_offset;
   // Accessors
   ciKlass* klass() const;
   const TypeAry* ary() const  { return _ary; }
   const Type*    elem() const { return _ary->_elem; }
   const TypeInt* size() const { return _ary->_size; }

@@ -1259,11 +1259,11 @@
   const TypeAryPtr* cast_to_stable(bool stable, int stable_dimension = 1) const;
   int stable_dimension() const;
 
   const TypeAryPtr* cast_to_autobox_cache(bool cache) const;
 
-  const int field_offset() const { return _field_offset.get(); }
+  const Offset field_offset() const { return _field_offset; }
   const TypeAryPtr* with_field_offset(int offset) const;
   const TypePtr* with_field_offset_and_offset(intptr_t offset) const;
 
   // Convenience common pre-built types.
   static const TypeAryPtr *RANGE;

@@ -1294,11 +1294,11 @@
 
 //------------------------------TypeValueTypePtr-------------------------------------
 // Class of value type pointers
 class TypeValueTypePtr : public TypeOopPtr {
   TypeValueTypePtr(const TypeValueType* vt, PTR ptr, ciObject* o, Offset offset, int instance_id, const TypePtr* speculative, int inline_depth)
-    : TypeOopPtr(ValueTypePtr, ptr, vt->value_klass(), true, o, offset, instance_id, speculative, inline_depth) {
+    : TypeOopPtr(ValueTypePtr, ptr, vt->value_klass(), true, o, offset, Offset::bottom, instance_id, speculative, inline_depth) {
     _vt = vt;
   }
 
   const TypeValueType* _vt;    // Value type we point to