jdk8-mips64-public/hotspot: src/share/vm/memory/oopFactory.cpp@0fbdb4381b99

6814575: Update copyright year
Summary: Update copyright for files that have been modified in 2009, up to 03/09
Reviewed-by: katleman, tbell, ohair

     1 /*

     2  * Copyright 1997-2009 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/_oopFactory.cpp.incl"

    29 typeArrayOop oopFactory::new_charArray(const char* utf8_str, TRAPS) {

    30   int length = utf8_str == NULL ? 0 : UTF8::unicode_length(utf8_str);

    31   typeArrayOop result = new_charArray(length, CHECK_NULL);

    32   if (length > 0) {

    33     UTF8::convert_to_unicode(utf8_str, result->char_at_addr(0), length);

    34   }

    35   return result;

    36 }

    38 typeArrayOop oopFactory::new_permanent_charArray(int length, TRAPS) {

    39   return typeArrayKlass::cast(Universe::charArrayKlassObj())->allocate_permanent(length, THREAD);

    40 }

    42 typeArrayOop oopFactory::new_permanent_byteArray(int length, TRAPS) {

    43   return typeArrayKlass::cast(Universe::byteArrayKlassObj())->allocate_permanent(length, THREAD);

    44 }

    47 typeArrayOop oopFactory::new_permanent_shortArray(int length, TRAPS) {

    48   return typeArrayKlass::cast(Universe::shortArrayKlassObj())->allocate_permanent(length, THREAD);

    49 }

    52 typeArrayOop oopFactory::new_permanent_intArray(int length, TRAPS) {

    53   return typeArrayKlass::cast(Universe::intArrayKlassObj())->allocate_permanent(length, THREAD);

    54 }

    57 typeArrayOop oopFactory::new_typeArray(BasicType type, int length, TRAPS) {

    58   klassOop type_asKlassOop = Universe::typeArrayKlassObj(type);

    59   typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop);

    60   typeArrayOop result = type_asArrayKlass->allocate(length, THREAD);

    61   return result;

    62 }

    65 objArrayOop oopFactory::new_objArray(klassOop klass, int length, TRAPS) {

    66   assert(klass->is_klass(), "must be instance class");

    67   if (klass->klass_part()->oop_is_array()) {

    68     return ((arrayKlass*)klass->klass_part())->allocate_arrayArray(1, length, THREAD);

    69   } else {

    70     assert (klass->klass_part()->oop_is_instance(), "new object array with klass not an instanceKlass");

    71     return ((instanceKlass*)klass->klass_part())->allocate_objArray(1, length, THREAD);

    72   }

    73 }

    75 objArrayOop oopFactory::new_system_objArray(int length, TRAPS) {

    76   int size = objArrayOopDesc::object_size(length);

    77   KlassHandle klass (THREAD, Universe::systemObjArrayKlassObj());

    78   objArrayOop o = (objArrayOop)

    79     Universe::heap()->permanent_array_allocate(klass, size, length, CHECK_NULL);

    80   // initialization not needed, allocated cleared

    81   return o;

    82 }

    85 constantPoolOop oopFactory::new_constantPool(int length,

    86                                              bool is_conc_safe,

    87                                              TRAPS) {

    88   constantPoolKlass* ck = constantPoolKlass::cast(Universe::constantPoolKlassObj());

    89   return ck->allocate(length, is_conc_safe, CHECK_NULL);

    90 }

    93 constantPoolCacheOop oopFactory::new_constantPoolCache(int length,

    94                                                        bool is_conc_safe,

    95                                                        TRAPS) {

    96   constantPoolCacheKlass* ck = constantPoolCacheKlass::cast(Universe::constantPoolCacheKlassObj());

    97   return ck->allocate(length, is_conc_safe, CHECK_NULL);

    98 }

   101 klassOop oopFactory::new_instanceKlass(int vtable_len, int itable_len, int static_field_size,

   102                                        int nonstatic_oop_map_size, ReferenceType rt, TRAPS) {

   103   instanceKlassKlass* ikk = instanceKlassKlass::cast(Universe::instanceKlassKlassObj());

   104   return ikk->allocate_instance_klass(vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, CHECK_NULL);

   105 }

   108 constMethodOop oopFactory::new_constMethod(int byte_code_size,

   109                                            int compressed_line_number_size,

   110                                            int localvariable_table_length,

   111                                            int checked_exceptions_length,

   112                                            bool is_conc_safe,

   113                                            TRAPS) {

   114   klassOop cmkObj = Universe::constMethodKlassObj();

   115   constMethodKlass* cmk = constMethodKlass::cast(cmkObj);

   116   return cmk->allocate(byte_code_size, compressed_line_number_size,

   117                        localvariable_table_length, checked_exceptions_length,

   118                        is_conc_safe,

   119                        CHECK_NULL);

   120 }

   123 methodOop oopFactory::new_method(int byte_code_size, AccessFlags access_flags,

   124                                  int compressed_line_number_size,

   125                                  int localvariable_table_length,

   126                                  int checked_exceptions_length,

   127                                  bool is_conc_safe,

   128                                  TRAPS) {

   129   methodKlass* mk = methodKlass::cast(Universe::methodKlassObj());

   130   assert(!access_flags.is_native() || byte_code_size == 0,

   131          "native methods should not contain byte codes");

   132   constMethodOop cm = new_constMethod(byte_code_size,

   133                                       compressed_line_number_size,

   134                                       localvariable_table_length,

   135                                       checked_exceptions_length,

   136                                       is_conc_safe, CHECK_NULL);

   137   constMethodHandle rw(THREAD, cm);

   138   return mk->allocate(rw, access_flags, CHECK_NULL);

   139 }

   142 methodDataOop oopFactory::new_methodData(methodHandle method, TRAPS) {

   143   methodDataKlass* mdk = methodDataKlass::cast(Universe::methodDataKlassObj());

   144   return mdk->allocate(method, CHECK_NULL);

   145 }

   148 compiledICHolderOop oopFactory::new_compiledICHolder(methodHandle method, KlassHandle klass, TRAPS) {

   149   compiledICHolderKlass* ck = (compiledICHolderKlass*) Universe::compiledICHolderKlassObj()->klass_part();

   150   compiledICHolderOop c = ck->allocate(CHECK_NULL);

   151   c->set_holder_method(method());

   152   c->set_holder_klass(klass());

   153   return c;

   154 }

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