jdk8-mips64-public/hotspot: src/share/vm/oops/cpCacheKlass.cpp@75b0f3cb1943

     1 /*

     2  * Copyright 1998-2006 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    25 #include "incls/_precompiled.incl"

    26 #include "incls/_cpCacheKlass.cpp.incl"

    29 int constantPoolCacheKlass::oop_size(oop obj) const {

    30   assert(obj->is_constantPoolCache(), "must be constantPool");

    31   return constantPoolCacheOop(obj)->object_size();

    32 }

    35 constantPoolCacheOop constantPoolCacheKlass::allocate(int length, TRAPS) {

    36   // allocate memory

    37   int size = constantPoolCacheOopDesc::object_size(length);

    38   KlassHandle klass (THREAD, as_klassOop());

    39   constantPoolCacheOop cache = (constantPoolCacheOop)

    40     CollectedHeap::permanent_array_allocate(klass, size, length, CHECK_NULL);

    41   cache->set_constant_pool(NULL);

    42   return cache;

    43 }

    46 klassOop constantPoolCacheKlass::create_klass(TRAPS) {

    47   constantPoolCacheKlass o;

    48   KlassHandle klassklass(THREAD, Universe::arrayKlassKlassObj());

    49   arrayKlassHandle k = base_create_array_klass(o.vtbl_value(), header_size(), klassklass, CHECK_NULL);

    50   KlassHandle super (THREAD, k->super());

    51   complete_create_array_klass(k, super, CHECK_NULL);

    52   return k();

    53 }

    56 void constantPoolCacheKlass::oop_follow_contents(oop obj) {

    57   assert(obj->is_constantPoolCache(), "obj must be constant pool cache");

    58   constantPoolCacheOop cache = (constantPoolCacheOop)obj;

    59   // Performance tweak: We skip iterating over the klass pointer since we

    60   // know that Universe::constantPoolCacheKlassObj never moves.

    61   // gc of constant pool cache instance variables

    62   MarkSweep::mark_and_push((oop*)cache->constant_pool_addr());

    63   // gc of constant pool cache entries

    64   int i = cache->length();

    65   while (i-- > 0) cache->entry_at(i)->follow_contents();

    66 }

    68 #ifndef SERIALGC

    69 void constantPoolCacheKlass::oop_follow_contents(ParCompactionManager* cm,

    70                                                  oop obj) {

    71   assert(obj->is_constantPoolCache(), "obj must be constant pool cache");

    72   constantPoolCacheOop cache = (constantPoolCacheOop)obj;

    73   // Performance tweak: We skip iterating over the klass pointer since we

    74   // know that Universe::constantPoolCacheKlassObj never moves.

    75   // gc of constant pool cache instance variables

    76   PSParallelCompact::mark_and_push(cm, (oop*)cache->constant_pool_addr());

    77   // gc of constant pool cache entries

    78   int i = cache->length();

    79   while (i-- > 0) cache->entry_at(i)->follow_contents(cm);

    80 }

    81 #endif // SERIALGC

    84 int constantPoolCacheKlass::oop_oop_iterate(oop obj, OopClosure* blk) {

    85   assert(obj->is_constantPoolCache(), "obj must be constant pool cache");

    86   constantPoolCacheOop cache = (constantPoolCacheOop)obj;

    87   // Get size before changing pointers.

    88   // Don't call size() or oop_size() since that is a virtual call.

    89   int size = cache->object_size();

    90   // Performance tweak: We skip iterating over the klass pointer since we

    91   // know that Universe::constantPoolCacheKlassObj never moves.

    92   // iteration over constant pool cache instance variables

    93   blk->do_oop((oop*)cache->constant_pool_addr());

    94   // iteration over constant pool cache entries

    95   for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->oop_iterate(blk);

    96   return size;

    97 }

   100 int constantPoolCacheKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) {

   101   assert(obj->is_constantPoolCache(), "obj must be constant pool cache");

   102   constantPoolCacheOop cache = (constantPoolCacheOop)obj;

   103   // Get size before changing pointers.

   104   // Don't call size() or oop_size() since that is a virtual call.

   105   int size = cache->object_size();

   106   // Performance tweak: We skip iterating over the klass pointer since we

   107   // know that Universe::constantPoolCacheKlassObj never moves.

   108   // iteration over constant pool cache instance variables

   109   oop* addr = (oop*)cache->constant_pool_addr();

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

   111   // iteration over constant pool cache entries

   112   for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->oop_iterate_m(blk, mr);

   113   return size;

   114 }

   117 int constantPoolCacheKlass::oop_adjust_pointers(oop obj) {

   118   assert(obj->is_constantPoolCache(), "obj must be constant pool cache");

   119   constantPoolCacheOop cache = (constantPoolCacheOop)obj;

   120   // Get size before changing pointers.

   121   // Don't call size() or oop_size() since that is a virtual call.

   122   int size = cache->object_size();

   123   // Performance tweak: We skip iterating over the klass pointer since we

   124   // know that Universe::constantPoolCacheKlassObj never moves.

   125   // Iteration over constant pool cache instance variables

   126   MarkSweep::adjust_pointer((oop*)cache->constant_pool_addr());

   127   // iteration over constant pool cache entries

   128   for (int i = 0; i < cache->length(); i++)

   129     cache->entry_at(i)->adjust_pointers();

   130   return size;

   131 }

   133 #ifndef SERIALGC

   134 void constantPoolCacheKlass::oop_copy_contents(PSPromotionManager* pm,

   135                                                oop obj) {

   136   assert(obj->is_constantPoolCache(), "should be constant pool");

   137 }

   139 void constantPoolCacheKlass::oop_push_contents(PSPromotionManager* pm,

   140                                                oop obj) {

   141   assert(obj->is_constantPoolCache(), "should be constant pool");

   142 }

   144 int

   145 constantPoolCacheKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {

   146   assert(obj->is_constantPoolCache(), "obj must be constant pool cache");

   147   constantPoolCacheOop cache = (constantPoolCacheOop)obj;

   149   // Iteration over constant pool cache instance variables

   150   PSParallelCompact::adjust_pointer((oop*)cache->constant_pool_addr());

   152   // iteration over constant pool cache entries

   153   for (int i = 0; i < cache->length(); ++i) {

   154     cache->entry_at(i)->update_pointers();

   155   }

   157   return cache->object_size();

   158 }

   160 int

   161 constantPoolCacheKlass::oop_update_pointers(ParCompactionManager* cm, oop obj,

   162                                             HeapWord* beg_addr,

   163                                             HeapWord* end_addr) {

   164   assert(obj->is_constantPoolCache(), "obj must be constant pool cache");

   165   constantPoolCacheOop cache = (constantPoolCacheOop)obj;

   167   // Iteration over constant pool cache instance variables

   168   oop* p;

   169   p = (oop*)cache->constant_pool_addr();

   170   PSParallelCompact::adjust_pointer(p, beg_addr, end_addr);

   172   // Iteration over constant pool cache entries

   173   for (int i = 0; i < cache->length(); ++i) {

   174     cache->entry_at(i)->update_pointers(beg_addr, end_addr);

   175   }

   176   return cache->object_size();

   177 }

   178 #endif // SERIALGC

   180 #ifndef PRODUCT

   182 void constantPoolCacheKlass::oop_print_on(oop obj, outputStream* st) {

   183   assert(obj->is_constantPoolCache(), "obj must be constant pool cache");

   184   constantPoolCacheOop cache = (constantPoolCacheOop)obj;

   185   // super print

   186   arrayKlass::oop_print_on(obj, st);

   187   // print constant pool cache entries

   188   for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->print(st, i);

   189 }

   191 #endif

   193 void constantPoolCacheKlass::oop_verify_on(oop obj, outputStream* st) {

   194   guarantee(obj->is_constantPoolCache(), "obj must be constant pool cache");

   195   constantPoolCacheOop cache = (constantPoolCacheOop)obj;

   196   // super verify

   197   arrayKlass::oop_verify_on(obj, st);

   198   // print constant pool cache entries

   199   for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->verify(st);

   200 }

   203 const char* constantPoolCacheKlass::internal_name() const {

   204   return "{constant pool cache}";

   205 }

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

src/share/vm/oops/cpCacheKlass.cpp@75b0f3cb1943

src/share/vm/oops/cpCacheKlass.cpp