1 | /* |
2 | * Copyright (c) 1997, 2019, 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 | */ |
24 | |
25 | #include "precompiled.hpp" |
26 | #include "classfile/javaClasses.hpp" |
27 | #include "classfile/symbolTable.hpp" |
28 | #include "classfile/systemDictionary.hpp" |
29 | #include "classfile/vmSymbols.hpp" |
30 | #include "gc/shared/collectedHeap.inline.hpp" |
31 | #include "memory/oopFactory.hpp" |
32 | #include "memory/resourceArea.hpp" |
33 | #include "memory/universe.hpp" |
34 | #include "oops/instanceKlass.hpp" |
35 | #include "oops/instanceOop.hpp" |
36 | #include "oops/objArrayKlass.hpp" |
37 | #include "oops/objArrayOop.hpp" |
38 | #include "oops/oop.inline.hpp" |
39 | #include "oops/typeArrayKlass.hpp" |
40 | #include "oops/typeArrayOop.inline.hpp" |
41 | #include "runtime/handles.inline.hpp" |
42 | #include "utilities/utf8.hpp" |
43 | |
44 | typeArrayOop oopFactory::new_boolArray(int length, TRAPS) { |
45 | return TypeArrayKlass::cast(Universe::boolArrayKlassObj())->allocate(length, THREAD); |
46 | } |
47 | |
48 | typeArrayOop oopFactory::new_charArray(int length, TRAPS) { |
49 | return TypeArrayKlass::cast(Universe::charArrayKlassObj())->allocate(length, THREAD); |
50 | } |
51 | |
52 | typeArrayOop oopFactory::new_floatArray(int length, TRAPS) { |
53 | return TypeArrayKlass::cast(Universe::floatArrayKlassObj())->allocate(length, THREAD); |
54 | } |
55 | |
56 | typeArrayOop oopFactory::new_doubleArray(int length, TRAPS) { |
57 | return TypeArrayKlass::cast(Universe::doubleArrayKlassObj())->allocate(length, THREAD); |
58 | } |
59 | |
60 | typeArrayOop oopFactory::new_byteArray(int length, TRAPS) { |
61 | return TypeArrayKlass::cast(Universe::byteArrayKlassObj())->allocate(length, THREAD); |
62 | } |
63 | |
64 | typeArrayOop oopFactory::new_shortArray(int length, TRAPS) { |
65 | return TypeArrayKlass::cast(Universe::shortArrayKlassObj())->allocate(length, THREAD); |
66 | } |
67 | |
68 | typeArrayOop oopFactory::new_intArray(int length, TRAPS) { |
69 | return TypeArrayKlass::cast(Universe::intArrayKlassObj())->allocate(length, THREAD); |
70 | } |
71 | |
72 | typeArrayOop oopFactory::new_longArray(int length, TRAPS) { |
73 | return TypeArrayKlass::cast(Universe::longArrayKlassObj())->allocate(length, THREAD); |
74 | } |
75 | |
76 | // create java.lang.Object[] |
77 | objArrayOop oopFactory::new_objectArray(int length, TRAPS) { |
78 | assert(Universe::objectArrayKlassObj() != NULL, "Too early?" ); |
79 | return ObjArrayKlass::cast(Universe::objectArrayKlassObj())->allocate(length, THREAD); |
80 | } |
81 | |
82 | typeArrayOop oopFactory::new_charArray(const char* utf8_str, TRAPS) { |
83 | int length = utf8_str == NULL ? 0 : UTF8::unicode_length(utf8_str); |
84 | typeArrayOop result = new_charArray(length, CHECK_NULL); |
85 | if (length > 0) { |
86 | UTF8::convert_to_unicode(utf8_str, result->char_at_addr(0), length); |
87 | } |
88 | return result; |
89 | } |
90 | |
91 | typeArrayOop oopFactory::new_tenured_charArray(int length, TRAPS) { |
92 | return TypeArrayKlass::cast(Universe::charArrayKlassObj())->allocate(length, THREAD); |
93 | } |
94 | |
95 | typeArrayOop oopFactory::new_typeArray(BasicType type, int length, TRAPS) { |
96 | Klass* type_asKlassOop = Universe::typeArrayKlassObj(type); |
97 | TypeArrayKlass* type_asArrayKlass = TypeArrayKlass::cast(type_asKlassOop); |
98 | typeArrayOop result = type_asArrayKlass->allocate(length, THREAD); |
99 | return result; |
100 | } |
101 | |
102 | // Create a Java array that points to Symbol. |
103 | // As far as Java code is concerned, a Symbol array is either an array of |
104 | // int or long depending on pointer size. Only stack trace elements in Throwable use |
105 | // this. They cast Symbol* into this type. |
106 | typeArrayOop oopFactory::new_symbolArray(int length, TRAPS) { |
107 | BasicType type = LP64_ONLY(T_LONG) NOT_LP64(T_INT); |
108 | Klass* type_asKlassOop = Universe::typeArrayKlassObj(type); |
109 | TypeArrayKlass* type_asArrayKlass = TypeArrayKlass::cast(type_asKlassOop); |
110 | typeArrayOop result = type_asArrayKlass->allocate(length, THREAD); |
111 | return result; |
112 | } |
113 | |
114 | typeArrayOop oopFactory::new_typeArray_nozero(BasicType type, int length, TRAPS) { |
115 | Klass* type_asKlassOop = Universe::typeArrayKlassObj(type); |
116 | TypeArrayKlass* type_asArrayKlass = TypeArrayKlass::cast(type_asKlassOop); |
117 | typeArrayOop result = type_asArrayKlass->allocate_common(length, false, THREAD); |
118 | return result; |
119 | } |
120 | |
121 | |
122 | objArrayOop oopFactory::new_objArray(Klass* klass, int length, TRAPS) { |
123 | assert(klass->is_klass(), "must be instance class" ); |
124 | if (klass->is_array_klass()) { |
125 | return ArrayKlass::cast(klass)->allocate_arrayArray(1, length, THREAD); |
126 | } else { |
127 | return InstanceKlass::cast(klass)->allocate_objArray(1, length, THREAD); |
128 | } |
129 | } |
130 | |
131 | objArrayHandle oopFactory::new_objArray_handle(Klass* klass, int length, TRAPS) { |
132 | objArrayOop obj = new_objArray(klass, length, CHECK_(objArrayHandle())); |
133 | return objArrayHandle(THREAD, obj); |
134 | } |
135 | |
136 | typeArrayHandle oopFactory::new_byteArray_handle(int length, TRAPS) { |
137 | typeArrayOop obj = new_byteArray(length, CHECK_(typeArrayHandle())); |
138 | return typeArrayHandle(THREAD, obj); |
139 | } |
140 | |