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

7153771: array bound check elimination for c1
Summary: when possible optimize out array bound checks, inserting predicates when needed.
Reviewed-by: never, kvn, twisti
Contributed-by: thomaswue <thomas.wuerthinger@oracle.com>

     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   // Copying

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

    73   // Iteration

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

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

    77   // Garbage collection

    78   void oop_follow_contents(oop obj);

    79   int  oop_adjust_pointers(oop obj);

    81   // Parallel Scavenge and Parallel Old

    82   PARALLEL_GC_DECLS

    84  protected:

    85   // Find n'th dimensional array

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

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

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

    91  public:

    92   // Casting from Klass*

    93   static TypeArrayKlass* cast(Klass* k) {

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

    95     return (TypeArrayKlass*) k;

    96   }

    98   // Naming

    99   static const char* external_name(BasicType type);

   101   // Sizing

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

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

   105   // Initialization (virtual from Klass)

   106   void initialize(TRAPS);

   108  public:

   109   // Printing

   110 #ifndef PRODUCT

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

   112 #endif

   114   void print_on(outputStream* st) const;

   115   void print_value_on(outputStream* st) const;

   117  public:

   118   const char* internal_name() const;

   119 };

   121 #endif // SHARE_VM_OOPS_TYPEARRAYKLASS_HPP

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

src/share/vm/oops/typeArrayKlass.hpp@46f6f063b272

src/share/vm/oops/typeArrayKlass.hpp