1 /*
2 * Copyright (c) 2011, 2015, 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 #include "precompiled.hpp"
25 #include "code/compiledIC.hpp"
26 #include "compiler/compileBroker.hpp"
27 #include "compiler/disassembler.hpp"
28 #include "oops/oop.inline.hpp"
29 #include "oops/objArrayOop.inline.hpp"
30 #include "runtime/javaCalls.hpp"
31 #include "jvmci/jvmciEnv.hpp"
32 #include "jvmci/jvmciCompiler.hpp"
33 #include "jvmci/jvmciCodeInstaller.hpp"
34 #include "jvmci/jvmciJavaClasses.hpp"
35 #include "jvmci/jvmciCompilerToVM.hpp"
36 #include "jvmci/jvmciRuntime.hpp"
37 #include "asm/register.hpp"
38 #include "classfile/vmSymbols.hpp"
39 #include "code/vmreg.hpp"
40
41 #ifdef TARGET_ARCH_x86
42 # include "vmreg_x86.inline.hpp"
43 #endif
44 #ifdef TARGET_ARCH_sparc
45 # include "vmreg_sparc.inline.hpp"
46 #endif
47 #ifdef TARGET_ARCH_zero
48 # include "vmreg_zero.inline.hpp"
49 #endif
50 #ifdef TARGET_ARCH_arm
51 # include "vmreg_arm.inline.hpp"
52 #endif
53 #ifdef TARGET_ARCH_ppc
54 # include "vmreg_ppc.inline.hpp"
55 #endif
56
57
58 // frequently used constants
59 // Allocate them with new so they are never destroyed (otherwise, a
60 // forced exit could destroy these objects while they are still in
61 // use).
62 ConstantOopWriteValue* CodeInstaller::_oop_null_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantOopWriteValue(NULL);
63 ConstantIntValue* CodeInstaller::_int_m1_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(-1);
64 ConstantIntValue* CodeInstaller::_int_0_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(0);
65 ConstantIntValue* CodeInstaller::_int_1_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(1);
66 ConstantIntValue* CodeInstaller::_int_2_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(2);
67 LocationValue* CodeInstaller::_illegal_value = new (ResourceObj::C_HEAP, mtCompiler) LocationValue(Location());
68
69 Method* getMethodFromHotSpotMethod(oop hotspot_method) {
70 assert(hotspot_method != NULL && hotspot_method->is_a(HotSpotResolvedJavaMethodImpl::klass()), "sanity");
71 return CompilerToVM::asMethod(hotspot_method);
72 }
73
74 VMReg getVMRegFromLocation(oop location, int total_frame_size) {
75 oop reg = code_Location::reg(location);
76 jint offset = code_Location::offset(location);
77
78 if (reg != NULL) {
79 // register
80 jint number = code_Register::number(reg);
81 VMReg vmReg = CodeInstaller::get_hotspot_reg(number);
82 assert(offset % 4 == 0, "must be aligned");
83 return vmReg->next(offset / 4);
84 } else {
85 // stack slot
86 assert(offset % 4 == 0, "must be aligned");
87 return VMRegImpl::stack2reg(offset / 4);
88 }
89 }
90
91 // creates a HotSpot oop map out of the byte arrays provided by DebugInfo
92 OopMap* CodeInstaller::create_oop_map(oop debug_info) {
93 oop reference_map = DebugInfo::referenceMap(debug_info);
94 if (HotSpotReferenceMap::maxRegisterSize(reference_map) > 16) {
95 _has_wide_vector = true;
96 }
97 OopMap* map = new OopMap(_total_frame_size, _parameter_count);
98 objArrayOop objects = HotSpotReferenceMap::objects(reference_map);
99 objArrayOop derivedBase = HotSpotReferenceMap::derivedBase(reference_map);
100 typeArrayOop sizeInBytes = HotSpotReferenceMap::sizeInBytes(reference_map);
101 for (int i = 0; i < objects->length(); i++) {
102 oop location = objects->obj_at(i);
103 oop baseLocation = derivedBase->obj_at(i);
104 int bytes = sizeInBytes->int_at(i);
105
106 VMReg vmReg = getVMRegFromLocation(location, _total_frame_size);
107 if (baseLocation != NULL) {
108 // derived oop
109 assert(bytes == 8, "derived oop can't be compressed");
110 VMReg baseReg = getVMRegFromLocation(baseLocation, _total_frame_size);
111 map->set_derived_oop(vmReg, baseReg);
112 } else if (bytes == 8) {
113 // wide oop
114 map->set_oop(vmReg);
115 } else {
116 // narrow oop
117 assert(bytes == 4, "wrong size");
118 map->set_narrowoop(vmReg);
119 }
120 }
121
122 oop callee_save_info = (oop) DebugInfo::calleeSaveInfo(debug_info);
123 if (callee_save_info != NULL) {
124 objArrayOop registers = RegisterSaveLayout::registers(callee_save_info);
125 typeArrayOop slots = RegisterSaveLayout::slots(callee_save_info);
126 for (jint i = 0; i < slots->length(); i++) {
127 oop jvmci_reg = registers->obj_at(i);
128 jint jvmci_reg_number = code_Register::number(jvmci_reg);
129 VMReg hotspot_reg = CodeInstaller::get_hotspot_reg(jvmci_reg_number);
130 // HotSpot stack slots are 4 bytes
131 jint jvmci_slot = slots->int_at(i);
132 jint hotspot_slot = jvmci_slot * VMRegImpl::slots_per_word;
133 VMReg hotspot_slot_as_reg = VMRegImpl::stack2reg(hotspot_slot);
134 map->set_callee_saved(hotspot_slot_as_reg, hotspot_reg);
135 #ifdef _LP64
136 // (copied from generate_oop_map() in c1_Runtime1_x86.cpp)
137 VMReg hotspot_slot_hi_as_reg = VMRegImpl::stack2reg(hotspot_slot + 1);
138 map->set_callee_saved(hotspot_slot_hi_as_reg, hotspot_reg->next());
139 #endif
140 }
141 }
142 return map;
143 }
144
145 static void record_metadata_reference(oop obj, jlong prim, jboolean compressed, OopRecorder* oop_recorder) {
146 if (obj->is_a(HotSpotResolvedObjectTypeImpl::klass())) {
147 Klass* klass = java_lang_Class::as_Klass(HotSpotResolvedObjectTypeImpl::javaClass(obj));
148 if (compressed) {
149 assert(Klass::decode_klass((narrowKlass) prim) == klass, err_msg("%s @ " INTPTR_FORMAT " != " PTR64_FORMAT, klass->name()->as_C_string(), p2i(klass), prim));
150 } else {
151 assert((Klass*) prim == klass, err_msg("%s @ " INTPTR_FORMAT " != " PTR64_FORMAT, klass->name()->as_C_string(), p2i(klass), prim));
152 }
153 int index = oop_recorder->find_index(klass);
154 TRACE_jvmci_3("metadata[%d of %d] = %s", index, oop_recorder->metadata_count(), klass->name()->as_C_string());
155 } else if (obj->is_a(HotSpotResolvedJavaMethodImpl::klass())) {
156 Method* method = (Method*) (address) HotSpotResolvedJavaMethodImpl::metaspaceMethod(obj);
157 assert(!compressed, err_msg("unexpected compressed method pointer %s @ " INTPTR_FORMAT " = " PTR64_FORMAT, method->name()->as_C_string(), p2i(method), prim));
158 int index = oop_recorder->find_index(method);
159 TRACE_jvmci_3("metadata[%d of %d] = %s", index, oop_recorder->metadata_count(), method->name()->as_C_string());
160 } else {
161 assert(java_lang_String::is_instance(obj),
162 err_msg("unexpected metadata reference (%s) for constant " JLONG_FORMAT " (" PTR64_FORMAT ")", obj->klass()->name()->as_C_string(), prim, prim));
163 }
164 }
165
166 // Records any Metadata values embedded in a Constant (e.g., the value returned by HotSpotResolvedObjectTypeImpl.klass()).
167 static void record_metadata_in_constant(oop constant, OopRecorder* oop_recorder) {
168 if (constant->is_a(HotSpotMetaspaceConstantImpl::klass())) {
169 oop obj = HotSpotMetaspaceConstantImpl::metaspaceObject(constant);
170 jlong prim = HotSpotMetaspaceConstantImpl::primitive(constant);
171 assert(obj != NULL, "must have an object");
172 assert(prim != 0, "must have a primitive value");
173
174 record_metadata_reference(obj, prim, false, oop_recorder);
175 }
176 }
177
178 static void record_metadata_in_patch(Handle& constant, OopRecorder* oop_recorder) {
179 record_metadata_reference(HotSpotMetaspaceConstantImpl::metaspaceObject(constant), HotSpotMetaspaceConstantImpl::primitive(constant), HotSpotMetaspaceConstantImpl::compressed(constant), oop_recorder);
180 }
181
182 Location::Type CodeInstaller::get_oop_type(oop value) {
183 oop lirKind = Value::lirKind(value);
184 oop platformKind = LIRKind::platformKind(lirKind);
185 assert(LIRKind::referenceMask(lirKind) == 1, "unexpected referenceMask");
186
187 if (platformKind == word_kind()) {
188 return Location::oop;
189 } else {
190 return Location::narrowoop;
191 }
192 }
193
194 ScopeValue* CodeInstaller::get_scope_value(oop value, BasicType type, GrowableArray<ScopeValue*>* objects, ScopeValue* &second) {
195 second = NULL;
196 if (value == Value::ILLEGAL()) {
197 assert(type == T_ILLEGAL, "expected legal value");
198 return _illegal_value;
199 } else if (value->is_a(RegisterValue::klass())) {
200 oop reg = RegisterValue::reg(value);
201 jint number = code_Register::number(reg);
202 VMReg hotspotRegister = get_hotspot_reg(number);
203 if (is_general_purpose_reg(hotspotRegister)) {
204 Location::Type locationType;
205 if (type == T_OBJECT) {
206 locationType = get_oop_type(value);
207 } else if (type == T_LONG) {
208 locationType = Location::lng;
209 } else {
210 assert(type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN, "unexpected type in cpu register");
211 locationType = Location::int_in_long;
212 }
213 ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister));
214 if (type == T_LONG) {
215 second = value;
216 }
217 return value;
218 } else {
219 assert(type == T_FLOAT || type == T_DOUBLE, "only float and double expected in xmm register");
220 Location::Type locationType;
221 if (type == T_FLOAT) {
222 // this seems weird, but the same value is used in c1_LinearScan
223 locationType = Location::normal;
224 } else {
225 locationType = Location::dbl;
226 }
227 ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister));
228 if (type == T_DOUBLE) {
229 second = value;
230 }
231 return value;
232 }
233 } else if (value->is_a(StackSlot::klass())) {
234 jint offset = StackSlot::offset(value);
235 if (StackSlot::addFrameSize(value)) {
236 offset += _total_frame_size;
237 }
238
239 Location::Type locationType;
240 if (type == T_OBJECT) {
241 locationType = get_oop_type(value);
242 } else if (type == T_LONG) {
243 locationType = Location::lng;
244 } else if (type == T_DOUBLE) {
245 locationType = Location::dbl;
246 } else {
247 assert(type == T_INT || type == T_FLOAT || type == T_SHORT || type == T_CHAR || type == T_BYTE || type == T_BOOLEAN, "unexpected type in stack slot");
248 locationType = Location::normal;
249 }
250 ScopeValue* value = new LocationValue(Location::new_stk_loc(locationType, offset));
251 if (type == T_DOUBLE || type == T_LONG) {
252 second = value;
253 }
254 return value;
255 } else if (value->is_a(JavaConstant::klass())) {
256 record_metadata_in_constant(value, _oop_recorder);
257 if (value->is_a(PrimitiveConstant::klass())) {
258 if (value->is_a(RawConstant::klass())) {
259 jlong prim = PrimitiveConstant::primitive(value);
260 return new ConstantLongValue(prim);
261 } else {
262 assert(type == JVMCIRuntime::kindToBasicType(JavaKind::typeChar(PrimitiveConstant::kind(value))), "primitive constant type doesn't match");
263 if (type == T_INT || type == T_FLOAT) {
264 jint prim = (jint)PrimitiveConstant::primitive(value);
265 switch (prim) {
266 case -1: return _int_m1_scope_value;
267 case 0: return _int_0_scope_value;
268 case 1: return _int_1_scope_value;
269 case 2: return _int_2_scope_value;
270 default: return new ConstantIntValue(prim);
271 }
272 } else {
273 assert(type == T_LONG || type == T_DOUBLE, "unexpected primitive constant type");
274 jlong prim = PrimitiveConstant::primitive(value);
275 second = _int_1_scope_value;
276 return new ConstantLongValue(prim);
277 }
278 }
279 } else {
280 assert(type == T_OBJECT, "unexpected object constant");
281 if (value->is_a(NullConstant::klass()) || value->is_a(HotSpotCompressedNullConstant::klass())) {
282 return _oop_null_scope_value;
283 } else {
284 assert(value->is_a(HotSpotObjectConstantImpl::klass()), "unexpected constant type");
285 oop obj = HotSpotObjectConstantImpl::object(value);
286 assert(obj != NULL, "null value must be in NullConstant");
287 return new ConstantOopWriteValue(JNIHandles::make_local(obj));
288 }
289 }
290 } else if (value->is_a(VirtualObject::klass())) {
291 assert(type == T_OBJECT, "unexpected virtual object");
292 int id = VirtualObject::id(value);
293 ScopeValue* object = objects->at(id);
294 assert(object != NULL, "missing value");
295 return object;
296 } else {
297 value->klass()->print();
298 value->print();
299 }
300 ShouldNotReachHere();
301 return NULL;
302 }
303
304 void CodeInstaller::record_object_value(ObjectValue* sv, oop value, GrowableArray<ScopeValue*>* objects) {
305 oop type = VirtualObject::type(value);
306 int id = VirtualObject::id(value);
307 oop javaMirror = HotSpotResolvedObjectTypeImpl::javaClass(type);
308 Klass* klass = java_lang_Class::as_Klass(javaMirror);
309 bool isLongArray = klass == Universe::longArrayKlassObj();
310
311 objArrayOop values = VirtualObject::values(value);
312 objArrayOop slotKinds = VirtualObject::slotKinds(value);
313 for (jint i = 0; i < values->length(); i++) {
314 ScopeValue* cur_second = NULL;
315 oop object = values->obj_at(i);
316 oop kind = slotKinds->obj_at(i);
317 BasicType type = JVMCIRuntime::kindToBasicType(JavaKind::typeChar(kind));
318 ScopeValue* value = get_scope_value(object, type, objects, cur_second);
319
320 if (isLongArray && cur_second == NULL) {
321 // we're trying to put ints into a long array... this isn't really valid, but it's used for some optimizations.
322 // add an int 0 constant
323 cur_second = _int_0_scope_value;
324 }
325
326 if (cur_second != NULL) {
327 sv->field_values()->append(cur_second);
328 }
329 assert(value != NULL, "missing value");
330 sv->field_values()->append(value);
331 }
332 }
333
334 MonitorValue* CodeInstaller::get_monitor_value(oop value, GrowableArray<ScopeValue*>* objects) {
335 guarantee(value->is_a(StackLockValue::klass()), "Monitors must be of type StackLockValue");
336
337 ScopeValue* second = NULL;
338 ScopeValue* owner_value = get_scope_value(StackLockValue::owner(value), T_OBJECT, objects, second);
339 assert(second == NULL, "monitor cannot occupy two stack slots");
340
341 ScopeValue* lock_data_value = get_scope_value(StackLockValue::slot(value), T_LONG, objects, second);
342 assert(second == lock_data_value, "monitor is LONG value that occupies two stack slots");
343 assert(lock_data_value->is_location(), "invalid monitor location");
344 Location lock_data_loc = ((LocationValue*)lock_data_value)->location();
345
346 bool eliminated = false;
347 if (StackLockValue::eliminated(value)) {
348 eliminated = true;
349 }
350
351 return new MonitorValue(owner_value, lock_data_loc, eliminated);
352 }
353
354 void CodeInstaller::initialize_dependencies(oop compiled_code, OopRecorder* recorder) {
355 JavaThread* thread = JavaThread::current();
356 CompilerThread* compilerThread = thread->is_Compiler_thread() ? thread->as_CompilerThread() : NULL;
357 _oop_recorder = recorder;
358 _dependencies = new Dependencies(&_arena, _oop_recorder, compilerThread != NULL ? compilerThread->log() : NULL);
359 objArrayHandle assumptions = HotSpotCompiledCode::assumptions(compiled_code);
360 if (!assumptions.is_null()) {
361 int length = assumptions->length();
362 for (int i = 0; i < length; ++i) {
363 Handle assumption = assumptions->obj_at(i);
364 if (!assumption.is_null()) {
365 if (assumption->klass() == Assumptions_NoFinalizableSubclass::klass()) {
366 assumption_NoFinalizableSubclass(assumption);
367 } else if (assumption->klass() == Assumptions_ConcreteSubtype::klass()) {
368 assumption_ConcreteSubtype(assumption);
369 } else if (assumption->klass() == Assumptions_LeafType::klass()) {
370 assumption_LeafType(assumption);
371 } else if (assumption->klass() == Assumptions_ConcreteMethod::klass()) {
372 assumption_ConcreteMethod(assumption);
373 } else if (assumption->klass() == Assumptions_CallSiteTargetValue::klass()) {
374 assumption_CallSiteTargetValue(assumption);
375 } else {
376 assumption->print();
377 fatal("unexpected Assumption subclass");
378 }
379 }
380 }
381 }
382 objArrayHandle methods = HotSpotCompiledCode::methods(compiled_code);
383 if (!methods.is_null()) {
384 int length = methods->length();
385 for (int i = 0; i < length; ++i) {
386 Handle method_handle = methods->obj_at(i);
387 methodHandle method = getMethodFromHotSpotMethod(method_handle());
388
389 _dependencies->assert_evol_method(method());
390 }
391 }
392 }
393
394 RelocBuffer::~RelocBuffer() {
395 if (_buffer != NULL) {
396 FREE_C_HEAP_ARRAY(char, _buffer);
397 }
398 }
399
400 address RelocBuffer::begin() const {
401 if (_buffer != NULL) {
402 return (address) _buffer;
403 }
404 return (address) _static_buffer;
405 }
406
407 void RelocBuffer::set_size(size_t bytes) {
408 assert(bytes <= _size, "can't grow in size!");
409 _size = bytes;
410 }
411
412 void RelocBuffer::ensure_size(size_t bytes) {
413 assert(_buffer == NULL, "can only be used once");
414 assert(_size == 0, "can only be used once");
415 if (bytes >= RelocBuffer::stack_size) {
416 _buffer = NEW_C_HEAP_ARRAY(char, bytes, mtInternal);
417 }
418 _size = bytes;
419 }
420
421 JVMCIEnv::CodeInstallResult CodeInstaller::gather_metadata(Handle target, Handle& compiled_code, CodeMetadata& metadata) {
422 CodeBuffer buffer("JVMCI Compiler CodeBuffer for Metadata");
423 jobject compiled_code_obj = JNIHandles::make_local(compiled_code());
424 initialize_dependencies(JNIHandles::resolve(compiled_code_obj), NULL);
425
426 // Get instructions and constants CodeSections early because we need it.
427 _instructions = buffer.insts();
428 _constants = buffer.consts();
429
430 initialize_fields(target(), JNIHandles::resolve(compiled_code_obj));
431 if (!initialize_buffer(buffer)) {
432 return JVMCIEnv::code_too_large;
433 }
434 process_exception_handlers();
435
436 _debug_recorder->pcs_size(); // ehm, create the sentinel record
437
438 assert(_debug_recorder->pcs_length() >= 2, "must be at least 2");
439
440 metadata.set_pc_desc(_debug_recorder->pcs(), _debug_recorder->pcs_length());
441 metadata.set_scopes(_debug_recorder->stream()->buffer(), _debug_recorder->data_size());
442 metadata.set_exception_table(&_exception_handler_table);
443
444 RelocBuffer* reloc_buffer = metadata.get_reloc_buffer();
445
446 reloc_buffer->ensure_size(buffer.total_relocation_size());
447 size_t size = (size_t) buffer.copy_relocations_to(reloc_buffer->begin(), (CodeBuffer::csize_t) reloc_buffer->size(), true);
448 reloc_buffer->set_size(size);
449 return JVMCIEnv::ok;
450 }
451
452 // constructor used to create a method
453 JVMCIEnv::CodeInstallResult CodeInstaller::install(JVMCICompiler* compiler, Handle target, Handle& compiled_code, CodeBlob*& cb, Handle installed_code, Handle speculation_log) {
454 CodeBuffer buffer("JVMCI Compiler CodeBuffer");
455 jobject compiled_code_obj = JNIHandles::make_local(compiled_code());
456 OopRecorder* recorder = new OopRecorder(&_arena, true);
457 initialize_dependencies(JNIHandles::resolve(compiled_code_obj), recorder);
458
459 // Get instructions and constants CodeSections early because we need it.
460 _instructions = buffer.insts();
461 _constants = buffer.consts();
462
463 initialize_fields(target(), JNIHandles::resolve(compiled_code_obj));
464 JVMCIEnv::CodeInstallResult result = initialize_buffer(buffer);
465 if (result != JVMCIEnv::ok) {
466 return result;
467 }
468 process_exception_handlers();
469
470 int stack_slots = _total_frame_size / HeapWordSize; // conversion to words
471
472 if (!compiled_code->is_a(HotSpotCompiledNmethod::klass())) {
473 oop stubName = HotSpotCompiledCode::name(compiled_code_obj);
474 char* name = strdup(java_lang_String::as_utf8_string(stubName));
475 cb = RuntimeStub::new_runtime_stub(name,
476 &buffer,
477 CodeOffsets::frame_never_safe,
478 stack_slots,
479 _debug_recorder->_oopmaps,
480 false);
481 result = JVMCIEnv::ok;
482 } else {
483 nmethod* nm = NULL;
484 methodHandle method = getMethodFromHotSpotMethod(HotSpotCompiledNmethod::method(compiled_code));
485 jint entry_bci = HotSpotCompiledNmethod::entryBCI(compiled_code);
486 jint id = HotSpotCompiledNmethod::id(compiled_code);
487 bool has_unsafe_access = HotSpotCompiledNmethod::hasUnsafeAccess(compiled_code) == JNI_TRUE;
488 JVMCIEnv* env = (JVMCIEnv*) (address) HotSpotCompiledNmethod::jvmciEnv(compiled_code);
489 if (id == -1) {
490 // Make sure a valid compile_id is associated with every compile
491 id = CompileBroker::assign_compile_id_unlocked(Thread::current(), method, entry_bci);
492 }
493 result = JVMCIEnv::register_method(method, nm, entry_bci, &_offsets, _custom_stack_area_offset, &buffer,
494 stack_slots, _debug_recorder->_oopmaps, &_exception_handler_table,
495 compiler, _debug_recorder, _dependencies, env, id,
496 has_unsafe_access, _has_wide_vector, installed_code, compiled_code, speculation_log);
497 cb = nm;
498 }
499
500 if (cb != NULL) {
501 // Make sure the pre-calculated constants section size was correct.
502 guarantee((cb->code_begin() - cb->content_begin()) >= _constants_size, err_msg("%d < %d", (int)(cb->code_begin() - cb->content_begin()), _constants_size));
503 }
504 return result;
505 }
506
507 void CodeInstaller::initialize_fields(oop target, oop compiled_code) {
508 if (compiled_code->is_a(HotSpotCompiledNmethod::klass())) {
509 Handle hotspotJavaMethod = HotSpotCompiledNmethod::method(compiled_code);
510 methodHandle method = getMethodFromHotSpotMethod(hotspotJavaMethod());
511 _parameter_count = method->size_of_parameters();
512 TRACE_jvmci_2("installing code for %s", method->name_and_sig_as_C_string());
513 } else {
514 // Must be a HotSpotCompiledRuntimeStub.
515 // Only used in OopMap constructor for non-product builds
516 _parameter_count = 0;
517 }
518 _sites_handle = JNIHandles::make_local(HotSpotCompiledCode::sites(compiled_code));
519 _exception_handlers_handle = JNIHandles::make_local(HotSpotCompiledCode::exceptionHandlers(compiled_code));
520
521 _code_handle = JNIHandles::make_local(HotSpotCompiledCode::targetCode(compiled_code));
522 _code_size = HotSpotCompiledCode::targetCodeSize(compiled_code);
523 _total_frame_size = HotSpotCompiledCode::totalFrameSize(compiled_code);
524 _custom_stack_area_offset = HotSpotCompiledCode::customStackAreaOffset(compiled_code);
525
526 // Pre-calculate the constants section size. This is required for PC-relative addressing.
527 _data_section_handle = JNIHandles::make_local(HotSpotCompiledCode::dataSection(compiled_code));
528 guarantee(HotSpotCompiledCode::dataSectionAlignment(compiled_code) <= _constants->alignment(), "Alignment inside constants section is restricted by alignment of section begin");
529 _constants_size = data_section()->length();
530
531 _data_section_patches_handle = JNIHandles::make_local(HotSpotCompiledCode::dataSectionPatches(compiled_code));
532
533 #ifndef PRODUCT
534 _comments_handle = JNIHandles::make_local(HotSpotCompiledCode::comments(compiled_code));
535 #endif
536
537 _next_call_type = INVOKE_INVALID;
538
539 _has_wide_vector = false;
540
541 oop arch = TargetDescription::arch(target);
542 _word_kind_handle = JNIHandles::make_local(Architecture::wordKind(arch));
543 }
544
545 int CodeInstaller::estimate_stubs_size() {
546 // Return size for all stubs.
547 int static_call_stubs = 0;
548 objArrayOop sites = this->sites();
549 for (int i = 0; i < sites->length(); i++) {
550 oop site = sites->obj_at(i);
551 if (site->is_a(CompilationResult_Mark::klass())) {
552 oop id_obj = CompilationResult_Mark::id(site);
553 if (id_obj != NULL) {
554 assert(java_lang_boxing_object::is_instance(id_obj, T_INT), "Integer id expected");
555 jint id = id_obj->int_field(java_lang_boxing_object::value_offset_in_bytes(T_INT));
556 if (id == INVOKESTATIC || id == INVOKESPECIAL) {
557 static_call_stubs++;
558 }
559 }
560 }
561 }
562 return static_call_stubs * CompiledStaticCall::to_interp_stub_size();
563 }
564
565 // perform data and call relocation on the CodeBuffer
566 JVMCIEnv::CodeInstallResult CodeInstaller::initialize_buffer(CodeBuffer& buffer) {
567 objArrayHandle sites = this->sites();
568 int locs_buffer_size = sites->length() * (relocInfo::length_limit + sizeof(relocInfo));
569
570 // Allocate enough space in the stub section for the static call
571 // stubs. Stubs have extra relocs but they are managed by the stub
572 // section itself so they don't need to be accounted for in the
573 // locs_buffer above.
574 int stubs_size = estimate_stubs_size();
575 int total_size = round_to(_code_size, buffer.insts()->alignment()) + round_to(_constants_size, buffer.consts()->alignment()) + round_to(stubs_size, buffer.stubs()->alignment());
576
577 if (total_size > JVMCINMethodSizeLimit) {
578 return JVMCIEnv::code_too_large;
579 }
580
581 buffer.initialize(total_size, locs_buffer_size);
582 if (buffer.blob() == NULL) {
583 return JVMCIEnv::cache_full;
584 }
585 buffer.initialize_stubs_size(stubs_size);
586 buffer.initialize_consts_size(_constants_size);
587
588 _debug_recorder = new DebugInformationRecorder(_oop_recorder);
589 _debug_recorder->set_oopmaps(new OopMapSet());
590
591 buffer.initialize_oop_recorder(_oop_recorder);
592
593 // copy the constant data into the newly created CodeBuffer
594 address end_data = _constants->start() + _constants_size;
595 memcpy(_constants->start(), data_section()->base(T_BYTE), _constants_size);
596 _constants->set_end(end_data);
597
598 // copy the code into the newly created CodeBuffer
599 address end_pc = _instructions->start() + _code_size;
600 guarantee(_instructions->allocates2(end_pc), "initialize should have reserved enough space for all the code");
601 memcpy(_instructions->start(), code()->base(T_BYTE), _code_size);
602 _instructions->set_end(end_pc);
603
604 for (int i = 0; i < data_section_patches()->length(); i++) {
605 Handle patch = data_section_patches()->obj_at(i);
606 Handle reference = CompilationResult_DataPatch::reference(patch);
607 assert(reference->is_a(CompilationResult_ConstantReference::klass()), err_msg("patch in data section must be a ConstantReference"));
608 Handle constant = CompilationResult_ConstantReference::constant(reference);
609 if (constant->is_a(HotSpotMetaspaceConstantImpl::klass())) {
610 record_metadata_in_patch(constant, _oop_recorder);
611 } else if (constant->is_a(HotSpotObjectConstantImpl::klass())) {
612 Handle obj = HotSpotObjectConstantImpl::object(constant);
613 jobject value = JNIHandles::make_local(obj());
614 int oop_index = _oop_recorder->find_index(value);
615
616 address dest = _constants->start() + CompilationResult_Site::pcOffset(patch);
617 if (HotSpotObjectConstantImpl::compressed(constant)) {
618 #ifdef _LP64
619 _constants->relocate(dest, oop_Relocation::spec(oop_index), relocInfo::narrow_oop_in_const);
620 #else
621 fatal("unexpected compressed oop in 32-bit mode");
622 #endif
623 } else {
624 _constants->relocate(dest, oop_Relocation::spec(oop_index));
625 }
626 } else {
627 ShouldNotReachHere();
628 }
629 }
630 jint last_pc_offset = -1;
631 for (int i = 0; i < sites->length(); i++) {
632 {
633 No_Safepoint_Verifier no_safepoint;
634 oop site = sites->obj_at(i);
635 jint pc_offset = CompilationResult_Site::pcOffset(site);
636
637 if (site->is_a(CompilationResult_Call::klass())) {
638 TRACE_jvmci_4("call at %i", pc_offset);
639 site_Call(buffer, pc_offset, site);
640 } else if (site->is_a(CompilationResult_Infopoint::klass())) {
641 // three reasons for infopoints denote actual safepoints
642 oop reason = CompilationResult_Infopoint::reason(site);
643 if (InfopointReason::SAFEPOINT() == reason || InfopointReason::CALL() == reason || InfopointReason::IMPLICIT_EXCEPTION() == reason) {
644 TRACE_jvmci_4("safepoint at %i", pc_offset);
645 site_Safepoint(buffer, pc_offset, site);
646 } else {
647 // if the infopoint is not an actual safepoint, it must have one of the other reasons
648 // (safeguard against new safepoint types that require handling above)
649 assert(InfopointReason::METHOD_START() == reason || InfopointReason::METHOD_END() == reason || InfopointReason::LINE_NUMBER() == reason, "");
650 site_Infopoint(buffer, pc_offset, site);
651 }
652 } else if (site->is_a(CompilationResult_DataPatch::klass())) {
653 TRACE_jvmci_4("datapatch at %i", pc_offset);
654 site_DataPatch(buffer, pc_offset, site);
655 } else if (site->is_a(CompilationResult_Mark::klass())) {
656 TRACE_jvmci_4("mark at %i", pc_offset);
657 site_Mark(buffer, pc_offset, site);
658 } else {
659 fatal("unexpected Site subclass");
660 }
661 last_pc_offset = pc_offset;
662 }
663 if (CodeInstallSafepointChecks && SafepointSynchronize::do_call_back()) {
664 // this is a hacky way to force a safepoint check but nothing else was jumping out at me.
665 ThreadToNativeFromVM ttnfv(JavaThread::current());
666 }
667 }
668
669 #ifndef PRODUCT
670 if (comments() != NULL) {
671 No_Safepoint_Verifier no_safepoint;
672 for (int i = 0; i < comments()->length(); i++) {
673 oop comment = comments()->obj_at(i);
674 assert(comment->is_a(HotSpotCompiledCode_Comment::klass()), "cce");
675 jint offset = HotSpotCompiledCode_Comment::pcOffset(comment);
676 char* text = java_lang_String::as_utf8_string(HotSpotCompiledCode_Comment::text(comment));
677 buffer.block_comment(offset, text);
678 }
679 }
680 #endif
681 return JVMCIEnv::ok;
682 }
683
684 void CodeInstaller::assumption_NoFinalizableSubclass(Handle assumption) {
685 Handle receiverType_handle = Assumptions_NoFinalizableSubclass::receiverType(assumption());
686 Klass* receiverType = java_lang_Class::as_Klass(HotSpotResolvedObjectTypeImpl::javaClass(receiverType_handle));
687 _dependencies->assert_has_no_finalizable_subclasses(receiverType);
688 }
689
690 void CodeInstaller::assumption_ConcreteSubtype(Handle assumption) {
691 Handle context_handle = Assumptions_ConcreteSubtype::context(assumption());
692 Handle subtype_handle = Assumptions_ConcreteSubtype::subtype(assumption());
693 Klass* context = java_lang_Class::as_Klass(HotSpotResolvedObjectTypeImpl::javaClass(context_handle));
694 Klass* subtype = java_lang_Class::as_Klass(HotSpotResolvedObjectTypeImpl::javaClass(subtype_handle));
695
696 assert(context->is_abstract(), "");
697 _dependencies->assert_abstract_with_unique_concrete_subtype(context, subtype);
698 }
699
700 void CodeInstaller::assumption_LeafType(Handle assumption) {
701 Handle context_handle = Assumptions_LeafType::context(assumption());
702 Klass* context = java_lang_Class::as_Klass(HotSpotResolvedObjectTypeImpl::javaClass(context_handle));
703
704 _dependencies->assert_leaf_type(context);
705 }
706
707 void CodeInstaller::assumption_ConcreteMethod(Handle assumption) {
708 Handle impl_handle = Assumptions_ConcreteMethod::impl(assumption());
709 Handle context_handle = Assumptions_ConcreteMethod::context(assumption());
710
711 methodHandle impl = getMethodFromHotSpotMethod(impl_handle());
712 Klass* context = java_lang_Class::as_Klass(HotSpotResolvedObjectTypeImpl::javaClass(context_handle));
713
714 _dependencies->assert_unique_concrete_method(context, impl());
715 }
716
717 void CodeInstaller::assumption_CallSiteTargetValue(Handle assumption) {
718 Handle callSite = Assumptions_CallSiteTargetValue::callSite(assumption());
719 Handle methodHandle = Assumptions_CallSiteTargetValue::methodHandle(assumption());
720
721 _dependencies->assert_call_site_target_value(callSite(), methodHandle());
722 }
723
724 void CodeInstaller::process_exception_handlers() {
725 if (exception_handlers() != NULL) {
726 objArrayOop handlers = exception_handlers();
727 for (int i = 0; i < handlers->length(); i++) {
728 oop exc = handlers->obj_at(i);
729 jint pc_offset = CompilationResult_Site::pcOffset(exc);
730 jint handler_offset = CompilationResult_ExceptionHandler::handlerPos(exc);
731
732 // Subtable header
733 _exception_handler_table.add_entry(HandlerTableEntry(1, pc_offset, 0));
734
735 // Subtable entry
736 _exception_handler_table.add_entry(HandlerTableEntry(-1, handler_offset, 0));
737 }
738 }
739 }
740
741 // If deoptimization happens, the interpreter should reexecute these bytecodes.
742 // This function mainly helps the compilers to set up the reexecute bit.
743 static bool bytecode_should_reexecute(Bytecodes::Code code) {
744 switch (code) {
745 case Bytecodes::_invokedynamic:
746 case Bytecodes::_invokevirtual:
747 case Bytecodes::_invokeinterface:
748 case Bytecodes::_invokespecial:
749 case Bytecodes::_invokestatic:
750 return false;
751 default:
752 return true;
753 }
754 return true;
755 }
756
757 GrowableArray<ScopeValue*>* CodeInstaller::record_virtual_objects(oop debug_info) {
758 objArrayOop virtualObjects = DebugInfo::virtualObjectMapping(debug_info);
759 if (virtualObjects == NULL) {
760 return NULL;
761 }
762 GrowableArray<ScopeValue*>* objects = new GrowableArray<ScopeValue*>(virtualObjects->length(), virtualObjects->length(), NULL);
763 // Create the unique ObjectValues
764 for (int i = 0; i < virtualObjects->length(); i++) {
765 oop value = virtualObjects->obj_at(i);
766 int id = VirtualObject::id(value);
767 oop type = VirtualObject::type(value);
768 oop javaMirror = HotSpotResolvedObjectTypeImpl::javaClass(type);
769 ObjectValue* sv = new ObjectValue(id, new ConstantOopWriteValue(JNIHandles::make_local(Thread::current(), javaMirror)));
770 assert(objects->at(id) == NULL, "once");
771 objects->at_put(id, sv);
772 }
773 // All the values which could be referenced by the VirtualObjects
774 // exist, so now describe all the VirtualObjects themselves.
775 for (int i = 0; i < virtualObjects->length(); i++) {
776 oop value = virtualObjects->obj_at(i);
777 int id = VirtualObject::id(value);
778 record_object_value(objects->at(id)->as_ObjectValue(), value, objects);
779 }
780 _debug_recorder->dump_object_pool(objects);
781 return objects;
782 }
783
784 void CodeInstaller::record_scope(jint pc_offset, oop debug_info) {
785 oop position = DebugInfo::bytecodePosition(debug_info);
786 if (position == NULL) {
787 // Stubs do not record scope info, just oop maps
788 return;
789 }
790
791 GrowableArray<ScopeValue*>* objectMapping = record_virtual_objects(debug_info);
792 record_scope(pc_offset, position, objectMapping);
793 }
794
795 void CodeInstaller::record_scope(jint pc_offset, oop position, GrowableArray<ScopeValue*>* objects) {
796 oop frame = NULL;
797 if (position->is_a(BytecodeFrame::klass())) {
798 frame = position;
799 }
800 oop caller_frame = BytecodePosition::caller(position);
801 if (caller_frame != NULL) {
802 record_scope(pc_offset, caller_frame, objects);
803 }
804
805 oop hotspot_method = BytecodePosition::method(position);
806 Method* method = getMethodFromHotSpotMethod(hotspot_method);
807 jint bci = BytecodePosition::bci(position);
808 if (bci == BytecodeFrame::BEFORE_BCI()) {
809 bci = SynchronizationEntryBCI;
810 }
811
812 TRACE_jvmci_2("Recording scope pc_offset=%d bci=%d method=%s", pc_offset, bci, method->name_and_sig_as_C_string());
813
814 bool reexecute = false;
815 if (frame != NULL) {
816 if (bci == SynchronizationEntryBCI){
817 reexecute = false;
818 } else {
819 Bytecodes::Code code = Bytecodes::java_code_at(method, method->bcp_from(bci));
820 reexecute = bytecode_should_reexecute(code);
821 if (frame != NULL) {
822 reexecute = (BytecodeFrame::duringCall(frame) == JNI_FALSE);
823 }
824 }
825 }
826
827 DebugToken* locals_token = NULL;
828 DebugToken* expressions_token = NULL;
829 DebugToken* monitors_token = NULL;
830 bool throw_exception = false;
831
832 if (frame != NULL) {
833 jint local_count = BytecodeFrame::numLocals(frame);
834 jint expression_count = BytecodeFrame::numStack(frame);
835 jint monitor_count = BytecodeFrame::numLocks(frame);
836 objArrayOop values = BytecodeFrame::values(frame);
837 objArrayOop slotKinds = BytecodeFrame::slotKinds(frame);
838
839 assert(local_count + expression_count + monitor_count == values->length(), "unexpected values length");
840 assert(local_count + expression_count == slotKinds->length(), "unexpected slotKinds length");
841
842 GrowableArray<ScopeValue*>* locals = local_count > 0 ? new GrowableArray<ScopeValue*> (local_count) : NULL;
843 GrowableArray<ScopeValue*>* expressions = expression_count > 0 ? new GrowableArray<ScopeValue*> (expression_count) : NULL;
844 GrowableArray<MonitorValue*>* monitors = monitor_count > 0 ? new GrowableArray<MonitorValue*> (monitor_count) : NULL;
845
846 TRACE_jvmci_2("Scope at bci %d with %d values", bci, values->length());
847 TRACE_jvmci_2("%d locals %d expressions, %d monitors", local_count, expression_count, monitor_count);
848
849 for (jint i = 0; i < values->length(); i++) {
850 ScopeValue* second = NULL;
851 oop value = values->obj_at(i);
852 if (i < local_count) {
853 oop kind = slotKinds->obj_at(i);
854 BasicType type = JVMCIRuntime::kindToBasicType(JavaKind::typeChar(kind));
855 ScopeValue* first = get_scope_value(value, type, objects, second);
856 if (second != NULL) {
857 locals->append(second);
858 }
859 locals->append(first);
860 } else if (i < local_count + expression_count) {
861 oop kind = slotKinds->obj_at(i);
862 BasicType type = JVMCIRuntime::kindToBasicType(JavaKind::typeChar(kind));
863 ScopeValue* first = get_scope_value(value, type, objects, second);
864 if (second != NULL) {
865 expressions->append(second);
866 }
867 expressions->append(first);
868 } else {
869 monitors->append(get_monitor_value(value, objects));
870 }
871 if (second != NULL) {
872 i++;
873 assert(i < values->length(), "double-slot value not followed by Value.ILLEGAL");
874 assert(values->obj_at(i) == Value::ILLEGAL(), "double-slot value not followed by Value.ILLEGAL");
875 }
876 }
877
878 locals_token = _debug_recorder->create_scope_values(locals);
879 expressions_token = _debug_recorder->create_scope_values(expressions);
880 monitors_token = _debug_recorder->create_monitor_values(monitors);
881
882 throw_exception = BytecodeFrame::rethrowException(frame) == JNI_TRUE;
883 }
884
885 _debug_recorder->describe_scope(pc_offset, method, NULL, bci, reexecute, throw_exception, false, false,
886 locals_token, expressions_token, monitors_token);
887 }
888
889 void CodeInstaller::site_Safepoint(CodeBuffer& buffer, jint pc_offset, oop site) {
890 oop debug_info = CompilationResult_Infopoint::debugInfo(site);
891 assert(debug_info != NULL, "debug info expected");
892
893 // address instruction = _instructions->start() + pc_offset;
894 // jint next_pc_offset = Assembler::locate_next_instruction(instruction) - _instructions->start();
895 _debug_recorder->add_safepoint(pc_offset, create_oop_map(debug_info));
896 record_scope(pc_offset, debug_info);
897 _debug_recorder->end_safepoint(pc_offset);
898 }
899
900 void CodeInstaller::site_Infopoint(CodeBuffer& buffer, jint pc_offset, oop site) {
901 oop debug_info = CompilationResult_Infopoint::debugInfo(site);
902 assert(debug_info != NULL, "debug info expected");
903
904 _debug_recorder->add_non_safepoint(pc_offset);
905 record_scope(pc_offset, debug_info);
906 _debug_recorder->end_non_safepoint(pc_offset);
907 }
908
909 void CodeInstaller::site_Call(CodeBuffer& buffer, jint pc_offset, oop site) {
910 oop target = CompilationResult_Call::target(site);
911 InstanceKlass* target_klass = InstanceKlass::cast(target->klass());
912
913 oop hotspot_method = NULL; // JavaMethod
914 oop foreign_call = NULL;
915
916 if (target_klass->is_subclass_of(SystemDictionary::HotSpotForeignCallTarget_klass())) {
917 foreign_call = target;
918 } else {
919 hotspot_method = target;
920 }
921
922 oop debug_info = CompilationResult_Call::debugInfo(site);
923
924 assert(!!hotspot_method ^ !!foreign_call, "Call site needs exactly one type");
925
926 NativeInstruction* inst = nativeInstruction_at(_instructions->start() + pc_offset);
927 jint next_pc_offset = CodeInstaller::pd_next_offset(inst, pc_offset, hotspot_method);
928
929 if (debug_info != NULL) {
930 _debug_recorder->add_safepoint(next_pc_offset, create_oop_map(debug_info));
931 record_scope(next_pc_offset, debug_info);
932 }
933
934 if (foreign_call != NULL) {
935 jlong foreign_call_destination = HotSpotForeignCallTarget::address(foreign_call);
936 CodeInstaller::pd_relocate_ForeignCall(inst, foreign_call_destination);
937 } else { // method != NULL
938 assert(hotspot_method != NULL, "unexpected JavaMethod");
939 assert(debug_info != NULL, "debug info expected");
940
941 TRACE_jvmci_3("method call");
942 CodeInstaller::pd_relocate_JavaMethod(hotspot_method, pc_offset);
943 if (_next_call_type == INVOKESTATIC || _next_call_type == INVOKESPECIAL) {
944 // Need a static call stub for transitions from compiled to interpreted.
945 CompiledStaticCall::emit_to_interp_stub(buffer, _instructions->start() + pc_offset);
946 }
947 }
948
949 _next_call_type = INVOKE_INVALID;
950
951 if (debug_info != NULL) {
952 _debug_recorder->end_safepoint(next_pc_offset);
953 }
954 }
955
956 void CodeInstaller::site_DataPatch(CodeBuffer& buffer, jint pc_offset, oop site) {
957 oop reference = CompilationResult_DataPatch::reference(site);
958 if (reference->is_a(CompilationResult_ConstantReference::klass())) {
959 Handle constant = CompilationResult_ConstantReference::constant(reference);
960 if (constant->is_a(HotSpotObjectConstantImpl::klass())) {
961 pd_patch_OopConstant(pc_offset, constant);
962 } else if (constant->is_a(HotSpotMetaspaceConstantImpl::klass())) {
963 record_metadata_in_patch(constant, _oop_recorder);
964 } else if (constant->is_a(HotSpotSentinelConstant::klass())) {
965 fatal("sentinel constant unsupported");
966 } else {
967 fatal("unknown constant type in data patch");
968 }
969 } else if (reference->is_a(CompilationResult_DataSectionReference::klass())) {
970 int data_offset = CompilationResult_DataSectionReference::offset(reference);
971 assert(0 <= data_offset && data_offset < _constants_size, err_msg("data offset 0x%X points outside data section (size 0x%X)", data_offset, _constants_size));
972 pd_patch_DataSectionReference(pc_offset, data_offset);
973 } else {
974 fatal("unknown data patch type");
975 }
976 }
977
978 void CodeInstaller::site_Mark(CodeBuffer& buffer, jint pc_offset, oop site) {
979 oop id_obj = CompilationResult_Mark::id(site);
980
981 if (id_obj != NULL) {
982 assert(java_lang_boxing_object::is_instance(id_obj, T_INT), "Integer id expected");
983 jint id = id_obj->int_field(java_lang_boxing_object::value_offset_in_bytes(T_INT));
984
985 address pc = _instructions->start() + pc_offset;
986
987 switch (id) {
988 case UNVERIFIED_ENTRY:
989 _offsets.set_value(CodeOffsets::Entry, pc_offset);
990 break;
991 case VERIFIED_ENTRY:
992 _offsets.set_value(CodeOffsets::Verified_Entry, pc_offset);
993 break;
994 case OSR_ENTRY:
995 _offsets.set_value(CodeOffsets::OSR_Entry, pc_offset);
996 break;
997 case EXCEPTION_HANDLER_ENTRY:
998 _offsets.set_value(CodeOffsets::Exceptions, pc_offset);
999 break;
1000 case DEOPT_HANDLER_ENTRY:
1001 _offsets.set_value(CodeOffsets::Deopt, pc_offset);
1002 break;
1003 case INVOKEVIRTUAL:
1004 case INVOKEINTERFACE:
1005 case INLINE_INVOKE:
1006 case INVOKESTATIC:
1007 case INVOKESPECIAL:
1008 _next_call_type = (MarkId) id;
1009 _invoke_mark_pc = pc;
1010 break;
1011 case POLL_NEAR:
1012 case POLL_FAR:
1013 case POLL_RETURN_NEAR:
1014 case POLL_RETURN_FAR:
1015 pd_relocate_poll(pc, id);
1016 break;
1017 case CARD_TABLE_ADDRESS:
1018 case HEAP_TOP_ADDRESS:
1019 case HEAP_END_ADDRESS:
1020 case NARROW_KLASS_BASE_ADDRESS:
1021 case CRC_TABLE_ADDRESS:
1022 break;
1023 default:
1024 ShouldNotReachHere();
1025 break;
1026 }
1027 }
1028 }
1029