1 /*
  2  * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  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_OOPS_TYPEARRAYKLASS_HPP
 26 #define SHARE_OOPS_TYPEARRAYKLASS_HPP
 27 
 28 #include "oops/arrayKlass.hpp"
 29 
 30 class ClassLoaderData;
 31 
 32 // A TypeArrayKlass is the klass of a typeArray
 33 // It contains the type and size of the elements
 34 
 35 class TypeArrayKlass : public ArrayKlass {
 36   friend class VMStructs;
 37 
 38  public:
 39   static const KlassKind Kind = TypeArrayKlassKind;
 40 
 41  private:
 42   jint _max_length;            // maximum number of elements allowed in an array
 43 
 44   // Constructor
 45   TypeArrayKlass(BasicType type, Symbol* name);
 46   static TypeArrayKlass* allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS);
 47  public:
 48   TypeArrayKlass() {} // For dummy objects.
 49 
 50   // instance variables
 51   jint max_length()                     { return _max_length; }
 52   void set_max_length(jint m)           { _max_length = m;    }
 53 
 54   // testers
 55   DEBUG_ONLY(bool is_typeArray_klass_slow() const  { return true; })
 56 
 57   // klass allocation
 58   static TypeArrayKlass* create_klass(BasicType type, const char* name_str,
 59                                TRAPS);
 60   static TypeArrayKlass* create_klass(BasicType type, TRAPS) {
 61     return create_klass(type, external_name(type), THREAD);
 62   }
 63 
 64   size_t oop_size(oop obj, markWord mark) const;
 65 
 66   // Allocation
 67   typeArrayOop allocate_common(int length, bool do_zero, TRAPS);
 68   typeArrayOop allocate(int length, TRAPS) { return allocate_common(length, true, THREAD); }
 69   oop multi_allocate(int rank, jint* sizes, TRAPS);
 70 
 71   oop protection_domain() const { return nullptr; }
 72 
 73   // Copying
 74   void  copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS);
 75 
 76   u2 compute_modifier_flags() const;
 77 
 78   // Oop iterators. Since there are no oops in TypeArrayKlasses,
 79   // these functions only return the size of the object.
 80 
 81  private:
 82   // The implementation used by all oop_oop_iterate functions in TypeArrayKlasses.
 83   inline void oop_oop_iterate_impl(oop obj, OopIterateClosure* closure);
 84 
 85  public:
 86   // Wraps oop_oop_iterate_impl to conform to macros.
 87   template <typename T, typename OopClosureType>
 88   inline void oop_oop_iterate(oop obj, OopClosureType* closure);
 89 
 90   // Wraps oop_oop_iterate_impl to conform to macros.
 91   template <typename T, typename OopClosureType>
 92   inline void oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr);
 93 
 94   // Wraps oop_oop_iterate_impl to conform to macros.
 95   template <typename T, typename OopClosureType>
 96   inline void oop_oop_iterate_reverse(oop obj, OopClosureType* closure);
 97 
 98  public:
 99   static TypeArrayKlass* cast(Klass* k) {
100     return const_cast<TypeArrayKlass*>(cast(const_cast<const Klass*>(k)));
101   }
102 
103   static const TypeArrayKlass* cast(const Klass* k) {
104     assert(k->is_typeArray_klass(), "cast to TypeArrayKlass");
105     return static_cast<const TypeArrayKlass*>(k);
106   }
107 
108   // Naming
109   static const char* external_name(BasicType type);
110 
111   // Sizing
112   static int header_size()  { return sizeof(TypeArrayKlass)/wordSize; }
113   int size() const          { return ArrayKlass::static_size(header_size()); }
114 
115   // Initialization (virtual from Klass)
116   void initialize(TRAPS);
117 
118  public:
119   // Printing
120   void oop_print_on(oop obj, outputStream* st);
121   void oop_print_elements_on(typeArrayOop ta, outputStream* st);
122   void print_on(outputStream* st) const;
123   void print_value_on(outputStream* st) const;
124 
125  public:
126   const char* internal_name() const;
127 
128   ModuleEntry* module() const;
129   PackageEntry* package() const;
130 };
131 
132 #endif // SHARE_OOPS_TYPEARRAYKLASS_HPP