jdk8-mips64-public/hotspot: src/share/vm/oops/objArrayKlassKlass.cpp@8033953d67ff

7012648: move JSR 292 to package java.lang.invoke and adjust names
Summary: package and class renaming only; delete unused methods and classes
Reviewed-by: twisti

     1 /*

     2  * Copyright (c) 1997, 2011, 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 #include "precompiled.hpp"

    26 #include "classfile/javaClasses.hpp"

    27 #include "classfile/systemDictionary.hpp"

    28 #include "gc_implementation/shared/markSweep.inline.hpp"

    29 #include "gc_interface/collectedHeap.inline.hpp"

    30 #include "oops/instanceKlass.hpp"

    31 #include "oops/objArrayKlassKlass.hpp"

    32 #include "oops/oop.inline.hpp"

    33 #include "oops/oop.inline2.hpp"

    35 klassOop objArrayKlassKlass::create_klass(TRAPS) {

    36   objArrayKlassKlass o;

    37   KlassHandle h_this_klass(THREAD, Universe::klassKlassObj());

    38   KlassHandle k = base_create_klass(h_this_klass, header_size(), o.vtbl_value(), CHECK_0);

    39   assert(k()->size() == align_object_size(header_size()), "wrong size for object");

    40   java_lang_Class::create_mirror(k, CHECK_0); // Allocate mirror

    41   return k();

    42 }

    44 klassOop objArrayKlassKlass::allocate_system_objArray_klass(TRAPS) {

    45   // system_objArrays have no instance klass, so allocate with fake class, then reset to NULL

    46   KlassHandle kk(THREAD, Universe::intArrayKlassObj());

    47   klassOop k = allocate_objArray_klass(1, kk, CHECK_0);

    48   objArrayKlass* tk = (objArrayKlass*) k->klass_part();

    49   tk->set_element_klass(NULL);

    50   tk->set_bottom_klass(NULL);

    51   return k;

    52 }

    55 klassOop objArrayKlassKlass::allocate_objArray_klass(int n, KlassHandle element_klass, TRAPS) {

    56   objArrayKlassKlassHandle this_oop(THREAD, as_klassOop());

    57   return allocate_objArray_klass_impl(this_oop, n, element_klass, THREAD);

    58 }

    60 klassOop objArrayKlassKlass::allocate_objArray_klass_impl(objArrayKlassKlassHandle this_oop,

    61                                                           int n, KlassHandle element_klass, TRAPS) {

    63   // Eagerly allocate the direct array supertype.

    64   KlassHandle super_klass = KlassHandle();

    65   if (!Universe::is_bootstrapping()) {

    66     KlassHandle element_super (THREAD, element_klass->super());

    67     if (element_super.not_null()) {

    68       // The element type has a direct super.  E.g., String[] has direct super of Object[].

    69       super_klass = KlassHandle(THREAD, element_super->array_klass_or_null());

    70       bool supers_exist = super_klass.not_null();

    71       // Also, see if the element has secondary supertypes.

    72       // We need an array type for each.

    73       objArrayHandle element_supers = objArrayHandle(THREAD,

    74                                             element_klass->secondary_supers());

    75       for( int i = element_supers->length()-1; i >= 0; i-- ) {

    76         klassOop elem_super = (klassOop) element_supers->obj_at(i);

    77         if (Klass::cast(elem_super)->array_klass_or_null() == NULL) {

    78           supers_exist = false;

    79           break;

    80         }

    81       }

    82       if (!supers_exist) {

    83         // Oops.  Not allocated yet.  Back out, allocate it, and retry.

    84 #ifndef PRODUCT

    85         if (WizardMode) {

    86           tty->print_cr("Must retry array klass creation for depth %d",n);

    87         }

    88 #endif

    89         KlassHandle ek;

    90         {

    91           MutexUnlocker mu(MultiArray_lock);

    92           MutexUnlocker mc(Compile_lock);   // for vtables

    93           klassOop sk = element_super->array_klass(CHECK_0);

    94           super_klass = KlassHandle(THREAD, sk);

    95           for( int i = element_supers->length()-1; i >= 0; i-- ) {

    96             KlassHandle elem_super (THREAD, element_supers->obj_at(i));

    97             elem_super->array_klass(CHECK_0);

    98           }

    99           // Now retry from the beginning

   100           klassOop klass_oop = element_klass->array_klass(n, CHECK_0);

   101           // Create a handle because the enclosing brace, when locking

   102           // can cause a gc.  Better to have this function return a Handle.

   103           ek = KlassHandle(THREAD, klass_oop);

   104         }  // re-lock

   105         return ek();

   106       }

   107     } else {

   108       // The element type is already Object.  Object[] has direct super of Object.

   109       super_klass = KlassHandle(THREAD, SystemDictionary::Object_klass());

   110     }

   111   }

   113   // Create type name for klass.

   114   Symbol* name = NULL;

   115   if (!element_klass->oop_is_instance() ||

   116       (name = instanceKlass::cast(element_klass())->array_name()) == NULL) {

   118     ResourceMark rm(THREAD);

   119     char *name_str = element_klass->name()->as_C_string();

   120     int len = element_klass->name()->utf8_length();

   121     char *new_str = NEW_RESOURCE_ARRAY(char, len + 4);

   122     int idx = 0;

   123     new_str[idx++] = '[';

   124     if (element_klass->oop_is_instance()) { // it could be an array or simple type

   125       new_str[idx++] = 'L';

   126     }

   127     memcpy(&new_str[idx], name_str, len * sizeof(char));

   128     idx += len;

   129     if (element_klass->oop_is_instance()) {

   130       new_str[idx++] = ';';

   131     }

   132     new_str[idx++] = '\0';

   133     name = SymbolTable::new_symbol(new_str, CHECK_0);

   134     if (element_klass->oop_is_instance()) {

   135       instanceKlass* ik = instanceKlass::cast(element_klass());

   136       ik->set_array_name(name);

   137     }

   138   }

   140   objArrayKlass o;

   141   arrayKlassHandle k = arrayKlass::base_create_array_klass(o.vtbl_value(),

   142                                                            objArrayKlass::header_size(),

   143                                                           this_oop,

   144                                                            CHECK_0);

   146   // Initialize instance variables

   147   objArrayKlass* oak = objArrayKlass::cast(k());

   148   oak->set_dimension(n);

   149   oak->set_element_klass(element_klass());

   150   oak->set_name(name);

   151   // decrement refcount because object arrays are not explicitly freed.  The

   152   // instanceKlass array_name() keeps the name counted while the klass is

   153   // loaded.

   154   name->decrement_refcount();

   156   klassOop bk;

   157   if (element_klass->oop_is_objArray()) {

   158     bk = objArrayKlass::cast(element_klass())->bottom_klass();

   159   } else {

   160     bk = element_klass();

   161   }

   162   assert(bk != NULL && (Klass::cast(bk)->oop_is_instance() || Klass::cast(bk)->oop_is_typeArray()), "invalid bottom klass");

   163   oak->set_bottom_klass(bk);

   165   oak->set_layout_helper(array_layout_helper(T_OBJECT));

   166   assert(oak->oop_is_javaArray(), "sanity");

   167   assert(oak->oop_is_objArray(), "sanity");

   169   // Call complete_create_array_klass after all instance variables has been initialized.

   170   arrayKlass::complete_create_array_klass(k, super_klass, CHECK_0);

   172   return k();

   173 }

   176 void objArrayKlassKlass::oop_follow_contents(oop obj) {

   177   assert(obj->is_klass(), "must be klass");

   178   assert(klassOop(obj)->klass_part()->oop_is_objArray_slow(), "must be obj array");

   180   objArrayKlass* oak = objArrayKlass::cast((klassOop)obj);

   181   MarkSweep::mark_and_push(oak->element_klass_addr());

   182   MarkSweep::mark_and_push(oak->bottom_klass_addr());

   184   arrayKlassKlass::oop_follow_contents(obj);

   185 }

   187 #ifndef SERIALGC

   188 void objArrayKlassKlass::oop_follow_contents(ParCompactionManager* cm,

   189                                              oop obj) {

   190   assert(obj->is_klass(), "must be klass");

   191   assert(klassOop(obj)->klass_part()->oop_is_objArray_slow(), "must be obj array");

   193   objArrayKlass* oak = objArrayKlass::cast((klassOop)obj);

   194   PSParallelCompact::mark_and_push(cm, oak->element_klass_addr());

   195   PSParallelCompact::mark_and_push(cm, oak->bottom_klass_addr());

   197   arrayKlassKlass::oop_follow_contents(cm, obj);

   198 }

   199 #endif // SERIALGC

   202 int objArrayKlassKlass::oop_adjust_pointers(oop obj) {

   203   assert(obj->is_klass(), "must be klass");

   204   assert(klassOop(obj)->klass_part()->oop_is_objArray_slow(), "must be obj array");

   206   objArrayKlass* oak = objArrayKlass::cast((klassOop)obj);

   207   MarkSweep::adjust_pointer(oak->element_klass_addr());

   208   MarkSweep::adjust_pointer(oak->bottom_klass_addr());

   210   return arrayKlassKlass::oop_adjust_pointers(obj);

   211 }

   215 int objArrayKlassKlass::oop_oop_iterate(oop obj, OopClosure* blk) {

   216   assert(obj->is_klass(), "must be klass");

   217   assert(klassOop(obj)->klass_part()->oop_is_objArray_slow(), "must be obj array");

   219   objArrayKlass* oak = objArrayKlass::cast((klassOop)obj);

   220   blk->do_oop(oak->element_klass_addr());

   221   blk->do_oop(oak->bottom_klass_addr());

   223   return arrayKlassKlass::oop_oop_iterate(obj, blk);

   224 }

   227 int

   228 objArrayKlassKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) {

   229   assert(obj->is_klass(), "must be klass");

   230   assert(klassOop(obj)->klass_part()->oop_is_objArray_slow(), "must be obj array");

   232   objArrayKlass* oak = objArrayKlass::cast((klassOop)obj);

   233   oop* addr;

   234   addr = oak->element_klass_addr();

   235   if (mr.contains(addr)) blk->do_oop(addr);

   236   addr = oak->bottom_klass_addr();

   237   if (mr.contains(addr)) blk->do_oop(addr);

   239   return arrayKlassKlass::oop_oop_iterate(obj, blk);

   240 }

   242 #ifndef SERIALGC

   243 void objArrayKlassKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {

   244   assert(obj->blueprint()->oop_is_objArrayKlass(),"must be an obj array klass");

   245 }

   247 int objArrayKlassKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {

   248   assert(obj->is_klass(), "must be klass");

   249   assert(klassOop(obj)->klass_part()->oop_is_objArray_slow(), "must be obj array");

   251   objArrayKlass* oak = objArrayKlass::cast((klassOop)obj);

   252   PSParallelCompact::adjust_pointer(oak->element_klass_addr());

   253   PSParallelCompact::adjust_pointer(oak->bottom_klass_addr());

   255   return arrayKlassKlass::oop_update_pointers(cm, obj);

   256 }

   257 #endif // SERIALGC

   259 #ifndef PRODUCT

   261 // Printing

   263 void objArrayKlassKlass::oop_print_on(oop obj, outputStream* st) {

   264   assert(obj->is_klass(), "must be klass");

   265   objArrayKlass* oak = (objArrayKlass*) klassOop(obj)->klass_part();

   266   klassKlass::oop_print_on(obj, st);

   267   st->print(" - instance klass: ");

   268   oak->element_klass()->print_value_on(st);

   269   st->cr();

   270 }

   272 #endif //PRODUCT

   274 void objArrayKlassKlass::oop_print_value_on(oop obj, outputStream* st) {

   275   assert(obj->is_klass(), "must be klass");

   276   objArrayKlass* oak = (objArrayKlass*) klassOop(obj)->klass_part();

   278   oak->element_klass()->print_value_on(st);

   279   st->print("[]");

   280 }

   282 const char* objArrayKlassKlass::internal_name() const {

   283   return "{object array class}";

   284 }

   287 // Verification

   289 void objArrayKlassKlass::oop_verify_on(oop obj, outputStream* st) {

   290   klassKlass::oop_verify_on(obj, st);

   291   objArrayKlass* oak = objArrayKlass::cast((klassOop)obj);

   292   guarantee(oak->element_klass()->is_perm(),  "should be in permspace");

   293   guarantee(oak->element_klass()->is_klass(), "should be klass");

   294   guarantee(oak->bottom_klass()->is_perm(),   "should be in permspace");

   295   guarantee(oak->bottom_klass()->is_klass(),  "should be klass");

   296   Klass* bk = Klass::cast(oak->bottom_klass());

   297   guarantee(bk->oop_is_instance() || bk->oop_is_typeArray(),  "invalid bottom klass");

   298 }

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

src/share/vm/oops/objArrayKlassKlass.cpp@8033953d67ff

src/share/vm/oops/objArrayKlassKlass.cpp