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

6719955: Update copyright year
Summary: Update copyright year for files that have been modified in 2008
Reviewed-by: ohair, tbell

     1 /*

     2  * Copyright 1997-2007 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, TRAPS) {

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

    87   return ck->allocate(length, CHECK_NULL);

    88 }

    91 constantPoolCacheOop oopFactory::new_constantPoolCache(int length, TRAPS) {

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

    93   return ck->allocate(length, CHECK_NULL);

    94 }

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

    98                                        int nonstatic_oop_map_size, ReferenceType rt, TRAPS) {

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

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

   101 }

   104 constMethodOop oopFactory::new_constMethod(int byte_code_size,

   105                                            int compressed_line_number_size,

   106                                            int localvariable_table_length,

   107                                            int checked_exceptions_length,

   108                                            TRAPS) {

   109   klassOop cmkObj = Universe::constMethodKlassObj();

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

   111   return cmk->allocate(byte_code_size, compressed_line_number_size,

   112                        localvariable_table_length, checked_exceptions_length,

   113                        CHECK_NULL);

   114 }

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

   118                                  int compressed_line_number_size,

   119                                  int localvariable_table_length,

   120                                  int checked_exceptions_length, TRAPS) {

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

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

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

   124   constMethodOop cm = new_constMethod(byte_code_size,

   125                                       compressed_line_number_size,

   126                                       localvariable_table_length,

   127                                       checked_exceptions_length, CHECK_NULL);

   128   constMethodHandle rw(THREAD, cm);

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

   130 }

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

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

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

   136 }

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

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

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

   142   c->set_holder_method(method());

   143   c->set_holder_klass(klass());

   144   return c;

   145 }

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