1 /*
2 * Copyright (c) 2016, 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 "ci/ciInstanceKlass.hpp"
27 #include "ci/ciValueArrayKlass.hpp"
28 #include "ci/ciSymbol.hpp"
29 #include "ci/ciUtilities.hpp"
30 #include "oops/valueArrayKlass.hpp"
31
32 // ciValueArrayKlass
33 //
34 // This class represents a Klass* in the HotSpot virtual machine
35 // whose Klass part is a ValueArrayKlass.
36
37 // ------------------------------------------------------------------
38 // ciValueArrayKlass::ciValueArrayKlass
39 //
40 // Constructor for loaded value array klasses.
41 ciValueArrayKlass::ciValueArrayKlass(Klass* h_k) : ciArrayKlass(h_k) {
42 assert(get_Klass()->is_valueArray_klass(), "wrong type");
43 assert(get_ValueArrayKlass()->element_klass()->is_value(), "element must be value");
44 Klass* element_Klass = get_ValueArrayKlass()->element_klass();
45 _base_element_klass = CURRENT_ENV->get_klass(element_Klass);
46 assert(_base_element_klass->is_valuetype(), "bad base klass");
47 if (dimension() == 1) {
48 _element_klass = _base_element_klass;
49 } else {
50 _element_klass = NULL;
51 }
52 if (!ciObjectFactory::is_initialized()) {
53 assert(_element_klass->is_java_lang_Object(), "only arrays of object are shared");
54 }
55 }
56
57 // ------------------------------------------------------------------
58 // ciValueArrayKlass::element_klass
59 //
60 // What is the one-level element type of this array?
61 ciKlass* ciValueArrayKlass::element_klass() {
62 if (_element_klass == NULL) {
63 assert(dimension() > 1, "_element_klass should not be NULL");
64 // Produce the element klass.
65 if (is_loaded()) {
66 VM_ENTRY_MARK;
67 Klass* element_Klass = get_ValueArrayKlass()->element_klass();
68 _element_klass = CURRENT_THREAD_ENV->get_klass(element_Klass);
69 } else {
70 // TODO handle this
71 guarantee(false, "unloaded array klass");
72 VM_ENTRY_MARK;
73 // We are an unloaded array klass. Attempt to fetch our
74 // element klass by name.
75 _element_klass = CURRENT_THREAD_ENV->get_klass_by_name_impl(
76 this,
77 constantPoolHandle(),
78 construct_array_name(base_element_klass()->name(),
79 dimension() - 1),
80 false);
81 }
82 }
83 return _element_klass;
84 }
85
86 // ------------------------------------------------------------------
87 // ciValueArrayKlass::construct_array_name
88 //
89 // Build an array name from an element name and a dimension.
90 ciSymbol* ciValueArrayKlass::construct_array_name(ciSymbol* element_name,
91 int dimension) {
92 EXCEPTION_CONTEXT;
93 int element_len = element_name->utf8_length();
94
95 Symbol* base_name_sym = element_name->get_symbol();
96 char* name;
97
98 if (base_name_sym->byte_at(0) == '[' ||
99 (base_name_sym->byte_at(0) == 'L' && // watch package name 'Lxx'
100 base_name_sym->byte_at(element_len-1) == ';')) {
101
102 int new_len = element_len + dimension + 1; // for the ['s and '\0'
103 name = CURRENT_THREAD_ENV->name_buffer(new_len);
104
105 int pos = 0;
106 for ( ; pos < dimension; pos++) {
107 name[pos] = '[';
108 }
109 strncpy(name+pos, (char*)element_name->base(), element_len);
110 name[new_len-1] = '\0';
111 } else {
112 int new_len = 3 // for L, ;, and '\0'
113 + dimension // for ['s
114 + element_len;
115
116 name = CURRENT_THREAD_ENV->name_buffer(new_len);
117 int pos = 0;
118 for ( ; pos < dimension; pos++) {
119 name[pos] = '[';
120 }
121 name[pos++] = 'L';
122 strncpy(name+pos, (char*)element_name->base(), element_len);
123 name[new_len-2] = ';';
124 name[new_len-1] = '\0';
125 }
126 return ciSymbol::make(name);
127 }
128
129 // ------------------------------------------------------------------
130 // ciValueArrayKlass::make_impl
131 //
132 // Implementation of make.
133 ciValueArrayKlass* ciValueArrayKlass::make_impl(ciKlass* element_klass) {
134 assert(ValueArrayFlatten, "should only be used for flattened value type arrays");
135 assert(element_klass->is_valuetype(), "element type must be value type");
136 if (element_klass->is_loaded()) {
137 EXCEPTION_CONTEXT;
138 // The element klass is loaded
139 Klass* array = element_klass->get_Klass()->array_klass(THREAD);
140 if (HAS_PENDING_EXCEPTION) {
141 CLEAR_PENDING_EXCEPTION;
142 CURRENT_THREAD_ENV->record_out_of_memory_failure();
143 // TODO handle this
144 guarantee(false, "out of memory");
145 return NULL;
146 }
147 return CURRENT_THREAD_ENV->get_value_array_klass(array);
148 }
149
150 // TODO handle this
151 guarantee(false, "klass not loaded");
152 return NULL;
153 }
154
155 // ------------------------------------------------------------------
156 // ciValueArrayKlass::make
157 //
158 // Make an array klass corresponding to the specified primitive type.
159 ciValueArrayKlass* ciValueArrayKlass::make(ciKlass* element_klass) {
160 GUARDED_VM_ENTRY(return make_impl(element_klass);)
161 }
162
163 ciKlass* ciValueArrayKlass::exact_klass() {
164 ShouldNotCallThis();
165 return NULL;
166 }