jdk8-mips64-public/hotspot: src/share/vm/oops/typeArrayKlass.hpp@ac9cb1d5a202

8009130: Lambda: Fix access controls, loader constraints.
Summary: New default methods list with inherited superinterface methods
Reviewed-by: minqi, sspitsyn, coleenp

     1 /*

     2  * Copyright (c) 1997, 2012, 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  */

    25 #ifndef SHARE_VM_OOPS_TYPEARRAYKLASS_HPP

    26 #define SHARE_VM_OOPS_TYPEARRAYKLASS_HPP

    28 #include "classfile/classLoaderData.hpp"

    29 #include "oops/arrayKlass.hpp"

    31 // A TypeArrayKlass is the klass of a typeArray

    32 // It contains the type and size of the elements

    34 class TypeArrayKlass : public ArrayKlass {

    35   friend class VMStructs;

    36  private:

    37   jint _max_length;            // maximum number of elements allowed in an array

    39   // Constructor

    40   TypeArrayKlass(BasicType type, Symbol* name);

    41   static TypeArrayKlass* allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS);

    42  public:

    43   TypeArrayKlass() {} // For dummy objects.

    45   // instance variables

    46   jint max_length()                     { return _max_length; }

    47   void set_max_length(jint m)           { _max_length = m;    }

    49   // testers

    50   bool oop_is_typeArray_slow() const    { return true; }

    52   // klass allocation

    53   static TypeArrayKlass* create_klass(BasicType type, const char* name_str,

    54                                TRAPS);

    55   static inline Klass* create_klass(BasicType type, int scale, TRAPS) {

    56     TypeArrayKlass* tak = create_klass(type, external_name(type), CHECK_NULL);

    57     assert(scale == (1 << tak->log2_element_size()), "scale must check out");

    58     return tak;

    59   }

    61   int oop_size(oop obj) const;

    63   bool compute_is_subtype_of(Klass* k);

    65   // Allocation

    66   typeArrayOop allocate_common(int length, bool do_zero, TRAPS);

    67   typeArrayOop allocate(int length, TRAPS) { return allocate_common(length, true, THREAD); }

    68   oop multi_allocate(int rank, jint* sizes, TRAPS);

    70   oop protection_domain() const { return NULL; }

    72   // Copying

    73   void  copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS);

    75   // Iteration

    76   int oop_oop_iterate(oop obj, ExtendedOopClosure* blk);

    77   int oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr);

    79   // Garbage collection

    80   void oop_follow_contents(oop obj);

    81   int  oop_adjust_pointers(oop obj);

    83   // Parallel Scavenge and Parallel Old

    84   PARALLEL_GC_DECLS

    86  protected:

    87   // Find n'th dimensional array

    88   virtual Klass* array_klass_impl(bool or_null, int n, TRAPS);

    90   // Returns the array class with this class as element type

    91   virtual Klass* array_klass_impl(bool or_null, TRAPS);

    93  public:

    94   // Casting from Klass*

    95   static TypeArrayKlass* cast(Klass* k) {

    96     assert(k->oop_is_typeArray(), "cast to TypeArrayKlass");

    97     return (TypeArrayKlass*) k;

    98   }

   100   // Naming

   101   static const char* external_name(BasicType type);

   103   // Sizing

   104   static int header_size()  { return sizeof(TypeArrayKlass)/HeapWordSize; }

   105   int size() const          { return ArrayKlass::static_size(header_size()); }

   107   // Initialization (virtual from Klass)

   108   void initialize(TRAPS);

   110  public:

   111   // Printing

   112 #ifndef PRODUCT

   113   void oop_print_on(oop obj, outputStream* st);

   114 #endif

   116   void print_on(outputStream* st) const;

   117   void print_value_on(outputStream* st) const;

   119  public:

   120   const char* internal_name() const;

   121 };

   123 #endif // SHARE_VM_OOPS_TYPEARRAYKLASS_HPP

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/oops/typeArrayKlass.hpp@ac9cb1d5a202

src/share/vm/oops/typeArrayKlass.hpp