53 UTF8::convert_to_unicode(utf8_str, result->char_at_addr(0), length); |
44 UTF8::convert_to_unicode(utf8_str, result->char_at_addr(0), length); |
54 } |
45 } |
55 return result; |
46 return result; |
56 } |
47 } |
57 |
48 |
58 typeArrayOop oopFactory::new_permanent_charArray(int length, TRAPS) { |
49 typeArrayOop oopFactory::new_tenured_charArray(int length, TRAPS) { |
59 return typeArrayKlass::cast(Universe::charArrayKlassObj())->allocate_permanent(length, THREAD); |
50 return typeArrayKlass::cast(Universe::charArrayKlassObj())->allocate(length, THREAD); |
60 } |
51 } |
61 |
52 |
62 typeArrayOop oopFactory::new_permanent_byteArray(int length, TRAPS) { |
53 typeArrayOop oopFactory::new_typeArray(BasicType type, int length, TRAPS) { |
63 return typeArrayKlass::cast(Universe::byteArrayKlassObj())->allocate_permanent(length, THREAD); |
54 Klass* type_asKlassOop = Universe::typeArrayKlassObj(type); |
|
55 typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop); |
|
56 typeArrayOop result = type_asArrayKlass->allocate(length, THREAD); |
|
57 return result; |
64 } |
58 } |
65 |
59 |
66 |
60 // Create a Java array that points to metadata. |
67 typeArrayOop oopFactory::new_permanent_shortArray(int length, TRAPS) { |
61 // As far as Java code is concerned, a metaData array is either an array of |
68 return typeArrayKlass::cast(Universe::shortArrayKlassObj())->allocate_permanent(length, THREAD); |
62 // int or long depending on pointer size. Only a few things use this, like |
69 } |
63 // stack trace elements in Throwable. They cast Method* into this type. |
70 |
64 // Note:can't point to symbols because there's no way to unreference count |
71 |
65 // them when this object goes away. |
72 typeArrayOop oopFactory::new_permanent_intArray(int length, TRAPS) { |
66 typeArrayOop oopFactory::new_metaDataArray(int length, TRAPS) { |
73 return typeArrayKlass::cast(Universe::intArrayKlassObj())->allocate_permanent(length, THREAD); |
67 BasicType type = LP64_ONLY(T_LONG) NOT_LP64(T_INT); |
74 } |
68 Klass* type_asKlassOop = Universe::typeArrayKlassObj(type); |
75 |
|
76 |
|
77 typeArrayOop oopFactory::new_typeArray(BasicType type, int length, TRAPS) { |
|
78 klassOop type_asKlassOop = Universe::typeArrayKlassObj(type); |
|
79 typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop); |
69 typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop); |
80 typeArrayOop result = type_asArrayKlass->allocate_common(length, true, THREAD); |
70 typeArrayOop result = type_asArrayKlass->allocate_common(length, true, THREAD); |
81 return result; |
71 return result; |
82 } |
72 } |
83 |
73 |
84 typeArrayOop oopFactory::new_typeArray_nozero(BasicType type, int length, TRAPS) { |
74 typeArrayOop oopFactory::new_typeArray_nozero(BasicType type, int length, TRAPS) { |
85 klassOop type_asKlassOop = Universe::typeArrayKlassObj(type); |
75 Klass* type_asKlassOop = Universe::typeArrayKlassObj(type); |
86 typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop); |
76 typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop); |
87 typeArrayOop result = type_asArrayKlass->allocate_common(length, false, THREAD); |
77 typeArrayOop result = type_asArrayKlass->allocate_common(length, false, THREAD); |
88 return result; |
78 return result; |
89 } |
79 } |
90 |
80 |
91 |
81 |
92 objArrayOop oopFactory::new_objArray(klassOop klass, int length, TRAPS) { |
82 objArrayOop oopFactory::new_objArray(Klass* klass, int length, TRAPS) { |
93 assert(klass->is_klass(), "must be instance class"); |
83 assert(klass->is_klass(), "must be instance class"); |
94 if (klass->klass_part()->oop_is_array()) { |
84 if (klass->oop_is_array()) { |
95 return ((arrayKlass*)klass->klass_part())->allocate_arrayArray(1, length, THREAD); |
85 return ((arrayKlass*)klass)->allocate_arrayArray(1, length, THREAD); |
96 } else { |
86 } else { |
97 assert (klass->klass_part()->oop_is_instance(), "new object array with klass not an instanceKlass"); |
87 assert (klass->oop_is_instance(), "new object array with klass not an InstanceKlass"); |
98 return ((instanceKlass*)klass->klass_part())->allocate_objArray(1, length, THREAD); |
88 return ((InstanceKlass*)klass)->allocate_objArray(1, length, THREAD); |
99 } |
89 } |
100 } |
90 } |
101 |
|
102 objArrayOop oopFactory::new_system_objArray(int length, TRAPS) { |
|
103 int size = objArrayOopDesc::object_size(length); |
|
104 KlassHandle klass (THREAD, Universe::systemObjArrayKlassObj()); |
|
105 objArrayOop o = (objArrayOop) |
|
106 Universe::heap()->permanent_array_allocate(klass, size, length, CHECK_NULL); |
|
107 // initialization not needed, allocated cleared |
|
108 return o; |
|
109 } |
|
110 |
|
111 |
|
112 constantPoolOop oopFactory::new_constantPool(int length, |
|
113 bool is_conc_safe, |
|
114 TRAPS) { |
|
115 constantPoolKlass* ck = constantPoolKlass::cast(Universe::constantPoolKlassObj()); |
|
116 return ck->allocate(length, is_conc_safe, CHECK_NULL); |
|
117 } |
|
118 |
|
119 |
|
120 constantPoolCacheOop oopFactory::new_constantPoolCache(int length, |
|
121 TRAPS) { |
|
122 constantPoolCacheKlass* ck = constantPoolCacheKlass::cast(Universe::constantPoolCacheKlassObj()); |
|
123 return ck->allocate(length, CHECK_NULL); |
|
124 } |
|
125 |
|
126 |
|
127 klassOop oopFactory::new_instanceKlass(Symbol* name, int vtable_len, int itable_len, |
|
128 int static_field_size, |
|
129 unsigned int nonstatic_oop_map_count, |
|
130 AccessFlags access_flags, |
|
131 ReferenceType rt, |
|
132 KlassHandle host_klass, TRAPS) { |
|
133 instanceKlassKlass* ikk = instanceKlassKlass::cast(Universe::instanceKlassKlassObj()); |
|
134 return ikk->allocate_instance_klass(name, vtable_len, itable_len, |
|
135 static_field_size, nonstatic_oop_map_count, |
|
136 access_flags, rt, host_klass, CHECK_NULL); |
|
137 } |
|
138 |
|
139 |
|
140 constMethodOop oopFactory::new_constMethod(int byte_code_size, |
|
141 int compressed_line_number_size, |
|
142 int localvariable_table_length, |
|
143 int exception_table_length, |
|
144 int checked_exceptions_length, |
|
145 bool is_conc_safe, |
|
146 TRAPS) { |
|
147 klassOop cmkObj = Universe::constMethodKlassObj(); |
|
148 constMethodKlass* cmk = constMethodKlass::cast(cmkObj); |
|
149 return cmk->allocate(byte_code_size, compressed_line_number_size, |
|
150 localvariable_table_length, exception_table_length, |
|
151 checked_exceptions_length, is_conc_safe, |
|
152 CHECK_NULL); |
|
153 } |
|
154 |
|
155 |
|
156 methodOop oopFactory::new_method(int byte_code_size, AccessFlags access_flags, |
|
157 int compressed_line_number_size, |
|
158 int localvariable_table_length, |
|
159 int exception_table_length, |
|
160 int checked_exceptions_length, |
|
161 bool is_conc_safe, |
|
162 TRAPS) { |
|
163 methodKlass* mk = methodKlass::cast(Universe::methodKlassObj()); |
|
164 assert(!access_flags.is_native() || byte_code_size == 0, |
|
165 "native methods should not contain byte codes"); |
|
166 constMethodOop cm = new_constMethod(byte_code_size, |
|
167 compressed_line_number_size, |
|
168 localvariable_table_length, |
|
169 exception_table_length, |
|
170 checked_exceptions_length, |
|
171 is_conc_safe, CHECK_NULL); |
|
172 constMethodHandle rw(THREAD, cm); |
|
173 return mk->allocate(rw, access_flags, CHECK_NULL); |
|
174 } |
|
175 |
|
176 |
|
177 methodDataOop oopFactory::new_methodData(methodHandle method, TRAPS) { |
|
178 methodDataKlass* mdk = methodDataKlass::cast(Universe::methodDataKlassObj()); |
|
179 return mdk->allocate(method, CHECK_NULL); |
|
180 } |
|
181 |
|
182 |
|
183 compiledICHolderOop oopFactory::new_compiledICHolder(methodHandle method, KlassHandle klass, TRAPS) { |
|
184 compiledICHolderKlass* ck = (compiledICHolderKlass*) Universe::compiledICHolderKlassObj()->klass_part(); |
|
185 compiledICHolderOop c = ck->allocate(CHECK_NULL); |
|
186 c->set_holder_method(method()); |
|
187 c->set_holder_klass(klass()); |
|
188 return c; |
|
189 } |
|