8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_VM_OOPS_OBJARRAYOOP_HPP 26 #define SHARE_VM_OOPS_OBJARRAYOOP_HPP 27 28 #include "oops/arrayOop.hpp" 29 30 // An objArrayOop is an array containing oops. 31 // Evaluating "String arg[10]" will create an objArrayOop. 32 33 class objArrayOopDesc : public arrayOopDesc { 34 friend class ObjArrayKlass; 35 friend class Runtime1; 36 friend class psPromotionManager; 37 friend class CSetMarkOopClosure; 38 friend class G1ParScanPartialArrayClosure; 39 40 template <class T> T* obj_at_addr(int index) const { 41 assert(is_within_bounds(index), "index out of bounds"); 42 return &((T*)base())[index]; 43 } 44 45 private: 46 // Give size of objArrayOop in HeapWords minus the header 47 static int array_size(int length) { 48 const uint OopsPerHeapWord = HeapWordSize/heapOopSize; 49 assert(OopsPerHeapWord >= 1 && (HeapWordSize % heapOopSize == 0), 62 old_res = length * HeapWordsPerOop; 63 } else { 64 old_res = align_size_up((uint)length, OopsPerHeapWord)/OopsPerHeapWord; 65 } 66 assert(res == old_res, "Inconsistency between old and new."); 67 #endif // ASSERT 68 return res; 69 } 70 71 public: 72 // Returns the offset of the first element. 73 static int base_offset_in_bytes() { 74 return arrayOopDesc::base_offset_in_bytes(T_OBJECT); 75 } 76 77 // base is the address following the header. 78 HeapWord* base() const { return (HeapWord*) arrayOopDesc::base(T_OBJECT); } 79 80 // Accessing 81 oop obj_at(int index) const { 82 // With UseCompressedOops decode the narrow oop in the objArray to an 83 // uncompressed oop. Otherwise this is simply a "*" operator. 84 if (UseCompressedOops) { 85 return load_decode_heap_oop(obj_at_addr<narrowOop>(index)); 86 } else { 87 return load_decode_heap_oop(obj_at_addr<oop>(index)); 88 } 89 } 90 91 void obj_at_put(int index, oop value) { 92 if (UseCompressedOops) { 93 oop_store(obj_at_addr<narrowOop>(index), value); 94 } else { 95 oop_store(obj_at_addr<oop>(index), value); 96 } 97 } 98 // Sizing 99 static int header_size() { return arrayOopDesc::header_size(T_OBJECT); } 100 int object_size() { return object_size(length()); } 101 102 static int object_size(int length) { 103 // This returns the object size in HeapWords. 104 uint asz = array_size(length); 105 uint osz = align_object_size(header_size() + asz); 106 assert(osz >= asz, "no overflow"); 107 assert((int)osz > 0, "no overflow"); 108 return (int)osz; | 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_VM_OOPS_OBJARRAYOOP_HPP 26 #define SHARE_VM_OOPS_OBJARRAYOOP_HPP 27 28 #include "memory/barrierSet.hpp" 29 #include "oops/arrayOop.hpp" 30 31 #if INCLUDE_ALL_GCS 32 #include "gc_implementation/shenandoah/shenandoahBarrierSet.hpp" 33 #endif 34 35 // An objArrayOop is an array containing oops. 36 // Evaluating "String arg[10]" will create an objArrayOop. 37 38 class objArrayOopDesc : public arrayOopDesc { 39 friend class ObjArrayKlass; 40 friend class Runtime1; 41 friend class psPromotionManager; 42 friend class CSetMarkOopClosure; 43 friend class G1ParScanPartialArrayClosure; 44 45 template <class T> T* obj_at_addr(int index) const { 46 assert(is_within_bounds(index), "index out of bounds"); 47 return &((T*)base())[index]; 48 } 49 50 private: 51 // Give size of objArrayOop in HeapWords minus the header 52 static int array_size(int length) { 53 const uint OopsPerHeapWord = HeapWordSize/heapOopSize; 54 assert(OopsPerHeapWord >= 1 && (HeapWordSize % heapOopSize == 0), 67 old_res = length * HeapWordsPerOop; 68 } else { 69 old_res = align_size_up((uint)length, OopsPerHeapWord)/OopsPerHeapWord; 70 } 71 assert(res == old_res, "Inconsistency between old and new."); 72 #endif // ASSERT 73 return res; 74 } 75 76 public: 77 // Returns the offset of the first element. 78 static int base_offset_in_bytes() { 79 return arrayOopDesc::base_offset_in_bytes(T_OBJECT); 80 } 81 82 // base is the address following the header. 83 HeapWord* base() const { return (HeapWord*) arrayOopDesc::base(T_OBJECT); } 84 85 // Accessing 86 oop obj_at(int index) const { 87 oop obj; 88 // With UseCompressedOops decode the narrow oop in the objArray to an 89 // uncompressed oop. Otherwise this is simply a "*" operator. 90 if (UseCompressedOops) { 91 obj = load_decode_heap_oop(obj_at_addr<narrowOop>(index)); 92 } else { 93 obj = load_decode_heap_oop(obj_at_addr<oop>(index)); 94 } 95 #if INCLUDE_ALL_GCS 96 if (UseShenandoahGC) { 97 obj = ShenandoahBarrierSet::barrier_set()->load_reference_barrier(obj); 98 } 99 #endif 100 return obj; 101 } 102 103 void obj_at_put(int index, oop value) { 104 if (UseCompressedOops) { 105 oop_store(obj_at_addr<narrowOop>(index), value); 106 } else { 107 oop_store(obj_at_addr<oop>(index), value); 108 } 109 } 110 // Sizing 111 static int header_size() { return arrayOopDesc::header_size(T_OBJECT); } 112 int object_size() { return object_size(length()); } 113 114 static int object_size(int length) { 115 // This returns the object size in HeapWords. 116 uint asz = array_size(length); 117 uint osz = align_object_size(header_size() + asz); 118 assert(osz >= asz, "no overflow"); 119 assert((int)osz > 0, "no overflow"); 120 return (int)osz; |