1 /*
2 * Copyright (c) 1999, 2012, 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 *
58
59 // It is not a vicious circularity for a ciField to recursively create
60 // the ciSymbols necessary to represent its name and signature.
61 // Therefore, these items are created eagerly, and the name and signature
62 // of a shared field are themselves shared symbols. This somewhat
63 // pollutes the set of shared CI objects: It grows from 50 to 93 items,
64 // with all of the additional 43 being uninteresting shared ciSymbols.
65 // This adds at most one step to the binary search, an amount which
66 // decreases for complex compilation tasks.
67
68 // ------------------------------------------------------------------
69 // ciField::ciField
70 ciField::ciField(ciInstanceKlass* klass, int index): _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) {
71 ASSERT_IN_VM;
72 CompilerThread *thread = CompilerThread::current();
73
74 assert(ciObjectFactory::is_initialized(), "not a shared field");
75
76 assert(klass->get_instanceKlass()->is_linked(), "must be linked before using its constan-pool");
77
78 _cp_index = index;
79 constantPoolHandle cpool(thread, klass->get_instanceKlass()->constants());
80
81 // Get the field's name, signature, and type.
82 Symbol* name = cpool->name_ref_at(index);
83 _name = ciEnv::current(thread)->get_symbol(name);
84
85 int nt_index = cpool->name_and_type_ref_index_at(index);
86 int sig_index = cpool->signature_ref_index_at(nt_index);
87 Symbol* signature = cpool->symbol_at(sig_index);
88 _signature = ciEnv::current(thread)->get_symbol(signature);
89
90 BasicType field_type = FieldType::basic_type(signature);
91
92 // If the field is a pointer type, get the klass of the
93 // field.
94 if (field_type == T_OBJECT || field_type == T_ARRAY) {
95 bool ignore;
96 // This is not really a class reference; the index always refers to the
97 // field's type signature, as a symbol. Linkage checks do not apply.
98 _type = ciEnv::current(thread)->get_klass_by_index(cpool, sig_index, ignore, klass);
99 } else {
100 _type = ciType::make(field_type);
101 }
102
103 _name = (ciSymbol*)ciEnv::current(thread)->get_symbol(name);
104
105 // Get the field's declared holder.
106 //
107 // Note: we actually create a ciInstanceKlass for this klass,
108 // even though we may not need to.
109 int holder_index = cpool->klass_ref_index_at(index);
110 bool holder_is_accessible;
111 ciInstanceKlass* declared_holder =
112 ciEnv::current(thread)->get_klass_by_index(cpool, holder_index,
113 holder_is_accessible,
114 klass)->as_instance_klass();
115
116 // The declared holder of this field may not have been loaded.
117 // Bail out with partial field information.
118 if (!holder_is_accessible) {
119 // _cp_index and _type have already been set.
120 // The default values for _flags and _constant_value will suffice.
121 // We need values for _holder, _offset, and _is_constant,
122 _holder = declared_holder;
123 _offset = -1;
124 _is_constant = false;
125 return;
126 }
127
128 InstanceKlass* loaded_decl_holder = declared_holder->get_instanceKlass();
129
130 // Perform the field lookup.
131 fieldDescriptor field_desc;
132 Klass* canonical_holder =
133 loaded_decl_holder->find_field(name, signature, &field_desc);
134 if (canonical_holder == NULL) {
135 // Field lookup failed. Will be detected by will_link.
136 _holder = declared_holder;
137 _offset = -1;
138 _is_constant = false;
139 return;
140 }
141
142 assert(canonical_holder == field_desc.field_holder(), "just checking");
143 initialize_from(&field_desc);
144 }
145
146 ciField::ciField(fieldDescriptor *fd): _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) {
147 ASSERT_IN_VM;
148
149 _cp_index = -1;
150
151 // Get the field's name, signature, and type.
152 ciEnv* env = CURRENT_ENV;
153 _name = env->get_symbol(fd->name());
154 _signature = env->get_symbol(fd->signature());
155
156 BasicType field_type = fd->field_type();
157
158 // If the field is a pointer type, get the klass of the
159 // field.
160 if (field_type == T_OBJECT || field_type == T_ARRAY) {
161 _type = NULL; // must call compute_type on first access
162 } else {
163 _type = ciType::make(field_type);
164 }
165
166 initialize_from(fd);
167
168 // Either (a) it is marked shared, or else (b) we are done bootstrapping.
169 assert(is_shared() || ciObjectFactory::is_initialized(),
170 "bootstrap classes must not create & cache unshared fields");
327 }
328
329 // Check for static/nonstatic mismatch
330 bool is_static = (bc == Bytecodes::_getstatic || bc == Bytecodes::_putstatic);
331 if (is_static != this->is_static()) {
332 return false;
333 }
334
335 // Get and put can have different accessibility rules
336 bool is_put = (bc == Bytecodes::_putfield || bc == Bytecodes::_putstatic);
337 if (is_put) {
338 if (_known_to_link_with_put == accessing_klass) {
339 return true;
340 }
341 } else {
342 if (_known_to_link_with_get == accessing_klass) {
343 return true;
344 }
345 }
346
347 FieldAccessInfo result;
348 constantPoolHandle c_pool(THREAD,
349 accessing_klass->get_instanceKlass()->constants());
350 LinkResolver::resolve_field(result, c_pool, _cp_index,
351 Bytecodes::java_code(bc),
352 true, false, KILL_COMPILE_ON_FATAL_(false));
353
354 // update the hit-cache, unless there is a problem with memory scoping:
355 if (accessing_klass->is_shared() || !is_shared()) {
356 if (is_put) {
357 _known_to_link_with_put = accessing_klass;
358 } else {
359 _known_to_link_with_get = accessing_klass;
360 }
361 }
362
363 return true;
364 }
365
366 // ------------------------------------------------------------------
367 // ciField::print
368 void ciField::print() {
369 tty->print("<ciField name=");
370 _holder->print_name();
371 tty->print(".");
372 _name->print_symbol();
|
1 /*
2 * Copyright (c) 1999, 2013, 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 *
58
59 // It is not a vicious circularity for a ciField to recursively create
60 // the ciSymbols necessary to represent its name and signature.
61 // Therefore, these items are created eagerly, and the name and signature
62 // of a shared field are themselves shared symbols. This somewhat
63 // pollutes the set of shared CI objects: It grows from 50 to 93 items,
64 // with all of the additional 43 being uninteresting shared ciSymbols.
65 // This adds at most one step to the binary search, an amount which
66 // decreases for complex compilation tasks.
67
68 // ------------------------------------------------------------------
69 // ciField::ciField
70 ciField::ciField(ciInstanceKlass* klass, int index): _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) {
71 ASSERT_IN_VM;
72 CompilerThread *thread = CompilerThread::current();
73
74 assert(ciObjectFactory::is_initialized(), "not a shared field");
75
76 assert(klass->get_instanceKlass()->is_linked(), "must be linked before using its constan-pool");
77
78 constantPoolHandle cpool(thread, klass->get_instanceKlass()->constants());
79
80 // Get the field's name, signature, and type.
81 Symbol* name = cpool->name_ref_at(index);
82 _name = ciEnv::current(thread)->get_symbol(name);
83
84 int nt_index = cpool->name_and_type_ref_index_at(index);
85 int sig_index = cpool->signature_ref_index_at(nt_index);
86 Symbol* signature = cpool->symbol_at(sig_index);
87 _signature = ciEnv::current(thread)->get_symbol(signature);
88
89 BasicType field_type = FieldType::basic_type(signature);
90
91 // If the field is a pointer type, get the klass of the
92 // field.
93 if (field_type == T_OBJECT || field_type == T_ARRAY) {
94 bool ignore;
95 // This is not really a class reference; the index always refers to the
96 // field's type signature, as a symbol. Linkage checks do not apply.
97 _type = ciEnv::current(thread)->get_klass_by_index(cpool, sig_index, ignore, klass);
98 } else {
99 _type = ciType::make(field_type);
100 }
101
102 _name = (ciSymbol*)ciEnv::current(thread)->get_symbol(name);
103
104 // Get the field's declared holder.
105 //
106 // Note: we actually create a ciInstanceKlass for this klass,
107 // even though we may not need to.
108 int holder_index = cpool->klass_ref_index_at(index);
109 bool holder_is_accessible;
110 ciInstanceKlass* declared_holder =
111 ciEnv::current(thread)->get_klass_by_index(cpool, holder_index,
112 holder_is_accessible,
113 klass)->as_instance_klass();
114
115 // The declared holder of this field may not have been loaded.
116 // Bail out with partial field information.
117 if (!holder_is_accessible) {
118 // _type has already been set.
119 // The default values for _flags and _constant_value will suffice.
120 // We need values for _holder, _offset, and _is_constant,
121 _holder = declared_holder;
122 _offset = -1;
123 _is_constant = false;
124 return;
125 }
126
127 InstanceKlass* loaded_decl_holder = declared_holder->get_instanceKlass();
128
129 // Perform the field lookup.
130 fieldDescriptor field_desc;
131 Klass* canonical_holder =
132 loaded_decl_holder->find_field(name, signature, &field_desc);
133 if (canonical_holder == NULL) {
134 // Field lookup failed. Will be detected by will_link.
135 _holder = declared_holder;
136 _offset = -1;
137 _is_constant = false;
138 return;
139 }
140
141 assert(canonical_holder == field_desc.field_holder(), "just checking");
142 initialize_from(&field_desc);
143 }
144
145 ciField::ciField(fieldDescriptor *fd): _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) {
146 ASSERT_IN_VM;
147
148 // Get the field's name, signature, and type.
149 ciEnv* env = CURRENT_ENV;
150 _name = env->get_symbol(fd->name());
151 _signature = env->get_symbol(fd->signature());
152
153 BasicType field_type = fd->field_type();
154
155 // If the field is a pointer type, get the klass of the
156 // field.
157 if (field_type == T_OBJECT || field_type == T_ARRAY) {
158 _type = NULL; // must call compute_type on first access
159 } else {
160 _type = ciType::make(field_type);
161 }
162
163 initialize_from(fd);
164
165 // Either (a) it is marked shared, or else (b) we are done bootstrapping.
166 assert(is_shared() || ciObjectFactory::is_initialized(),
167 "bootstrap classes must not create & cache unshared fields");
324 }
325
326 // Check for static/nonstatic mismatch
327 bool is_static = (bc == Bytecodes::_getstatic || bc == Bytecodes::_putstatic);
328 if (is_static != this->is_static()) {
329 return false;
330 }
331
332 // Get and put can have different accessibility rules
333 bool is_put = (bc == Bytecodes::_putfield || bc == Bytecodes::_putstatic);
334 if (is_put) {
335 if (_known_to_link_with_put == accessing_klass) {
336 return true;
337 }
338 } else {
339 if (_known_to_link_with_get == accessing_klass) {
340 return true;
341 }
342 }
343
344 fieldDescriptor result;
345 LinkResolver::resolve_field(result, _holder->get_instanceKlass(),
346 _name->get_symbol(), _signature->get_symbol(),
347 accessing_klass->get_Klass(), bc, true, false,
348 KILL_COMPILE_ON_FATAL_(false));
349
350 // update the hit-cache, unless there is a problem with memory scoping:
351 if (accessing_klass->is_shared() || !is_shared()) {
352 if (is_put) {
353 _known_to_link_with_put = accessing_klass;
354 } else {
355 _known_to_link_with_get = accessing_klass;
356 }
357 }
358
359 return true;
360 }
361
362 // ------------------------------------------------------------------
363 // ciField::print
364 void ciField::print() {
365 tty->print("<ciField name=");
366 _holder->print_name();
367 tty->print(".");
368 _name->print_symbol();
|