1 /*
2 * Copyright (c) 2005, 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 "c1/c1_Compilation.hpp"
27 #include "c1/c1_Defs.hpp"
28 #include "c1/c1_FrameMap.hpp"
29 #include "c1/c1_Instruction.hpp"
30 #include "c1/c1_LIRAssembler.hpp"
31 #include "c1/c1_LIRGenerator.hpp"
32 #include "c1/c1_ValueStack.hpp"
33 #include "ci/ciArrayKlass.hpp"
34 #include "ci/ciInstance.hpp"
35 #include "ci/ciObjArray.hpp"
36 #include "gc/shared/cardTableModRefBS.hpp"
37 #include "runtime/arguments.hpp"
38 #include "runtime/sharedRuntime.hpp"
39 #include "runtime/stubRoutines.hpp"
40 #include "runtime/vm_version.hpp"
41 #include "utilities/bitMap.inline.hpp"
42 #include "utilities/macros.hpp"
43 #if INCLUDE_ALL_GCS
44 #include "gc/g1/heapRegion.hpp"
45 #endif // INCLUDE_ALL_GCS
46 #ifdef TRACE_HAVE_INTRINSICS
47 #include "trace/traceMacros.hpp"
48 #endif
49
50 #ifdef ASSERT
51 #define __ gen()->lir(__FILE__, __LINE__)->
52 #else
53 #define __ gen()->lir()->
54 #endif
55
56 #ifndef PATCHED_ADDR
57 #define PATCHED_ADDR (max_jint)
58 #endif
59
60 void PhiResolverState::reset(int max_vregs) {
61 // Initialize array sizes
62 _virtual_operands.at_put_grow(max_vregs - 1, NULL, NULL);
63 _virtual_operands.trunc_to(0);
64 _other_operands.at_put_grow(max_vregs - 1, NULL, NULL);
65 _other_operands.trunc_to(0);
66 _vreg_table.at_put_grow(max_vregs - 1, NULL, NULL);
67 _vreg_table.trunc_to(0);
68 }
69
70
71
72 //--------------------------------------------------------------
73 // PhiResolver
74
75 // Resolves cycles:
76 //
77 // r1 := r2 becomes temp := r1
78 // r2 := r1 r1 := r2
79 // r2 := temp
80 // and orders moves:
81 //
82 // r2 := r3 becomes r1 := r2
83 // r1 := r2 r2 := r3
84
85 PhiResolver::PhiResolver(LIRGenerator* gen, int max_vregs)
86 : _gen(gen)
87 , _state(gen->resolver_state())
88 , _temp(LIR_OprFact::illegalOpr)
89 {
90 // reinitialize the shared state arrays
91 _state.reset(max_vregs);
92 }
93
94
95 void PhiResolver::emit_move(LIR_Opr src, LIR_Opr dest) {
96 assert(src->is_valid(), "");
97 assert(dest->is_valid(), "");
98 __ move(src, dest);
99 }
100
101
102 void PhiResolver::move_temp_to(LIR_Opr dest) {
103 assert(_temp->is_valid(), "");
104 emit_move(_temp, dest);
105 NOT_PRODUCT(_temp = LIR_OprFact::illegalOpr);
106 }
107
108
109 void PhiResolver::move_to_temp(LIR_Opr src) {
110 assert(_temp->is_illegal(), "");
111 _temp = _gen->new_register(src->type());
112 emit_move(src, _temp);
113 }
114
115
116 // Traverse assignment graph in depth first order and generate moves in post order
117 // ie. two assignments: b := c, a := b start with node c:
118 // Call graph: move(NULL, c) -> move(c, b) -> move(b, a)
119 // Generates moves in this order: move b to a and move c to b
120 // ie. cycle a := b, b := a start with node a
121 // Call graph: move(NULL, a) -> move(a, b) -> move(b, a)
122 // Generates moves in this order: move b to temp, move a to b, move temp to a
123 void PhiResolver::move(ResolveNode* src, ResolveNode* dest) {
124 if (!dest->visited()) {
125 dest->set_visited();
126 for (int i = dest->no_of_destinations()-1; i >= 0; i --) {
127 move(dest, dest->destination_at(i));
128 }
129 } else if (!dest->start_node()) {
130 // cylce in graph detected
131 assert(_loop == NULL, "only one loop valid!");
132 _loop = dest;
133 move_to_temp(src->operand());
134 return;
135 } // else dest is a start node
136
137 if (!dest->assigned()) {
138 if (_loop == dest) {
139 move_temp_to(dest->operand());
140 dest->set_assigned();
141 } else if (src != NULL) {
142 emit_move(src->operand(), dest->operand());
143 dest->set_assigned();
144 }
145 }
146 }
147
148
149 PhiResolver::~PhiResolver() {
150 int i;
151 // resolve any cycles in moves from and to virtual registers
152 for (i = virtual_operands().length() - 1; i >= 0; i --) {
153 ResolveNode* node = virtual_operands().at(i);
154 if (!node->visited()) {
155 _loop = NULL;
156 move(NULL, node);
157 node->set_start_node();
158 assert(_temp->is_illegal(), "move_temp_to() call missing");
159 }
160 }
161
162 // generate move for move from non virtual register to abitrary destination
163 for (i = other_operands().length() - 1; i >= 0; i --) {
164 ResolveNode* node = other_operands().at(i);
165 for (int j = node->no_of_destinations() - 1; j >= 0; j --) {
166 emit_move(node->operand(), node->destination_at(j)->operand());
167 }
168 }
169 }
170
171
172 ResolveNode* PhiResolver::create_node(LIR_Opr opr, bool source) {
173 ResolveNode* node;
174 if (opr->is_virtual()) {
175 int vreg_num = opr->vreg_number();
176 node = vreg_table().at_grow(vreg_num, NULL);
177 assert(node == NULL || node->operand() == opr, "");
178 if (node == NULL) {
179 node = new ResolveNode(opr);
180 vreg_table().at_put(vreg_num, node);
181 }
182 // Make sure that all virtual operands show up in the list when
183 // they are used as the source of a move.
184 if (source && !virtual_operands().contains(node)) {
185 virtual_operands().append(node);
186 }
187 } else {
188 assert(source, "");
189 node = new ResolveNode(opr);
190 other_operands().append(node);
191 }
192 return node;
193 }
194
195
196 void PhiResolver::move(LIR_Opr src, LIR_Opr dest) {
197 assert(dest->is_virtual(), "");
198 // tty->print("move "); src->print(); tty->print(" to "); dest->print(); tty->cr();
199 assert(src->is_valid(), "");
200 assert(dest->is_valid(), "");
201 ResolveNode* source = source_node(src);
202 source->append(destination_node(dest));
203 }
204
205
206 //--------------------------------------------------------------
207 // LIRItem
208
209 void LIRItem::set_result(LIR_Opr opr) {
210 assert(value()->operand()->is_illegal() || value()->operand()->is_constant(), "operand should never change");
211 value()->set_operand(opr);
212
213 if (opr->is_virtual()) {
214 _gen->_instruction_for_operand.at_put_grow(opr->vreg_number(), value(), NULL);
215 }
216
217 _result = opr;
218 }
219
220 void LIRItem::load_item() {
221 if (result()->is_illegal()) {
222 // update the items result
223 _result = value()->operand();
224 }
225 if (!result()->is_register()) {
226 LIR_Opr reg = _gen->new_register(value()->type());
227 __ move(result(), reg);
228 if (result()->is_constant()) {
229 _result = reg;
230 } else {
231 set_result(reg);
232 }
233 }
234 }
235
236
237 void LIRItem::load_for_store(BasicType type) {
238 if (_gen->can_store_as_constant(value(), type)) {
239 _result = value()->operand();
240 if (!_result->is_constant()) {
241 _result = LIR_OprFact::value_type(value()->type());
242 }
243 } else if (type == T_BYTE || type == T_BOOLEAN) {
244 load_byte_item();
245 } else {
246 load_item();
247 }
248 }
249
250 void LIRItem::load_item_force(LIR_Opr reg) {
251 LIR_Opr r = result();
252 if (r != reg) {
253 #if !defined(ARM) && !defined(E500V2)
254 if (r->type() != reg->type()) {
255 // moves between different types need an intervening spill slot
256 r = _gen->force_to_spill(r, reg->type());
257 }
258 #endif
259 __ move(r, reg);
260 _result = reg;
261 }
262 }
263
264 ciObject* LIRItem::get_jobject_constant() const {
265 ObjectType* oc = type()->as_ObjectType();
266 if (oc) {
267 return oc->constant_value();
268 }
269 return NULL;
270 }
271
272
273 jint LIRItem::get_jint_constant() const {
274 assert(is_constant() && value() != NULL, "");
275 assert(type()->as_IntConstant() != NULL, "type check");
276 return type()->as_IntConstant()->value();
277 }
278
279
280 jint LIRItem::get_address_constant() const {
281 assert(is_constant() && value() != NULL, "");
282 assert(type()->as_AddressConstant() != NULL, "type check");
283 return type()->as_AddressConstant()->value();
284 }
285
286
287 jfloat LIRItem::get_jfloat_constant() const {
288 assert(is_constant() && value() != NULL, "");
289 assert(type()->as_FloatConstant() != NULL, "type check");
290 return type()->as_FloatConstant()->value();
291 }
292
293
294 jdouble LIRItem::get_jdouble_constant() const {
295 assert(is_constant() && value() != NULL, "");
296 assert(type()->as_DoubleConstant() != NULL, "type check");
297 return type()->as_DoubleConstant()->value();
298 }
299
300
301 jlong LIRItem::get_jlong_constant() const {
302 assert(is_constant() && value() != NULL, "");
303 assert(type()->as_LongConstant() != NULL, "type check");
304 return type()->as_LongConstant()->value();
305 }
306
307
308
309 //--------------------------------------------------------------
310
311
312 void LIRGenerator::init() {
313 _bs = Universe::heap()->barrier_set();
314 }
315
316
317 void LIRGenerator::block_do_prolog(BlockBegin* block) {
318 #ifndef PRODUCT
319 if (PrintIRWithLIR) {
320 block->print();
321 }
322 #endif
323
324 // set up the list of LIR instructions
325 assert(block->lir() == NULL, "LIR list already computed for this block");
326 _lir = new LIR_List(compilation(), block);
327 block->set_lir(_lir);
328
329 __ branch_destination(block->label());
330
331 if (LIRTraceExecution &&
332 Compilation::current()->hir()->start()->block_id() != block->block_id() &&
333 !block->is_set(BlockBegin::exception_entry_flag)) {
334 assert(block->lir()->instructions_list()->length() == 1, "should come right after br_dst");
335 trace_block_entry(block);
336 }
337 }
338
339
340 void LIRGenerator::block_do_epilog(BlockBegin* block) {
341 #ifndef PRODUCT
342 if (PrintIRWithLIR) {
343 tty->cr();
344 }
345 #endif
346
347 // LIR_Opr for unpinned constants shouldn't be referenced by other
348 // blocks so clear them out after processing the block.
349 for (int i = 0; i < _unpinned_constants.length(); i++) {
350 _unpinned_constants.at(i)->clear_operand();
351 }
352 _unpinned_constants.trunc_to(0);
353
354 // clear our any registers for other local constants
355 _constants.trunc_to(0);
356 _reg_for_constants.trunc_to(0);
357 }
358
359
360 void LIRGenerator::block_do(BlockBegin* block) {
361 CHECK_BAILOUT();
362
363 block_do_prolog(block);
364 set_block(block);
365
366 for (Instruction* instr = block; instr != NULL; instr = instr->next()) {
367 if (instr->is_pinned()) do_root(instr);
368 }
369
370 set_block(NULL);
371 block_do_epilog(block);
372 }
373
374
375 //-------------------------LIRGenerator-----------------------------
376
377 // This is where the tree-walk starts; instr must be root;
378 void LIRGenerator::do_root(Value instr) {
379 CHECK_BAILOUT();
380
381 InstructionMark im(compilation(), instr);
382
383 assert(instr->is_pinned(), "use only with roots");
384 assert(instr->subst() == instr, "shouldn't have missed substitution");
385
386 instr->visit(this);
387
388 assert(!instr->has_uses() || instr->operand()->is_valid() ||
389 instr->as_Constant() != NULL || bailed_out(), "invalid item set");
390 }
391
392
393 // This is called for each node in tree; the walk stops if a root is reached
394 void LIRGenerator::walk(Value instr) {
395 InstructionMark im(compilation(), instr);
396 //stop walk when encounter a root
397 if (instr->is_pinned() && instr->as_Phi() == NULL || instr->operand()->is_valid()) {
398 assert(instr->operand() != LIR_OprFact::illegalOpr || instr->as_Constant() != NULL, "this root has not yet been visited");
399 } else {
400 assert(instr->subst() == instr, "shouldn't have missed substitution");
401 instr->visit(this);
402 // assert(instr->use_count() > 0 || instr->as_Phi() != NULL, "leaf instruction must have a use");
403 }
404 }
405
406
407 CodeEmitInfo* LIRGenerator::state_for(Instruction* x, ValueStack* state, bool ignore_xhandler) {
408 assert(state != NULL, "state must be defined");
409
410 #ifndef PRODUCT
411 state->verify();
412 #endif
413
414 ValueStack* s = state;
415 for_each_state(s) {
416 if (s->kind() == ValueStack::EmptyExceptionState) {
417 assert(s->stack_size() == 0 && s->locals_size() == 0 && (s->locks_size() == 0 || s->locks_size() == 1), "state must be empty");
418 continue;
419 }
420
421 int index;
422 Value value;
423 for_each_stack_value(s, index, value) {
424 assert(value->subst() == value, "missed substitution");
425 if (!value->is_pinned() && value->as_Constant() == NULL && value->as_Local() == NULL) {
426 walk(value);
427 assert(value->operand()->is_valid(), "must be evaluated now");
428 }
429 }
430
431 int bci = s->bci();
432 IRScope* scope = s->scope();
433 ciMethod* method = scope->method();
434
435 MethodLivenessResult liveness = method->liveness_at_bci(bci);
436 if (bci == SynchronizationEntryBCI) {
437 if (x->as_ExceptionObject() || x->as_Throw()) {
438 // all locals are dead on exit from the synthetic unlocker
439 liveness.clear();
440 } else {
441 assert(x->as_MonitorEnter() || x->as_ProfileInvoke(), "only other cases are MonitorEnter and ProfileInvoke");
442 }
443 }
444 if (!liveness.is_valid()) {
445 // Degenerate or breakpointed method.
446 bailout("Degenerate or breakpointed method");
447 } else {
448 assert((int)liveness.size() == s->locals_size(), "error in use of liveness");
449 for_each_local_value(s, index, value) {
450 assert(value->subst() == value, "missed substition");
451 if (liveness.at(index) && !value->type()->is_illegal()) {
452 if (!value->is_pinned() && value->as_Constant() == NULL && value->as_Local() == NULL) {
453 walk(value);
454 assert(value->operand()->is_valid(), "must be evaluated now");
455 }
456 } else {
457 // NULL out this local so that linear scan can assume that all non-NULL values are live.
458 s->invalidate_local(index);
459 }
460 }
461 }
462 }
463
464 return new CodeEmitInfo(state, ignore_xhandler ? NULL : x->exception_handlers(), x->check_flag(Instruction::DeoptimizeOnException));
465 }
466
467
468 CodeEmitInfo* LIRGenerator::state_for(Instruction* x) {
469 return state_for(x, x->exception_state());
470 }
471
472
473 void LIRGenerator::klass2reg_with_patching(LIR_Opr r, ciMetadata* obj, CodeEmitInfo* info, bool need_resolve) {
474 /* C2 relies on constant pool entries being resolved (ciTypeFlow), so if TieredCompilation
475 * is active and the class hasn't yet been resolved we need to emit a patch that resolves
476 * the class. */
477 if ((TieredCompilation && need_resolve) || !obj->is_loaded() || PatchALot) {
478 assert(info != NULL, "info must be set if class is not loaded");
479 __ klass2reg_patch(NULL, r, info);
480 } else {
481 // no patching needed
482 __ metadata2reg(obj->constant_encoding(), r);
483 }
484 }
485
486
487 void LIRGenerator::array_range_check(LIR_Opr array, LIR_Opr index,
488 CodeEmitInfo* null_check_info, CodeEmitInfo* range_check_info) {
489 CodeStub* stub = new RangeCheckStub(range_check_info, index);
490 if (index->is_constant()) {
491 cmp_mem_int(lir_cond_belowEqual, array, arrayOopDesc::length_offset_in_bytes(),
492 index->as_jint(), null_check_info);
493 __ branch(lir_cond_belowEqual, T_INT, stub); // forward branch
494 } else {
495 cmp_reg_mem(lir_cond_aboveEqual, index, array,
496 arrayOopDesc::length_offset_in_bytes(), T_INT, null_check_info);
497 __ branch(lir_cond_aboveEqual, T_INT, stub); // forward branch
498 }
499 }
500
501
502 void LIRGenerator::nio_range_check(LIR_Opr buffer, LIR_Opr index, LIR_Opr result, CodeEmitInfo* info) {
503 CodeStub* stub = new RangeCheckStub(info, index, true);
504 if (index->is_constant()) {
505 cmp_mem_int(lir_cond_belowEqual, buffer, java_nio_Buffer::limit_offset(), index->as_jint(), info);
506 __ branch(lir_cond_belowEqual, T_INT, stub); // forward branch
507 } else {
508 cmp_reg_mem(lir_cond_aboveEqual, index, buffer,
509 java_nio_Buffer::limit_offset(), T_INT, info);
510 __ branch(lir_cond_aboveEqual, T_INT, stub); // forward branch
511 }
512 __ move(index, result);
513 }
514
515
516
517 void LIRGenerator::arithmetic_op(Bytecodes::Code code, LIR_Opr result, LIR_Opr left, LIR_Opr right, bool is_strictfp, LIR_Opr tmp_op, CodeEmitInfo* info) {
518 LIR_Opr result_op = result;
519 LIR_Opr left_op = left;
520 LIR_Opr right_op = right;
521
522 if (TwoOperandLIRForm && left_op != result_op) {
523 assert(right_op != result_op, "malformed");
524 __ move(left_op, result_op);
525 left_op = result_op;
526 }
527
528 switch(code) {
529 case Bytecodes::_dadd:
530 case Bytecodes::_fadd:
531 case Bytecodes::_ladd:
532 case Bytecodes::_iadd: __ add(left_op, right_op, result_op); break;
533 case Bytecodes::_fmul:
534 case Bytecodes::_lmul: __ mul(left_op, right_op, result_op); break;
535
536 case Bytecodes::_dmul:
537 {
538 if (is_strictfp) {
539 __ mul_strictfp(left_op, right_op, result_op, tmp_op); break;
540 } else {
541 __ mul(left_op, right_op, result_op); break;
542 }
543 }
544 break;
545
546 case Bytecodes::_imul:
547 {
548 bool did_strength_reduce = false;
549
550 if (right->is_constant()) {
551 int c = right->as_jint();
552 if (is_power_of_2(c)) {
553 // do not need tmp here
554 __ shift_left(left_op, exact_log2(c), result_op);
555 did_strength_reduce = true;
556 } else {
557 did_strength_reduce = strength_reduce_multiply(left_op, c, result_op, tmp_op);
558 }
559 }
560 // we couldn't strength reduce so just emit the multiply
561 if (!did_strength_reduce) {
562 __ mul(left_op, right_op, result_op);
563 }
564 }
565 break;
566
567 case Bytecodes::_dsub:
568 case Bytecodes::_fsub:
569 case Bytecodes::_lsub:
570 case Bytecodes::_isub: __ sub(left_op, right_op, result_op); break;
571
572 case Bytecodes::_fdiv: __ div (left_op, right_op, result_op); break;
573 // ldiv and lrem are implemented with a direct runtime call
574
575 case Bytecodes::_ddiv:
576 {
577 if (is_strictfp) {
578 __ div_strictfp (left_op, right_op, result_op, tmp_op); break;
579 } else {
580 __ div (left_op, right_op, result_op); break;
581 }
582 }
583 break;
584
585 case Bytecodes::_drem:
586 case Bytecodes::_frem: __ rem (left_op, right_op, result_op); break;
587
588 default: ShouldNotReachHere();
589 }
590 }
591
592
593 void LIRGenerator::arithmetic_op_int(Bytecodes::Code code, LIR_Opr result, LIR_Opr left, LIR_Opr right, LIR_Opr tmp) {
594 arithmetic_op(code, result, left, right, false, tmp);
595 }
596
597
598 void LIRGenerator::arithmetic_op_long(Bytecodes::Code code, LIR_Opr result, LIR_Opr left, LIR_Opr right, CodeEmitInfo* info) {
599 arithmetic_op(code, result, left, right, false, LIR_OprFact::illegalOpr, info);
600 }
601
602
603 void LIRGenerator::arithmetic_op_fpu(Bytecodes::Code code, LIR_Opr result, LIR_Opr left, LIR_Opr right, bool is_strictfp, LIR_Opr tmp) {
604 arithmetic_op(code, result, left, right, is_strictfp, tmp);
605 }
606
607
608 void LIRGenerator::shift_op(Bytecodes::Code code, LIR_Opr result_op, LIR_Opr value, LIR_Opr count, LIR_Opr tmp) {
609 if (TwoOperandLIRForm && value != result_op) {
610 assert(count != result_op, "malformed");
611 __ move(value, result_op);
612 value = result_op;
613 }
614
615 assert(count->is_constant() || count->is_register(), "must be");
616 switch(code) {
617 case Bytecodes::_ishl:
618 case Bytecodes::_lshl: __ shift_left(value, count, result_op, tmp); break;
619 case Bytecodes::_ishr:
620 case Bytecodes::_lshr: __ shift_right(value, count, result_op, tmp); break;
621 case Bytecodes::_iushr:
622 case Bytecodes::_lushr: __ unsigned_shift_right(value, count, result_op, tmp); break;
623 default: ShouldNotReachHere();
624 }
625 }
626
627
628 void LIRGenerator::logic_op (Bytecodes::Code code, LIR_Opr result_op, LIR_Opr left_op, LIR_Opr right_op) {
629 if (TwoOperandLIRForm && left_op != result_op) {
630 assert(right_op != result_op, "malformed");
631 __ move(left_op, result_op);
632 left_op = result_op;
633 }
634
635 switch(code) {
636 case Bytecodes::_iand:
637 case Bytecodes::_land: __ logical_and(left_op, right_op, result_op); break;
638
639 case Bytecodes::_ior:
640 case Bytecodes::_lor: __ logical_or(left_op, right_op, result_op); break;
641
642 case Bytecodes::_ixor:
643 case Bytecodes::_lxor: __ logical_xor(left_op, right_op, result_op); break;
644
645 default: ShouldNotReachHere();
646 }
647 }
648
649
650 void LIRGenerator::monitor_enter(LIR_Opr object, LIR_Opr lock, LIR_Opr hdr, LIR_Opr scratch, int monitor_no, CodeEmitInfo* info_for_exception, CodeEmitInfo* info) {
651 if (!GenerateSynchronizationCode) return;
652 // for slow path, use debug info for state after successful locking
653 CodeStub* slow_path = new MonitorEnterStub(object, lock, info);
654 __ load_stack_address_monitor(monitor_no, lock);
655 // for handling NullPointerException, use debug info representing just the lock stack before this monitorenter
656 __ lock_object(hdr, object, lock, scratch, slow_path, info_for_exception);
657 }
658
659
660 void LIRGenerator::monitor_exit(LIR_Opr object, LIR_Opr lock, LIR_Opr new_hdr, LIR_Opr scratch, int monitor_no) {
661 if (!GenerateSynchronizationCode) return;
662 // setup registers
663 LIR_Opr hdr = lock;
664 lock = new_hdr;
665 CodeStub* slow_path = new MonitorExitStub(lock, UseFastLocking, monitor_no);
666 __ load_stack_address_monitor(monitor_no, lock);
667 __ unlock_object(hdr, object, lock, scratch, slow_path);
668 }
669
670 #ifndef PRODUCT
671 void LIRGenerator::print_if_not_loaded(const NewInstance* new_instance) {
672 if (PrintNotLoaded && !new_instance->klass()->is_loaded()) {
673 tty->print_cr(" ###class not loaded at new bci %d", new_instance->printable_bci());
674 } else if (PrintNotLoaded && (TieredCompilation && new_instance->is_unresolved())) {
675 tty->print_cr(" ###class not resolved at new bci %d", new_instance->printable_bci());
676 }
677 }
678 #endif
679
680 void LIRGenerator::new_instance(LIR_Opr dst, ciInstanceKlass* klass, bool is_unresolved, LIR_Opr scratch1, LIR_Opr scratch2, LIR_Opr scratch3, LIR_Opr scratch4, LIR_Opr klass_reg, CodeEmitInfo* info) {
681 klass2reg_with_patching(klass_reg, klass, info, is_unresolved);
682 // If klass is not loaded we do not know if the klass has finalizers:
683 if (UseFastNewInstance && klass->is_loaded()
684 && !Klass::layout_helper_needs_slow_path(klass->layout_helper())) {
685
686 Runtime1::StubID stub_id = klass->is_initialized() ? Runtime1::fast_new_instance_id : Runtime1::fast_new_instance_init_check_id;
687
688 CodeStub* slow_path = new NewInstanceStub(klass_reg, dst, klass, info, stub_id);
689
690 assert(klass->is_loaded(), "must be loaded");
691 // allocate space for instance
692 assert(klass->size_helper() >= 0, "illegal instance size");
693 const int instance_size = align_object_size(klass->size_helper());
694 __ allocate_object(dst, scratch1, scratch2, scratch3, scratch4,
695 oopDesc::header_size(), instance_size, klass_reg, !klass->is_initialized(), slow_path);
696 } else {
697 CodeStub* slow_path = new NewInstanceStub(klass_reg, dst, klass, info, Runtime1::new_instance_id);
698 __ branch(lir_cond_always, T_ILLEGAL, slow_path);
699 __ branch_destination(slow_path->continuation());
700 }
701 }
702
703
704 static bool is_constant_zero(Instruction* inst) {
705 IntConstant* c = inst->type()->as_IntConstant();
706 if (c) {
707 return (c->value() == 0);
708 }
709 return false;
710 }
711
712
713 static bool positive_constant(Instruction* inst) {
714 IntConstant* c = inst->type()->as_IntConstant();
715 if (c) {
716 return (c->value() >= 0);
717 }
718 return false;
719 }
720
721
722 static ciArrayKlass* as_array_klass(ciType* type) {
723 if (type != NULL && type->is_array_klass() && type->is_loaded()) {
724 return (ciArrayKlass*)type;
725 } else {
726 return NULL;
727 }
728 }
729
730 static ciType* phi_declared_type(Phi* phi) {
731 ciType* t = phi->operand_at(0)->declared_type();
732 if (t == NULL) {
733 return NULL;
734 }
735 for(int i = 1; i < phi->operand_count(); i++) {
736 if (t != phi->operand_at(i)->declared_type()) {
737 return NULL;
738 }
739 }
740 return t;
741 }
742
743 void LIRGenerator::arraycopy_helper(Intrinsic* x, int* flagsp, ciArrayKlass** expected_typep) {
744 Instruction* src = x->argument_at(0);
745 Instruction* src_pos = x->argument_at(1);
746 Instruction* dst = x->argument_at(2);
747 Instruction* dst_pos = x->argument_at(3);
748 Instruction* length = x->argument_at(4);
749
750 // first try to identify the likely type of the arrays involved
751 ciArrayKlass* expected_type = NULL;
752 bool is_exact = false, src_objarray = false, dst_objarray = false;
753 {
754 ciArrayKlass* src_exact_type = as_array_klass(src->exact_type());
755 ciArrayKlass* src_declared_type = as_array_klass(src->declared_type());
756 Phi* phi;
757 if (src_declared_type == NULL && (phi = src->as_Phi()) != NULL) {
758 src_declared_type = as_array_klass(phi_declared_type(phi));
759 }
760 ciArrayKlass* dst_exact_type = as_array_klass(dst->exact_type());
761 ciArrayKlass* dst_declared_type = as_array_klass(dst->declared_type());
762 if (dst_declared_type == NULL && (phi = dst->as_Phi()) != NULL) {
763 dst_declared_type = as_array_klass(phi_declared_type(phi));
764 }
765
766 if (src_exact_type != NULL && src_exact_type == dst_exact_type) {
767 // the types exactly match so the type is fully known
768 is_exact = true;
769 expected_type = src_exact_type;
770 } else if (dst_exact_type != NULL && dst_exact_type->is_obj_array_klass()) {
771 ciArrayKlass* dst_type = (ciArrayKlass*) dst_exact_type;
772 ciArrayKlass* src_type = NULL;
773 if (src_exact_type != NULL && src_exact_type->is_obj_array_klass()) {
774 src_type = (ciArrayKlass*) src_exact_type;
775 } else if (src_declared_type != NULL && src_declared_type->is_obj_array_klass()) {
776 src_type = (ciArrayKlass*) src_declared_type;
777 }
778 if (src_type != NULL) {
779 if (src_type->element_type()->is_subtype_of(dst_type->element_type())) {
780 is_exact = true;
781 expected_type = dst_type;
782 }
783 }
784 }
785 // at least pass along a good guess
786 if (expected_type == NULL) expected_type = dst_exact_type;
787 if (expected_type == NULL) expected_type = src_declared_type;
788 if (expected_type == NULL) expected_type = dst_declared_type;
789
790 src_objarray = (src_exact_type && src_exact_type->is_obj_array_klass()) || (src_declared_type && src_declared_type->is_obj_array_klass());
791 dst_objarray = (dst_exact_type && dst_exact_type->is_obj_array_klass()) || (dst_declared_type && dst_declared_type->is_obj_array_klass());
792 }
793
794 // if a probable array type has been identified, figure out if any
795 // of the required checks for a fast case can be elided.
796 int flags = LIR_OpArrayCopy::all_flags;
797
798 if (!src_objarray)
799 flags &= ~LIR_OpArrayCopy::src_objarray;
800 if (!dst_objarray)
801 flags &= ~LIR_OpArrayCopy::dst_objarray;
802
803 if (!x->arg_needs_null_check(0))
804 flags &= ~LIR_OpArrayCopy::src_null_check;
805 if (!x->arg_needs_null_check(2))
806 flags &= ~LIR_OpArrayCopy::dst_null_check;
807
808
809 if (expected_type != NULL) {
810 Value length_limit = NULL;
811
812 IfOp* ifop = length->as_IfOp();
813 if (ifop != NULL) {
814 // look for expressions like min(v, a.length) which ends up as
815 // x > y ? y : x or x >= y ? y : x
816 if ((ifop->cond() == If::gtr || ifop->cond() == If::geq) &&
817 ifop->x() == ifop->fval() &&
818 ifop->y() == ifop->tval()) {
819 length_limit = ifop->y();
820 }
821 }
822
823 // try to skip null checks and range checks
824 NewArray* src_array = src->as_NewArray();
825 if (src_array != NULL) {
826 flags &= ~LIR_OpArrayCopy::src_null_check;
827 if (length_limit != NULL &&
828 src_array->length() == length_limit &&
829 is_constant_zero(src_pos)) {
830 flags &= ~LIR_OpArrayCopy::src_range_check;
831 }
832 }
833
834 NewArray* dst_array = dst->as_NewArray();
835 if (dst_array != NULL) {
836 flags &= ~LIR_OpArrayCopy::dst_null_check;
837 if (length_limit != NULL &&
838 dst_array->length() == length_limit &&
839 is_constant_zero(dst_pos)) {
840 flags &= ~LIR_OpArrayCopy::dst_range_check;
841 }
842 }
843
844 // check from incoming constant values
845 if (positive_constant(src_pos))
846 flags &= ~LIR_OpArrayCopy::src_pos_positive_check;
847 if (positive_constant(dst_pos))
848 flags &= ~LIR_OpArrayCopy::dst_pos_positive_check;
849 if (positive_constant(length))
850 flags &= ~LIR_OpArrayCopy::length_positive_check;
851
852 // see if the range check can be elided, which might also imply
853 // that src or dst is non-null.
854 ArrayLength* al = length->as_ArrayLength();
855 if (al != NULL) {
856 if (al->array() == src) {
857 // it's the length of the source array
858 flags &= ~LIR_OpArrayCopy::length_positive_check;
859 flags &= ~LIR_OpArrayCopy::src_null_check;
860 if (is_constant_zero(src_pos))
861 flags &= ~LIR_OpArrayCopy::src_range_check;
862 }
863 if (al->array() == dst) {
864 // it's the length of the destination array
865 flags &= ~LIR_OpArrayCopy::length_positive_check;
866 flags &= ~LIR_OpArrayCopy::dst_null_check;
867 if (is_constant_zero(dst_pos))
868 flags &= ~LIR_OpArrayCopy::dst_range_check;
869 }
870 }
871 if (is_exact) {
872 flags &= ~LIR_OpArrayCopy::type_check;
873 }
874 }
875
876 IntConstant* src_int = src_pos->type()->as_IntConstant();
877 IntConstant* dst_int = dst_pos->type()->as_IntConstant();
878 if (src_int && dst_int) {
879 int s_offs = src_int->value();
880 int d_offs = dst_int->value();
881 if (src_int->value() >= dst_int->value()) {
882 flags &= ~LIR_OpArrayCopy::overlapping;
883 }
884 if (expected_type != NULL) {
885 BasicType t = expected_type->element_type()->basic_type();
886 int element_size = type2aelembytes(t);
887 if (((arrayOopDesc::base_offset_in_bytes(t) + s_offs * element_size) % HeapWordSize == 0) &&
888 ((arrayOopDesc::base_offset_in_bytes(t) + d_offs * element_size) % HeapWordSize == 0)) {
889 flags &= ~LIR_OpArrayCopy::unaligned;
890 }
891 }
892 } else if (src_pos == dst_pos || is_constant_zero(dst_pos)) {
893 // src and dest positions are the same, or dst is zero so assume
894 // nonoverlapping copy.
895 flags &= ~LIR_OpArrayCopy::overlapping;
896 }
897
898 if (src == dst) {
899 // moving within a single array so no type checks are needed
900 if (flags & LIR_OpArrayCopy::type_check) {
901 flags &= ~LIR_OpArrayCopy::type_check;
902 }
903 }
904 *flagsp = flags;
905 *expected_typep = (ciArrayKlass*)expected_type;
906 }
907
908
909 LIR_Opr LIRGenerator::round_item(LIR_Opr opr) {
910 assert(opr->is_register(), "why spill if item is not register?");
911
912 if (RoundFPResults && UseSSE < 1 && opr->is_single_fpu()) {
913 LIR_Opr result = new_register(T_FLOAT);
914 set_vreg_flag(result, must_start_in_memory);
915 assert(opr->is_register(), "only a register can be spilled");
916 assert(opr->value_type()->is_float(), "rounding only for floats available");
917 __ roundfp(opr, LIR_OprFact::illegalOpr, result);
918 return result;
919 }
920 return opr;
921 }
922
923
924 LIR_Opr LIRGenerator::force_to_spill(LIR_Opr value, BasicType t) {
925 assert(type2size[t] == type2size[value->type()],
926 "size mismatch: t=%s, value->type()=%s", type2name(t), type2name(value->type()));
927 if (!value->is_register()) {
928 // force into a register
929 LIR_Opr r = new_register(value->type());
930 __ move(value, r);
931 value = r;
932 }
933
934 // create a spill location
935 LIR_Opr tmp = new_register(t);
936 set_vreg_flag(tmp, LIRGenerator::must_start_in_memory);
937
938 // move from register to spill
939 __ move(value, tmp);
940 return tmp;
941 }
942
943 void LIRGenerator::profile_branch(If* if_instr, If::Condition cond) {
944 if (if_instr->should_profile()) {
945 ciMethod* method = if_instr->profiled_method();
946 assert(method != NULL, "method should be set if branch is profiled");
947 ciMethodData* md = method->method_data_or_null();
948 assert(md != NULL, "Sanity");
949 ciProfileData* data = md->bci_to_data(if_instr->profiled_bci());
950 assert(data != NULL, "must have profiling data");
951 assert(data->is_BranchData(), "need BranchData for two-way branches");
952 int taken_count_offset = md->byte_offset_of_slot(data, BranchData::taken_offset());
953 int not_taken_count_offset = md->byte_offset_of_slot(data, BranchData::not_taken_offset());
954 if (if_instr->is_swapped()) {
955 int t = taken_count_offset;
956 taken_count_offset = not_taken_count_offset;
957 not_taken_count_offset = t;
958 }
959
960 LIR_Opr md_reg = new_register(T_METADATA);
961 __ metadata2reg(md->constant_encoding(), md_reg);
962
963 LIR_Opr data_offset_reg = new_pointer_register();
964 __ cmove(lir_cond(cond),
965 LIR_OprFact::intptrConst(taken_count_offset),
966 LIR_OprFact::intptrConst(not_taken_count_offset),
967 data_offset_reg, as_BasicType(if_instr->x()->type()));
968
969 // MDO cells are intptr_t, so the data_reg width is arch-dependent.
970 LIR_Opr data_reg = new_pointer_register();
971 LIR_Address* data_addr = new LIR_Address(md_reg, data_offset_reg, data_reg->type());
972 __ move(data_addr, data_reg);
973 // Use leal instead of add to avoid destroying condition codes on x86
974 LIR_Address* fake_incr_value = new LIR_Address(data_reg, DataLayout::counter_increment, T_INT);
975 __ leal(LIR_OprFact::address(fake_incr_value), data_reg);
976 __ move(data_reg, data_addr);
977 }
978 }
979
980 // Phi technique:
981 // This is about passing live values from one basic block to the other.
982 // In code generated with Java it is rather rare that more than one
983 // value is on the stack from one basic block to the other.
984 // We optimize our technique for efficient passing of one value
985 // (of type long, int, double..) but it can be extended.
986 // When entering or leaving a basic block, all registers and all spill
987 // slots are release and empty. We use the released registers
988 // and spill slots to pass the live values from one block
989 // to the other. The topmost value, i.e., the value on TOS of expression
990 // stack is passed in registers. All other values are stored in spilling
991 // area. Every Phi has an index which designates its spill slot
992 // At exit of a basic block, we fill the register(s) and spill slots.
993 // At entry of a basic block, the block_prolog sets up the content of phi nodes
994 // and locks necessary registers and spilling slots.
995
996
997 // move current value to referenced phi function
998 void LIRGenerator::move_to_phi(PhiResolver* resolver, Value cur_val, Value sux_val) {
999 Phi* phi = sux_val->as_Phi();
1000 // cur_val can be null without phi being null in conjunction with inlining
1001 if (phi != NULL && cur_val != NULL && cur_val != phi && !phi->is_illegal()) {
1002 Phi* cur_phi = cur_val->as_Phi();
1003 if (cur_phi != NULL && cur_phi->is_illegal()) {
1004 // Phi and local would need to get invalidated
1005 // (which is unexpected for Linear Scan).
1006 // But this case is very rare so we simply bail out.
1007 bailout("propagation of illegal phi");
1008 return;
1009 }
1010 LIR_Opr operand = cur_val->operand();
1011 if (operand->is_illegal()) {
1012 assert(cur_val->as_Constant() != NULL || cur_val->as_Local() != NULL,
1013 "these can be produced lazily");
1014 operand = operand_for_instruction(cur_val);
1015 }
1016 resolver->move(operand, operand_for_instruction(phi));
1017 }
1018 }
1019
1020
1021 // Moves all stack values into their PHI position
1022 void LIRGenerator::move_to_phi(ValueStack* cur_state) {
1023 BlockBegin* bb = block();
1024 if (bb->number_of_sux() == 1) {
1025 BlockBegin* sux = bb->sux_at(0);
1026 assert(sux->number_of_preds() > 0, "invalid CFG");
1027
1028 // a block with only one predecessor never has phi functions
1029 if (sux->number_of_preds() > 1) {
1030 int max_phis = cur_state->stack_size() + cur_state->locals_size();
1031 PhiResolver resolver(this, _virtual_register_number + max_phis * 2);
1032
1033 ValueStack* sux_state = sux->state();
1034 Value sux_value;
1035 int index;
1036
1037 assert(cur_state->scope() == sux_state->scope(), "not matching");
1038 assert(cur_state->locals_size() == sux_state->locals_size(), "not matching");
1039 assert(cur_state->stack_size() == sux_state->stack_size(), "not matching");
1040
1041 for_each_stack_value(sux_state, index, sux_value) {
1042 move_to_phi(&resolver, cur_state->stack_at(index), sux_value);
1043 }
1044
1045 for_each_local_value(sux_state, index, sux_value) {
1046 move_to_phi(&resolver, cur_state->local_at(index), sux_value);
1047 }
1048
1049 assert(cur_state->caller_state() == sux_state->caller_state(), "caller states must be equal");
1050 }
1051 }
1052 }
1053
1054
1055 LIR_Opr LIRGenerator::new_register(BasicType type) {
1056 int vreg = _virtual_register_number;
1057 // add a little fudge factor for the bailout, since the bailout is
1058 // only checked periodically. This gives a few extra registers to
1059 // hand out before we really run out, which helps us keep from
1060 // tripping over assertions.
1061 if (vreg + 20 >= LIR_OprDesc::vreg_max) {
1062 bailout("out of virtual registers");
1063 if (vreg + 2 >= LIR_OprDesc::vreg_max) {
1064 // wrap it around
1065 _virtual_register_number = LIR_OprDesc::vreg_base;
1066 }
1067 }
1068 _virtual_register_number += 1;
1069 return LIR_OprFact::virtual_register(vreg, type);
1070 }
1071
1072
1073 // Try to lock using register in hint
1074 LIR_Opr LIRGenerator::rlock(Value instr) {
1075 return new_register(instr->type());
1076 }
1077
1078
1079 // does an rlock and sets result
1080 LIR_Opr LIRGenerator::rlock_result(Value x) {
1081 LIR_Opr reg = rlock(x);
1082 set_result(x, reg);
1083 return reg;
1084 }
1085
1086
1087 // does an rlock and sets result
1088 LIR_Opr LIRGenerator::rlock_result(Value x, BasicType type) {
1089 LIR_Opr reg;
1090 switch (type) {
1091 case T_BYTE:
1092 case T_BOOLEAN:
1093 reg = rlock_byte(type);
1094 break;
1095 default:
1096 reg = rlock(x);
1097 break;
1098 }
1099
1100 set_result(x, reg);
1101 return reg;
1102 }
1103
1104
1105 //---------------------------------------------------------------------
1106 ciObject* LIRGenerator::get_jobject_constant(Value value) {
1107 ObjectType* oc = value->type()->as_ObjectType();
1108 if (oc) {
1109 return oc->constant_value();
1110 }
1111 return NULL;
1112 }
1113
1114
1115 void LIRGenerator::do_ExceptionObject(ExceptionObject* x) {
1116 assert(block()->is_set(BlockBegin::exception_entry_flag), "ExceptionObject only allowed in exception handler block");
1117 assert(block()->next() == x, "ExceptionObject must be first instruction of block");
1118
1119 // no moves are created for phi functions at the begin of exception
1120 // handlers, so assign operands manually here
1121 for_each_phi_fun(block(), phi,
1122 operand_for_instruction(phi));
1123
1124 LIR_Opr thread_reg = getThreadPointer();
1125 __ move_wide(new LIR_Address(thread_reg, in_bytes(JavaThread::exception_oop_offset()), T_OBJECT),
1126 exceptionOopOpr());
1127 __ move_wide(LIR_OprFact::oopConst(NULL),
1128 new LIR_Address(thread_reg, in_bytes(JavaThread::exception_oop_offset()), T_OBJECT));
1129 __ move_wide(LIR_OprFact::oopConst(NULL),
1130 new LIR_Address(thread_reg, in_bytes(JavaThread::exception_pc_offset()), T_OBJECT));
1131
1132 LIR_Opr result = new_register(T_OBJECT);
1133 __ move(exceptionOopOpr(), result);
1134 set_result(x, result);
1135 }
1136
1137
1138 //----------------------------------------------------------------------
1139 //----------------------------------------------------------------------
1140 //----------------------------------------------------------------------
1141 //----------------------------------------------------------------------
1142 // visitor functions
1143 //----------------------------------------------------------------------
1144 //----------------------------------------------------------------------
1145 //----------------------------------------------------------------------
1146 //----------------------------------------------------------------------
1147
1148 void LIRGenerator::do_Phi(Phi* x) {
1149 // phi functions are never visited directly
1150 ShouldNotReachHere();
1151 }
1152
1153
1154 // Code for a constant is generated lazily unless the constant is frequently used and can't be inlined.
1155 void LIRGenerator::do_Constant(Constant* x) {
1156 if (x->state_before() != NULL) {
1157 // Any constant with a ValueStack requires patching so emit the patch here
1158 LIR_Opr reg = rlock_result(x);
1159 CodeEmitInfo* info = state_for(x, x->state_before());
1160 __ oop2reg_patch(NULL, reg, info);
1161 } else if (x->use_count() > 1 && !can_inline_as_constant(x)) {
1162 if (!x->is_pinned()) {
1163 // unpinned constants are handled specially so that they can be
1164 // put into registers when they are used multiple times within a
1165 // block. After the block completes their operand will be
1166 // cleared so that other blocks can't refer to that register.
1167 set_result(x, load_constant(x));
1168 } else {
1169 LIR_Opr res = x->operand();
1170 if (!res->is_valid()) {
1171 res = LIR_OprFact::value_type(x->type());
1172 }
1173 if (res->is_constant()) {
1174 LIR_Opr reg = rlock_result(x);
1175 __ move(res, reg);
1176 } else {
1177 set_result(x, res);
1178 }
1179 }
1180 } else {
1181 set_result(x, LIR_OprFact::value_type(x->type()));
1182 }
1183 }
1184
1185
1186 void LIRGenerator::do_Local(Local* x) {
1187 // operand_for_instruction has the side effect of setting the result
1188 // so there's no need to do it here.
1189 operand_for_instruction(x);
1190 }
1191
1192
1193 void LIRGenerator::do_IfInstanceOf(IfInstanceOf* x) {
1194 Unimplemented();
1195 }
1196
1197
1198 void LIRGenerator::do_Return(Return* x) {
1199 if (compilation()->env()->dtrace_method_probes()) {
1200 BasicTypeList signature;
1201 signature.append(LP64_ONLY(T_LONG) NOT_LP64(T_INT)); // thread
1202 signature.append(T_METADATA); // Method*
1203 LIR_OprList* args = new LIR_OprList();
1204 args->append(getThreadPointer());
1205 LIR_Opr meth = new_register(T_METADATA);
1206 __ metadata2reg(method()->constant_encoding(), meth);
1207 args->append(meth);
1208 call_runtime(&signature, args, CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_exit), voidType, NULL);
1209 }
1210
1211 if (x->type()->is_void()) {
1212 __ return_op(LIR_OprFact::illegalOpr);
1213 } else {
1214 LIR_Opr reg = result_register_for(x->type(), /*callee=*/true);
1215 LIRItem result(x->result(), this);
1216
1217 result.load_item_force(reg);
1218 __ return_op(result.result());
1219 }
1220 set_no_result(x);
1221 }
1222
1223 // Examble: ref.get()
1224 // Combination of LoadField and g1 pre-write barrier
1225 void LIRGenerator::do_Reference_get(Intrinsic* x) {
1226
1227 const int referent_offset = java_lang_ref_Reference::referent_offset;
1228 guarantee(referent_offset > 0, "referent offset not initialized");
1229
1230 assert(x->number_of_arguments() == 1, "wrong type");
1231
1232 LIRItem reference(x->argument_at(0), this);
1233 reference.load_item();
1234
1235 // need to perform the null check on the reference objecy
1236 CodeEmitInfo* info = NULL;
1237 if (x->needs_null_check()) {
1238 info = state_for(x);
1239 }
1240
1241 LIR_Address* referent_field_adr =
1242 new LIR_Address(reference.result(), referent_offset, T_OBJECT);
1243
1244 LIR_Opr result = rlock_result(x);
1245
1246 __ load(referent_field_adr, result, info);
1247
1248 // Register the value in the referent field with the pre-barrier
1249 pre_barrier(LIR_OprFact::illegalOpr /* addr_opr */,
1250 result /* pre_val */,
1251 false /* do_load */,
1252 false /* patch */,
1253 NULL /* info */);
1254 }
1255
1256 // Example: clazz.isInstance(object)
1257 void LIRGenerator::do_isInstance(Intrinsic* x) {
1258 assert(x->number_of_arguments() == 2, "wrong type");
1259
1260 // TODO could try to substitute this node with an equivalent InstanceOf
1261 // if clazz is known to be a constant Class. This will pick up newly found
1262 // constants after HIR construction. I'll leave this to a future change.
1263
1264 // as a first cut, make a simple leaf call to runtime to stay platform independent.
1265 // could follow the aastore example in a future change.
1266
1267 LIRItem clazz(x->argument_at(0), this);
1268 LIRItem object(x->argument_at(1), this);
1269 clazz.load_item();
1270 object.load_item();
1271 LIR_Opr result = rlock_result(x);
1272
1273 // need to perform null check on clazz
1274 if (x->needs_null_check()) {
1275 CodeEmitInfo* info = state_for(x);
1276 __ null_check(clazz.result(), info);
1277 }
1278
1279 LIR_Opr call_result = call_runtime(clazz.value(), object.value(),
1280 CAST_FROM_FN_PTR(address, Runtime1::is_instance_of),
1281 x->type(),
1282 NULL); // NULL CodeEmitInfo results in a leaf call
1283 __ move(call_result, result);
1284 }
1285
1286 // Example: object.getClass ()
1287 void LIRGenerator::do_getClass(Intrinsic* x) {
1288 assert(x->number_of_arguments() == 1, "wrong type");
1289
1290 LIRItem rcvr(x->argument_at(0), this);
1291 rcvr.load_item();
1292 LIR_Opr temp = new_register(T_METADATA);
1293 LIR_Opr result = rlock_result(x);
1294
1295 // need to perform the null check on the rcvr
1296 CodeEmitInfo* info = NULL;
1297 if (x->needs_null_check()) {
1298 info = state_for(x);
1299 }
1300
1301 // FIXME T_ADDRESS should actually be T_METADATA but it can't because the
1302 // meaning of these two is mixed up (see JDK-8026837).
1303 __ move(new LIR_Address(rcvr.result(), oopDesc::klass_offset_in_bytes(), T_ADDRESS), temp, info);
1304 __ move_wide(new LIR_Address(temp, in_bytes(Klass::java_mirror_offset()), T_OBJECT), result);
1305 }
1306
1307 // java.lang.Class::isPrimitive()
1308 void LIRGenerator::do_isPrimitive(Intrinsic* x) {
1309 assert(x->number_of_arguments() == 1, "wrong type");
1310
1311 LIRItem rcvr(x->argument_at(0), this);
1312 rcvr.load_item();
1313 LIR_Opr temp = new_register(T_METADATA);
1314 LIR_Opr result = rlock_result(x);
1315
1316 CodeEmitInfo* info = NULL;
1317 if (x->needs_null_check()) {
1318 info = state_for(x);
1319 }
1320
1321 __ move(new LIR_Address(rcvr.result(), java_lang_Class::klass_offset_in_bytes(), T_ADDRESS), temp, info);
1322 __ cmp(lir_cond_notEqual, temp, LIR_OprFact::intConst(0));
1323 __ cmove(lir_cond_notEqual, LIR_OprFact::intConst(0), LIR_OprFact::intConst(1), result, T_BOOLEAN);
1324 }
1325
1326
1327 // Example: Thread.currentThread()
1328 void LIRGenerator::do_currentThread(Intrinsic* x) {
1329 assert(x->number_of_arguments() == 0, "wrong type");
1330 LIR_Opr reg = rlock_result(x);
1331 __ move_wide(new LIR_Address(getThreadPointer(), in_bytes(JavaThread::threadObj_offset()), T_OBJECT), reg);
1332 }
1333
1334
1335 void LIRGenerator::do_RegisterFinalizer(Intrinsic* x) {
1336 assert(x->number_of_arguments() == 1, "wrong type");
1337 LIRItem receiver(x->argument_at(0), this);
1338
1339 receiver.load_item();
1340 BasicTypeList signature;
1341 signature.append(T_OBJECT); // receiver
1342 LIR_OprList* args = new LIR_OprList();
1343 args->append(receiver.result());
1344 CodeEmitInfo* info = state_for(x, x->state());
1345 call_runtime(&signature, args,
1346 CAST_FROM_FN_PTR(address, Runtime1::entry_for(Runtime1::register_finalizer_id)),
1347 voidType, info);
1348
1349 set_no_result(x);
1350 }
1351
1352
1353 //------------------------local access--------------------------------------
1354
1355 LIR_Opr LIRGenerator::operand_for_instruction(Instruction* x) {
1356 if (x->operand()->is_illegal()) {
1357 Constant* c = x->as_Constant();
1358 if (c != NULL) {
1359 x->set_operand(LIR_OprFact::value_type(c->type()));
1360 } else {
1361 assert(x->as_Phi() || x->as_Local() != NULL, "only for Phi and Local");
1362 // allocate a virtual register for this local or phi
1363 x->set_operand(rlock(x));
1364 _instruction_for_operand.at_put_grow(x->operand()->vreg_number(), x, NULL);
1365 }
1366 }
1367 return x->operand();
1368 }
1369
1370
1371 Instruction* LIRGenerator::instruction_for_opr(LIR_Opr opr) {
1372 if (opr->is_virtual()) {
1373 return instruction_for_vreg(opr->vreg_number());
1374 }
1375 return NULL;
1376 }
1377
1378
1379 Instruction* LIRGenerator::instruction_for_vreg(int reg_num) {
1380 if (reg_num < _instruction_for_operand.length()) {
1381 return _instruction_for_operand.at(reg_num);
1382 }
1383 return NULL;
1384 }
1385
1386
1387 void LIRGenerator::set_vreg_flag(int vreg_num, VregFlag f) {
1388 if (_vreg_flags.size_in_bits() == 0) {
1389 BitMap2D temp(100, num_vreg_flags);
1390 _vreg_flags = temp;
1391 }
1392 _vreg_flags.at_put_grow(vreg_num, f, true);
1393 }
1394
1395 bool LIRGenerator::is_vreg_flag_set(int vreg_num, VregFlag f) {
1396 if (!_vreg_flags.is_valid_index(vreg_num, f)) {
1397 return false;
1398 }
1399 return _vreg_flags.at(vreg_num, f);
1400 }
1401
1402
1403 // Block local constant handling. This code is useful for keeping
1404 // unpinned constants and constants which aren't exposed in the IR in
1405 // registers. Unpinned Constant instructions have their operands
1406 // cleared when the block is finished so that other blocks can't end
1407 // up referring to their registers.
1408
1409 LIR_Opr LIRGenerator::load_constant(Constant* x) {
1410 assert(!x->is_pinned(), "only for unpinned constants");
1411 _unpinned_constants.append(x);
1412 return load_constant(LIR_OprFact::value_type(x->type())->as_constant_ptr());
1413 }
1414
1415
1416 LIR_Opr LIRGenerator::load_constant(LIR_Const* c) {
1417 BasicType t = c->type();
1418 for (int i = 0; i < _constants.length(); i++) {
1419 LIR_Const* other = _constants.at(i);
1420 if (t == other->type()) {
1421 switch (t) {
1422 case T_INT:
1423 case T_FLOAT:
1424 if (c->as_jint_bits() != other->as_jint_bits()) continue;
1425 break;
1426 case T_LONG:
1427 case T_DOUBLE:
1428 if (c->as_jint_hi_bits() != other->as_jint_hi_bits()) continue;
1429 if (c->as_jint_lo_bits() != other->as_jint_lo_bits()) continue;
1430 break;
1431 case T_OBJECT:
1432 if (c->as_jobject() != other->as_jobject()) continue;
1433 break;
1434 }
1435 return _reg_for_constants.at(i);
1436 }
1437 }
1438
1439 LIR_Opr result = new_register(t);
1440 __ move((LIR_Opr)c, result);
1441 _constants.append(c);
1442 _reg_for_constants.append(result);
1443 return result;
1444 }
1445
1446 // Various barriers
1447
1448 void LIRGenerator::pre_barrier(LIR_Opr addr_opr, LIR_Opr pre_val,
1449 bool do_load, bool patch, CodeEmitInfo* info) {
1450 // Do the pre-write barrier, if any.
1451 switch (_bs->kind()) {
1452 #if INCLUDE_ALL_GCS
1453 case BarrierSet::G1SATBCTLogging:
1454 G1SATBCardTableModRef_pre_barrier(addr_opr, pre_val, do_load, patch, info);
1455 break;
1456 #endif // INCLUDE_ALL_GCS
1457 case BarrierSet::CardTableForRS:
1458 case BarrierSet::CardTableExtension:
1459 // No pre barriers
1460 break;
1461 case BarrierSet::ModRef:
1462 // No pre barriers
1463 break;
1464 default :
1465 ShouldNotReachHere();
1466
1467 }
1468 }
1469
1470 void LIRGenerator::post_barrier(LIR_OprDesc* addr, LIR_OprDesc* new_val) {
1471 switch (_bs->kind()) {
1472 #if INCLUDE_ALL_GCS
1473 case BarrierSet::G1SATBCTLogging:
1474 G1SATBCardTableModRef_post_barrier(addr, new_val);
1475 break;
1476 #endif // INCLUDE_ALL_GCS
1477 case BarrierSet::CardTableForRS:
1478 case BarrierSet::CardTableExtension:
1479 CardTableModRef_post_barrier(addr, new_val);
1480 break;
1481 case BarrierSet::ModRef:
1482 // No post barriers
1483 break;
1484 default :
1485 ShouldNotReachHere();
1486 }
1487 }
1488
1489 ////////////////////////////////////////////////////////////////////////
1490 #if INCLUDE_ALL_GCS
1491
1492 void LIRGenerator::G1SATBCardTableModRef_pre_barrier(LIR_Opr addr_opr, LIR_Opr pre_val,
1493 bool do_load, bool patch, CodeEmitInfo* info) {
1494 // First we test whether marking is in progress.
1495 BasicType flag_type;
1496 if (in_bytes(SATBMarkQueue::byte_width_of_active()) == 4) {
1497 flag_type = T_INT;
1498 } else {
1499 guarantee(in_bytes(SATBMarkQueue::byte_width_of_active()) == 1,
1500 "Assumption");
1501 // Use unsigned type T_BOOLEAN here rather than signed T_BYTE since some platforms, eg. ARM,
1502 // need to use unsigned instructions to use the large offset to load the satb_mark_queue.
1503 flag_type = T_BOOLEAN;
1504 }
1505 LIR_Opr thrd = getThreadPointer();
1506 LIR_Address* mark_active_flag_addr =
1507 new LIR_Address(thrd,
1508 in_bytes(JavaThread::satb_mark_queue_offset() +
1509 SATBMarkQueue::byte_offset_of_active()),
1510 flag_type);
1511 // Read the marking-in-progress flag.
1512 LIR_Opr flag_val = new_register(T_INT);
1513 __ load(mark_active_flag_addr, flag_val);
1514 __ cmp(lir_cond_notEqual, flag_val, LIR_OprFact::intConst(0));
1515
1516 LIR_PatchCode pre_val_patch_code = lir_patch_none;
1517
1518 CodeStub* slow;
1519
1520 if (do_load) {
1521 assert(pre_val == LIR_OprFact::illegalOpr, "sanity");
1522 assert(addr_opr != LIR_OprFact::illegalOpr, "sanity");
1523
1524 if (patch)
1525 pre_val_patch_code = lir_patch_normal;
1526
1527 pre_val = new_register(T_OBJECT);
1528
1529 if (!addr_opr->is_address()) {
1530 assert(addr_opr->is_register(), "must be");
1531 addr_opr = LIR_OprFact::address(new LIR_Address(addr_opr, T_OBJECT));
1532 }
1533 slow = new G1PreBarrierStub(addr_opr, pre_val, pre_val_patch_code, info);
1534 } else {
1535 assert(addr_opr == LIR_OprFact::illegalOpr, "sanity");
1536 assert(pre_val->is_register(), "must be");
1537 assert(pre_val->type() == T_OBJECT, "must be an object");
1538 assert(info == NULL, "sanity");
1539
1540 slow = new G1PreBarrierStub(pre_val);
1541 }
1542
1543 __ branch(lir_cond_notEqual, T_INT, slow);
1544 __ branch_destination(slow->continuation());
1545 }
1546
1547 void LIRGenerator::G1SATBCardTableModRef_post_barrier(LIR_OprDesc* addr, LIR_OprDesc* new_val) {
1548 // If the "new_val" is a constant NULL, no barrier is necessary.
1549 if (new_val->is_constant() &&
1550 new_val->as_constant_ptr()->as_jobject() == NULL) return;
1551
1552 if (!new_val->is_register()) {
1553 LIR_Opr new_val_reg = new_register(T_OBJECT);
1554 if (new_val->is_constant()) {
1555 __ move(new_val, new_val_reg);
1556 } else {
1557 __ leal(new_val, new_val_reg);
1558 }
1559 new_val = new_val_reg;
1560 }
1561 assert(new_val->is_register(), "must be a register at this point");
1562
1563 if (addr->is_address()) {
1564 LIR_Address* address = addr->as_address_ptr();
1565 LIR_Opr ptr = new_pointer_register();
1566 if (!address->index()->is_valid() && address->disp() == 0) {
1567 __ move(address->base(), ptr);
1568 } else {
1569 assert(address->disp() != max_jint, "lea doesn't support patched addresses!");
1570 __ leal(addr, ptr);
1571 }
1572 addr = ptr;
1573 }
1574 assert(addr->is_register(), "must be a register at this point");
1575
1576 LIR_Opr xor_res = new_pointer_register();
1577 LIR_Opr xor_shift_res = new_pointer_register();
1578 if (TwoOperandLIRForm ) {
1579 __ move(addr, xor_res);
1580 __ logical_xor(xor_res, new_val, xor_res);
1581 __ move(xor_res, xor_shift_res);
1582 __ unsigned_shift_right(xor_shift_res,
1583 LIR_OprFact::intConst(HeapRegion::LogOfHRGrainBytes),
1584 xor_shift_res,
1585 LIR_OprDesc::illegalOpr());
1586 } else {
1587 __ logical_xor(addr, new_val, xor_res);
1588 __ unsigned_shift_right(xor_res,
1589 LIR_OprFact::intConst(HeapRegion::LogOfHRGrainBytes),
1590 xor_shift_res,
1591 LIR_OprDesc::illegalOpr());
1592 }
1593
1594 if (!new_val->is_register()) {
1595 LIR_Opr new_val_reg = new_register(T_OBJECT);
1596 __ leal(new_val, new_val_reg);
1597 new_val = new_val_reg;
1598 }
1599 assert(new_val->is_register(), "must be a register at this point");
1600
1601 __ cmp(lir_cond_notEqual, xor_shift_res, LIR_OprFact::intptrConst(NULL_WORD));
1602
1603 CodeStub* slow = new G1PostBarrierStub(addr, new_val);
1604 __ branch(lir_cond_notEqual, LP64_ONLY(T_LONG) NOT_LP64(T_INT), slow);
1605 __ branch_destination(slow->continuation());
1606 }
1607
1608 #endif // INCLUDE_ALL_GCS
1609 ////////////////////////////////////////////////////////////////////////
1610
1611 void LIRGenerator::CardTableModRef_post_barrier(LIR_OprDesc* addr, LIR_OprDesc* new_val) {
1612 CardTableModRefBS* ct = barrier_set_cast<CardTableModRefBS>(_bs);
1613 assert(sizeof(*(ct->byte_map_base)) == sizeof(jbyte), "adjust this code");
1614 LIR_Const* card_table_base = new LIR_Const(ct->byte_map_base);
1615 if (addr->is_address()) {
1616 LIR_Address* address = addr->as_address_ptr();
1617 // ptr cannot be an object because we use this barrier for array card marks
1618 // and addr can point in the middle of an array.
1619 LIR_Opr ptr = new_pointer_register();
1620 if (!address->index()->is_valid() && address->disp() == 0) {
1621 __ move(address->base(), ptr);
1622 } else {
1623 assert(address->disp() != max_jint, "lea doesn't support patched addresses!");
1624 __ leal(addr, ptr);
1625 }
1626 addr = ptr;
1627 }
1628 assert(addr->is_register(), "must be a register at this point");
1629
1630 #ifdef CARDTABLEMODREF_POST_BARRIER_HELPER
1631 CardTableModRef_post_barrier_helper(addr, card_table_base);
1632 #else
1633 LIR_Opr tmp = new_pointer_register();
1634 if (TwoOperandLIRForm) {
1635 __ move(addr, tmp);
1636 __ unsigned_shift_right(tmp, CardTableModRefBS::card_shift, tmp);
1637 } else {
1638 __ unsigned_shift_right(addr, CardTableModRefBS::card_shift, tmp);
1639 }
1640
1641 LIR_Address* card_addr;
1642 if (can_inline_as_constant(card_table_base)) {
1643 card_addr = new LIR_Address(tmp, card_table_base->as_jint(), T_BYTE);
1644 } else {
1645 card_addr = new LIR_Address(tmp, load_constant(card_table_base), T_BYTE);
1646 }
1647
1648 LIR_Opr dirty = LIR_OprFact::intConst(CardTableModRefBS::dirty_card_val());
1649 if (UseCondCardMark) {
1650 LIR_Opr cur_value = new_register(T_INT);
1651 if (UseConcMarkSweepGC) {
1652 __ membar_storeload();
1653 }
1654 __ move(card_addr, cur_value);
1655
1656 LabelObj* L_already_dirty = new LabelObj();
1657 __ cmp(lir_cond_equal, cur_value, dirty);
1658 __ branch(lir_cond_equal, T_BYTE, L_already_dirty->label());
1659 __ move(dirty, card_addr);
1660 __ branch_destination(L_already_dirty->label());
1661 } else {
1662 if (UseConcMarkSweepGC && CMSPrecleaningEnabled) {
1663 __ membar_storestore();
1664 }
1665 __ move(dirty, card_addr);
1666 }
1667 #endif
1668 }
1669
1670
1671 //------------------------field access--------------------------------------
1672
1673 // Comment copied form templateTable_i486.cpp
1674 // ----------------------------------------------------------------------------
1675 // Volatile variables demand their effects be made known to all CPU's in
1676 // order. Store buffers on most chips allow reads & writes to reorder; the
1677 // JMM's ReadAfterWrite.java test fails in -Xint mode without some kind of
1678 // memory barrier (i.e., it's not sufficient that the interpreter does not
1679 // reorder volatile references, the hardware also must not reorder them).
1680 //
1681 // According to the new Java Memory Model (JMM):
1682 // (1) All volatiles are serialized wrt to each other.
1683 // ALSO reads & writes act as aquire & release, so:
1684 // (2) A read cannot let unrelated NON-volatile memory refs that happen after
1685 // the read float up to before the read. It's OK for non-volatile memory refs
1686 // that happen before the volatile read to float down below it.
1687 // (3) Similar a volatile write cannot let unrelated NON-volatile memory refs
1688 // that happen BEFORE the write float down to after the write. It's OK for
1689 // non-volatile memory refs that happen after the volatile write to float up
1690 // before it.
1691 //
1692 // We only put in barriers around volatile refs (they are expensive), not
1693 // _between_ memory refs (that would require us to track the flavor of the
1694 // previous memory refs). Requirements (2) and (3) require some barriers
1695 // before volatile stores and after volatile loads. These nearly cover
1696 // requirement (1) but miss the volatile-store-volatile-load case. This final
1697 // case is placed after volatile-stores although it could just as well go
1698 // before volatile-loads.
1699
1700
1701 void LIRGenerator::do_StoreField(StoreField* x) {
1702 bool needs_patching = x->needs_patching();
1703 bool is_volatile = x->field()->is_volatile();
1704 BasicType field_type = x->field_type();
1705 bool is_oop = (field_type == T_ARRAY || field_type == T_OBJECT);
1706
1707 CodeEmitInfo* info = NULL;
1708 if (needs_patching) {
1709 assert(x->explicit_null_check() == NULL, "can't fold null check into patching field access");
1710 info = state_for(x, x->state_before());
1711 } else if (x->needs_null_check()) {
1712 NullCheck* nc = x->explicit_null_check();
1713 if (nc == NULL) {
1714 info = state_for(x);
1715 } else {
1716 info = state_for(nc);
1717 }
1718 }
1719
1720
1721 LIRItem object(x->obj(), this);
1722 LIRItem value(x->value(), this);
1723
1724 object.load_item();
1725
1726 if (is_volatile || needs_patching) {
1727 // load item if field is volatile (fewer special cases for volatiles)
1728 // load item if field not initialized
1729 // load item if field not constant
1730 // because of code patching we cannot inline constants
1731 if (field_type == T_BYTE || field_type == T_BOOLEAN) {
1732 value.load_byte_item();
1733 } else {
1734 value.load_item();
1735 }
1736 } else {
1737 value.load_for_store(field_type);
1738 }
1739
1740 set_no_result(x);
1741
1742 #ifndef PRODUCT
1743 if (PrintNotLoaded && needs_patching) {
1744 tty->print_cr(" ###class not loaded at store_%s bci %d",
1745 x->is_static() ? "static" : "field", x->printable_bci());
1746 }
1747 #endif
1748
1749 if (x->needs_null_check() &&
1750 (needs_patching ||
1751 MacroAssembler::needs_explicit_null_check(x->offset()))) {
1752 // emit an explicit null check because the offset is too large
1753 __ null_check(object.result(), new CodeEmitInfo(info));
1754 }
1755
1756 LIR_Address* address;
1757 if (needs_patching) {
1758 // we need to patch the offset in the instruction so don't allow
1759 // generate_address to try to be smart about emitting the -1.
1760 // Otherwise the patching code won't know how to find the
1761 // instruction to patch.
1762 address = new LIR_Address(object.result(), PATCHED_ADDR, field_type);
1763 } else {
1764 address = generate_address(object.result(), x->offset(), field_type);
1765 }
1766
1767 if (is_volatile && os::is_MP()) {
1768 __ membar_release();
1769 }
1770
1771 if (is_oop) {
1772 // Do the pre-write barrier, if any.
1773 pre_barrier(LIR_OprFact::address(address),
1774 LIR_OprFact::illegalOpr /* pre_val */,
1775 true /* do_load*/,
1776 needs_patching,
1777 (info ? new CodeEmitInfo(info) : NULL));
1778 }
1779
1780 bool needs_atomic_access = is_volatile || AlwaysAtomicAccesses;
1781 if (needs_atomic_access && !needs_patching) {
1782 volatile_field_store(value.result(), address, info);
1783 } else {
1784 LIR_PatchCode patch_code = needs_patching ? lir_patch_normal : lir_patch_none;
1785 __ store(value.result(), address, info, patch_code);
1786 }
1787
1788 if (is_oop) {
1789 // Store to object so mark the card of the header
1790 post_barrier(object.result(), value.result());
1791 }
1792
1793 if (!support_IRIW_for_not_multiple_copy_atomic_cpu && is_volatile && os::is_MP()) {
1794 __ membar();
1795 }
1796 }
1797
1798
1799 void LIRGenerator::do_LoadField(LoadField* x) {
1800 bool needs_patching = x->needs_patching();
1801 bool is_volatile = x->field()->is_volatile();
1802 BasicType field_type = x->field_type();
1803
1804 CodeEmitInfo* info = NULL;
1805 if (needs_patching) {
1806 assert(x->explicit_null_check() == NULL, "can't fold null check into patching field access");
1807 info = state_for(x, x->state_before());
1808 } else if (x->needs_null_check()) {
1809 NullCheck* nc = x->explicit_null_check();
1810 if (nc == NULL) {
1811 info = state_for(x);
1812 } else {
1813 info = state_for(nc);
1814 }
1815 }
1816
1817 LIRItem object(x->obj(), this);
1818
1819 object.load_item();
1820
1821 #ifndef PRODUCT
1822 if (PrintNotLoaded && needs_patching) {
1823 tty->print_cr(" ###class not loaded at load_%s bci %d",
1824 x->is_static() ? "static" : "field", x->printable_bci());
1825 }
1826 #endif
1827
1828 bool stress_deopt = StressLoopInvariantCodeMotion && info && info->deoptimize_on_exception();
1829 if (x->needs_null_check() &&
1830 (needs_patching ||
1831 MacroAssembler::needs_explicit_null_check(x->offset()) ||
1832 stress_deopt)) {
1833 LIR_Opr obj = object.result();
1834 if (stress_deopt) {
1835 obj = new_register(T_OBJECT);
1836 __ move(LIR_OprFact::oopConst(NULL), obj);
1837 }
1838 // emit an explicit null check because the offset is too large
1839 __ null_check(obj, new CodeEmitInfo(info));
1840 }
1841
1842 LIR_Opr reg = rlock_result(x, field_type);
1843 LIR_Address* address;
1844 if (needs_patching) {
1845 // we need to patch the offset in the instruction so don't allow
1846 // generate_address to try to be smart about emitting the -1.
1847 // Otherwise the patching code won't know how to find the
1848 // instruction to patch.
1849 address = new LIR_Address(object.result(), PATCHED_ADDR, field_type);
1850 } else {
1851 address = generate_address(object.result(), x->offset(), field_type);
1852 }
1853
1854 if (support_IRIW_for_not_multiple_copy_atomic_cpu && is_volatile && os::is_MP()) {
1855 __ membar();
1856 }
1857
1858 bool needs_atomic_access = is_volatile || AlwaysAtomicAccesses;
1859 if (needs_atomic_access && !needs_patching) {
1860 volatile_field_load(address, reg, info);
1861 } else {
1862 LIR_PatchCode patch_code = needs_patching ? lir_patch_normal : lir_patch_none;
1863 __ load(address, reg, info, patch_code);
1864 }
1865
1866 if (is_volatile && os::is_MP()) {
1867 __ membar_acquire();
1868 }
1869 }
1870
1871
1872 //------------------------java.nio.Buffer.checkIndex------------------------
1873
1874 // int java.nio.Buffer.checkIndex(int)
1875 void LIRGenerator::do_NIOCheckIndex(Intrinsic* x) {
1876 // NOTE: by the time we are in checkIndex() we are guaranteed that
1877 // the buffer is non-null (because checkIndex is package-private and
1878 // only called from within other methods in the buffer).
1879 assert(x->number_of_arguments() == 2, "wrong type");
1880 LIRItem buf (x->argument_at(0), this);
1881 LIRItem index(x->argument_at(1), this);
1882 buf.load_item();
1883 index.load_item();
1884
1885 LIR_Opr result = rlock_result(x);
1886 if (GenerateRangeChecks) {
1887 CodeEmitInfo* info = state_for(x);
1888 CodeStub* stub = new RangeCheckStub(info, index.result(), true);
1889 if (index.result()->is_constant()) {
1890 cmp_mem_int(lir_cond_belowEqual, buf.result(), java_nio_Buffer::limit_offset(), index.result()->as_jint(), info);
1891 __ branch(lir_cond_belowEqual, T_INT, stub);
1892 } else {
1893 cmp_reg_mem(lir_cond_aboveEqual, index.result(), buf.result(),
1894 java_nio_Buffer::limit_offset(), T_INT, info);
1895 __ branch(lir_cond_aboveEqual, T_INT, stub);
1896 }
1897 __ move(index.result(), result);
1898 } else {
1899 // Just load the index into the result register
1900 __ move(index.result(), result);
1901 }
1902 }
1903
1904
1905 //------------------------array access--------------------------------------
1906
1907
1908 void LIRGenerator::do_ArrayLength(ArrayLength* x) {
1909 LIRItem array(x->array(), this);
1910 array.load_item();
1911 LIR_Opr reg = rlock_result(x);
1912
1913 CodeEmitInfo* info = NULL;
1914 if (x->needs_null_check()) {
1915 NullCheck* nc = x->explicit_null_check();
1916 if (nc == NULL) {
1917 info = state_for(x);
1918 } else {
1919 info = state_for(nc);
1920 }
1921 if (StressLoopInvariantCodeMotion && info->deoptimize_on_exception()) {
1922 LIR_Opr obj = new_register(T_OBJECT);
1923 __ move(LIR_OprFact::oopConst(NULL), obj);
1924 __ null_check(obj, new CodeEmitInfo(info));
1925 }
1926 }
1927 __ load(new LIR_Address(array.result(), arrayOopDesc::length_offset_in_bytes(), T_INT), reg, info, lir_patch_none);
1928 }
1929
1930
1931 void LIRGenerator::do_LoadIndexed(LoadIndexed* x) {
1932 bool use_length = x->length() != NULL;
1933 LIRItem array(x->array(), this);
1934 LIRItem index(x->index(), this);
1935 LIRItem length(this);
1936 bool needs_range_check = x->compute_needs_range_check();
1937
1938 if (use_length && needs_range_check) {
1939 length.set_instruction(x->length());
1940 length.load_item();
1941 }
1942
1943 array.load_item();
1944 if (index.is_constant() && can_inline_as_constant(x->index())) {
1945 // let it be a constant
1946 index.dont_load_item();
1947 } else {
1948 index.load_item();
1949 }
1950
1951 CodeEmitInfo* range_check_info = state_for(x);
1952 CodeEmitInfo* null_check_info = NULL;
1953 if (x->needs_null_check()) {
1954 NullCheck* nc = x->explicit_null_check();
1955 if (nc != NULL) {
1956 null_check_info = state_for(nc);
1957 } else {
1958 null_check_info = range_check_info;
1959 }
1960 if (StressLoopInvariantCodeMotion && null_check_info->deoptimize_on_exception()) {
1961 LIR_Opr obj = new_register(T_OBJECT);
1962 __ move(LIR_OprFact::oopConst(NULL), obj);
1963 __ null_check(obj, new CodeEmitInfo(null_check_info));
1964 }
1965 }
1966
1967 // emit array address setup early so it schedules better
1968 LIR_Address* array_addr = emit_array_address(array.result(), index.result(), x->elt_type(), false);
1969
1970 if (GenerateRangeChecks && needs_range_check) {
1971 if (StressLoopInvariantCodeMotion && range_check_info->deoptimize_on_exception()) {
1972 __ branch(lir_cond_always, T_ILLEGAL, new RangeCheckStub(range_check_info, index.result()));
1973 } else if (use_length) {
1974 // TODO: use a (modified) version of array_range_check that does not require a
1975 // constant length to be loaded to a register
1976 __ cmp(lir_cond_belowEqual, length.result(), index.result());
1977 __ branch(lir_cond_belowEqual, T_INT, new RangeCheckStub(range_check_info, index.result()));
1978 } else {
1979 array_range_check(array.result(), index.result(), null_check_info, range_check_info);
1980 // The range check performs the null check, so clear it out for the load
1981 null_check_info = NULL;
1982 }
1983 }
1984
1985 __ move(array_addr, rlock_result(x, x->elt_type()), null_check_info);
1986 }
1987
1988
1989 void LIRGenerator::do_NullCheck(NullCheck* x) {
1990 if (x->can_trap()) {
1991 LIRItem value(x->obj(), this);
1992 value.load_item();
1993 CodeEmitInfo* info = state_for(x);
1994 __ null_check(value.result(), info);
1995 }
1996 }
1997
1998
1999 void LIRGenerator::do_TypeCast(TypeCast* x) {
2000 LIRItem value(x->obj(), this);
2001 value.load_item();
2002 // the result is the same as from the node we are casting
2003 set_result(x, value.result());
2004 }
2005
2006
2007 void LIRGenerator::do_Throw(Throw* x) {
2008 LIRItem exception(x->exception(), this);
2009 exception.load_item();
2010 set_no_result(x);
2011 LIR_Opr exception_opr = exception.result();
2012 CodeEmitInfo* info = state_for(x, x->state());
2013
2014 #ifndef PRODUCT
2015 if (PrintC1Statistics) {
2016 increment_counter(Runtime1::throw_count_address(), T_INT);
2017 }
2018 #endif
2019
2020 // check if the instruction has an xhandler in any of the nested scopes
2021 bool unwind = false;
2022 if (info->exception_handlers()->length() == 0) {
2023 // this throw is not inside an xhandler
2024 unwind = true;
2025 } else {
2026 // get some idea of the throw type
2027 bool type_is_exact = true;
2028 ciType* throw_type = x->exception()->exact_type();
2029 if (throw_type == NULL) {
2030 type_is_exact = false;
2031 throw_type = x->exception()->declared_type();
2032 }
2033 if (throw_type != NULL && throw_type->is_instance_klass()) {
2034 ciInstanceKlass* throw_klass = (ciInstanceKlass*)throw_type;
2035 unwind = !x->exception_handlers()->could_catch(throw_klass, type_is_exact);
2036 }
2037 }
2038
2039 // do null check before moving exception oop into fixed register
2040 // to avoid a fixed interval with an oop during the null check.
2041 // Use a copy of the CodeEmitInfo because debug information is
2042 // different for null_check and throw.
2043 if (x->exception()->as_NewInstance() == NULL && x->exception()->as_ExceptionObject() == NULL) {
2044 // if the exception object wasn't created using new then it might be null.
2045 __ null_check(exception_opr, new CodeEmitInfo(info, x->state()->copy(ValueStack::ExceptionState, x->state()->bci())));
2046 }
2047
2048 if (compilation()->env()->jvmti_can_post_on_exceptions()) {
2049 // we need to go through the exception lookup path to get JVMTI
2050 // notification done
2051 unwind = false;
2052 }
2053
2054 // move exception oop into fixed register
2055 __ move(exception_opr, exceptionOopOpr());
2056
2057 if (unwind) {
2058 __ unwind_exception(exceptionOopOpr());
2059 } else {
2060 __ throw_exception(exceptionPcOpr(), exceptionOopOpr(), info);
2061 }
2062 }
2063
2064
2065 void LIRGenerator::do_RoundFP(RoundFP* x) {
2066 LIRItem input(x->input(), this);
2067 input.load_item();
2068 LIR_Opr input_opr = input.result();
2069 assert(input_opr->is_register(), "why round if value is not in a register?");
2070 assert(input_opr->is_single_fpu() || input_opr->is_double_fpu(), "input should be floating-point value");
2071 if (input_opr->is_single_fpu()) {
2072 set_result(x, round_item(input_opr)); // This code path not currently taken
2073 } else {
2074 LIR_Opr result = new_register(T_DOUBLE);
2075 set_vreg_flag(result, must_start_in_memory);
2076 __ roundfp(input_opr, LIR_OprFact::illegalOpr, result);
2077 set_result(x, result);
2078 }
2079 }
2080
2081 // Here UnsafeGetRaw may have x->base() and x->index() be int or long
2082 // on both 64 and 32 bits. Expecting x->base() to be always long on 64bit.
2083 void LIRGenerator::do_UnsafeGetRaw(UnsafeGetRaw* x) {
2084 LIRItem base(x->base(), this);
2085 LIRItem idx(this);
2086
2087 base.load_item();
2088 if (x->has_index()) {
2089 idx.set_instruction(x->index());
2090 idx.load_nonconstant();
2091 }
2092
2093 LIR_Opr reg = rlock_result(x, x->basic_type());
2094
2095 int log2_scale = 0;
2096 if (x->has_index()) {
2097 log2_scale = x->log2_scale();
2098 }
2099
2100 assert(!x->has_index() || idx.value() == x->index(), "should match");
2101
2102 LIR_Opr base_op = base.result();
2103 LIR_Opr index_op = idx.result();
2104 #ifndef _LP64
2105 if (base_op->type() == T_LONG) {
2106 base_op = new_register(T_INT);
2107 __ convert(Bytecodes::_l2i, base.result(), base_op);
2108 }
2109 if (x->has_index()) {
2110 if (index_op->type() == T_LONG) {
2111 LIR_Opr long_index_op = index_op;
2112 if (index_op->is_constant()) {
2113 long_index_op = new_register(T_LONG);
2114 __ move(index_op, long_index_op);
2115 }
2116 index_op = new_register(T_INT);
2117 __ convert(Bytecodes::_l2i, long_index_op, index_op);
2118 } else {
2119 assert(x->index()->type()->tag() == intTag, "must be");
2120 }
2121 }
2122 // At this point base and index should be all ints.
2123 assert(base_op->type() == T_INT && !base_op->is_constant(), "base should be an non-constant int");
2124 assert(!x->has_index() || index_op->type() == T_INT, "index should be an int");
2125 #else
2126 if (x->has_index()) {
2127 if (index_op->type() == T_INT) {
2128 if (!index_op->is_constant()) {
2129 index_op = new_register(T_LONG);
2130 __ convert(Bytecodes::_i2l, idx.result(), index_op);
2131 }
2132 } else {
2133 assert(index_op->type() == T_LONG, "must be");
2134 if (index_op->is_constant()) {
2135 index_op = new_register(T_LONG);
2136 __ move(idx.result(), index_op);
2137 }
2138 }
2139 }
2140 // At this point base is a long non-constant
2141 // Index is a long register or a int constant.
2142 // We allow the constant to stay an int because that would allow us a more compact encoding by
2143 // embedding an immediate offset in the address expression. If we have a long constant, we have to
2144 // move it into a register first.
2145 assert(base_op->type() == T_LONG && !base_op->is_constant(), "base must be a long non-constant");
2146 assert(!x->has_index() || (index_op->type() == T_INT && index_op->is_constant()) ||
2147 (index_op->type() == T_LONG && !index_op->is_constant()), "unexpected index type");
2148 #endif
2149
2150 BasicType dst_type = x->basic_type();
2151
2152 LIR_Address* addr;
2153 if (index_op->is_constant()) {
2154 assert(log2_scale == 0, "must not have a scale");
2155 assert(index_op->type() == T_INT, "only int constants supported");
2156 addr = new LIR_Address(base_op, index_op->as_jint(), dst_type);
2157 } else {
2158 #ifdef X86
2159 addr = new LIR_Address(base_op, index_op, LIR_Address::Scale(log2_scale), 0, dst_type);
2160 #elif defined(GENERATE_ADDRESS_IS_PREFERRED)
2161 addr = generate_address(base_op, index_op, log2_scale, 0, dst_type);
2162 #else
2163 if (index_op->is_illegal() || log2_scale == 0) {
2164 addr = new LIR_Address(base_op, index_op, dst_type);
2165 } else {
2166 LIR_Opr tmp = new_pointer_register();
2167 __ shift_left(index_op, log2_scale, tmp);
2168 addr = new LIR_Address(base_op, tmp, dst_type);
2169 }
2170 #endif
2171 }
2172
2173 if (x->may_be_unaligned() && (dst_type == T_LONG || dst_type == T_DOUBLE)) {
2174 __ unaligned_move(addr, reg);
2175 } else {
2176 if (dst_type == T_OBJECT && x->is_wide()) {
2177 __ move_wide(addr, reg);
2178 } else {
2179 __ move(addr, reg);
2180 }
2181 }
2182 }
2183
2184
2185 void LIRGenerator::do_UnsafePutRaw(UnsafePutRaw* x) {
2186 int log2_scale = 0;
2187 BasicType type = x->basic_type();
2188
2189 if (x->has_index()) {
2190 log2_scale = x->log2_scale();
2191 }
2192
2193 LIRItem base(x->base(), this);
2194 LIRItem value(x->value(), this);
2195 LIRItem idx(this);
2196
2197 base.load_item();
2198 if (x->has_index()) {
2199 idx.set_instruction(x->index());
2200 idx.load_item();
2201 }
2202
2203 if (type == T_BYTE || type == T_BOOLEAN) {
2204 value.load_byte_item();
2205 } else {
2206 value.load_item();
2207 }
2208
2209 set_no_result(x);
2210
2211 LIR_Opr base_op = base.result();
2212 LIR_Opr index_op = idx.result();
2213
2214 #ifdef GENERATE_ADDRESS_IS_PREFERRED
2215 LIR_Address* addr = generate_address(base_op, index_op, log2_scale, 0, x->basic_type());
2216 #else
2217 #ifndef _LP64
2218 if (base_op->type() == T_LONG) {
2219 base_op = new_register(T_INT);
2220 __ convert(Bytecodes::_l2i, base.result(), base_op);
2221 }
2222 if (x->has_index()) {
2223 if (index_op->type() == T_LONG) {
2224 index_op = new_register(T_INT);
2225 __ convert(Bytecodes::_l2i, idx.result(), index_op);
2226 }
2227 }
2228 // At this point base and index should be all ints and not constants
2229 assert(base_op->type() == T_INT && !base_op->is_constant(), "base should be an non-constant int");
2230 assert(!x->has_index() || (index_op->type() == T_INT && !index_op->is_constant()), "index should be an non-constant int");
2231 #else
2232 if (x->has_index()) {
2233 if (index_op->type() == T_INT) {
2234 index_op = new_register(T_LONG);
2235 __ convert(Bytecodes::_i2l, idx.result(), index_op);
2236 }
2237 }
2238 // At this point base and index are long and non-constant
2239 assert(base_op->type() == T_LONG && !base_op->is_constant(), "base must be a non-constant long");
2240 assert(!x->has_index() || (index_op->type() == T_LONG && !index_op->is_constant()), "index must be a non-constant long");
2241 #endif
2242
2243 if (log2_scale != 0) {
2244 // temporary fix (platform dependent code without shift on Intel would be better)
2245 // TODO: ARM also allows embedded shift in the address
2246 LIR_Opr tmp = new_pointer_register();
2247 if (TwoOperandLIRForm) {
2248 __ move(index_op, tmp);
2249 index_op = tmp;
2250 }
2251 __ shift_left(index_op, log2_scale, tmp);
2252 if (!TwoOperandLIRForm) {
2253 index_op = tmp;
2254 }
2255 }
2256
2257 LIR_Address* addr = new LIR_Address(base_op, index_op, x->basic_type());
2258 #endif // !GENERATE_ADDRESS_IS_PREFERRED
2259 __ move(value.result(), addr);
2260 }
2261
2262
2263 void LIRGenerator::do_UnsafeGetObject(UnsafeGetObject* x) {
2264 BasicType type = x->basic_type();
2265 LIRItem src(x->object(), this);
2266 LIRItem off(x->offset(), this);
2267
2268 off.load_item();
2269 src.load_item();
2270
2271 LIR_Opr value = rlock_result(x, x->basic_type());
2272
2273 if (support_IRIW_for_not_multiple_copy_atomic_cpu && x->is_volatile() && os::is_MP()) {
2274 __ membar();
2275 }
2276
2277 get_Object_unsafe(value, src.result(), off.result(), type, x->is_volatile());
2278
2279 #if INCLUDE_ALL_GCS
2280 // We might be reading the value of the referent field of a
2281 // Reference object in order to attach it back to the live
2282 // object graph. If G1 is enabled then we need to record
2283 // the value that is being returned in an SATB log buffer.
2284 //
2285 // We need to generate code similar to the following...
2286 //
2287 // if (offset == java_lang_ref_Reference::referent_offset) {
2288 // if (src != NULL) {
2289 // if (klass(src)->reference_type() != REF_NONE) {
2290 // pre_barrier(..., value, ...);
2291 // }
2292 // }
2293 // }
2294
2295 if (UseG1GC && type == T_OBJECT) {
2296 bool gen_pre_barrier = true; // Assume we need to generate pre_barrier.
2297 bool gen_offset_check = true; // Assume we need to generate the offset guard.
2298 bool gen_source_check = true; // Assume we need to check the src object for null.
2299 bool gen_type_check = true; // Assume we need to check the reference_type.
2300
2301 if (off.is_constant()) {
2302 jlong off_con = (off.type()->is_int() ?
2303 (jlong) off.get_jint_constant() :
2304 off.get_jlong_constant());
2305
2306
2307 if (off_con != (jlong) java_lang_ref_Reference::referent_offset) {
2308 // The constant offset is something other than referent_offset.
2309 // We can skip generating/checking the remaining guards and
2310 // skip generation of the code stub.
2311 gen_pre_barrier = false;
2312 } else {
2313 // The constant offset is the same as referent_offset -
2314 // we do not need to generate a runtime offset check.
2315 gen_offset_check = false;
2316 }
2317 }
2318
2319 // We don't need to generate stub if the source object is an array
2320 if (gen_pre_barrier && src.type()->is_array()) {
2321 gen_pre_barrier = false;
2322 }
2323
2324 if (gen_pre_barrier) {
2325 // We still need to continue with the checks.
2326 if (src.is_constant()) {
2327 ciObject* src_con = src.get_jobject_constant();
2328 guarantee(src_con != NULL, "no source constant");
2329
2330 if (src_con->is_null_object()) {
2331 // The constant src object is null - We can skip
2332 // generating the code stub.
2333 gen_pre_barrier = false;
2334 } else {
2335 // Non-null constant source object. We still have to generate
2336 // the slow stub - but we don't need to generate the runtime
2337 // null object check.
2338 gen_source_check = false;
2339 }
2340 }
2341 }
2342 if (gen_pre_barrier && !PatchALot) {
2343 // Can the klass of object be statically determined to be
2344 // a sub-class of Reference?
2345 ciType* type = src.value()->declared_type();
2346 if ((type != NULL) && type->is_loaded()) {
2347 if (type->is_subtype_of(compilation()->env()->Reference_klass())) {
2348 gen_type_check = false;
2349 } else if (type->is_klass() &&
2350 !compilation()->env()->Object_klass()->is_subtype_of(type->as_klass())) {
2351 // Not Reference and not Object klass.
2352 gen_pre_barrier = false;
2353 }
2354 }
2355 }
2356
2357 if (gen_pre_barrier) {
2358 LabelObj* Lcont = new LabelObj();
2359
2360 // We can have generate one runtime check here. Let's start with
2361 // the offset check.
2362 if (gen_offset_check) {
2363 // if (offset != referent_offset) -> continue
2364 // If offset is an int then we can do the comparison with the
2365 // referent_offset constant; otherwise we need to move
2366 // referent_offset into a temporary register and generate
2367 // a reg-reg compare.
2368
2369 LIR_Opr referent_off;
2370
2371 if (off.type()->is_int()) {
2372 referent_off = LIR_OprFact::intConst(java_lang_ref_Reference::referent_offset);
2373 } else {
2374 assert(off.type()->is_long(), "what else?");
2375 referent_off = new_register(T_LONG);
2376 __ move(LIR_OprFact::longConst(java_lang_ref_Reference::referent_offset), referent_off);
2377 }
2378 __ cmp(lir_cond_notEqual, off.result(), referent_off);
2379 __ branch(lir_cond_notEqual, as_BasicType(off.type()), Lcont->label());
2380 }
2381 if (gen_source_check) {
2382 // offset is a const and equals referent offset
2383 // if (source == null) -> continue
2384 __ cmp(lir_cond_equal, src.result(), LIR_OprFact::oopConst(NULL));
2385 __ branch(lir_cond_equal, T_OBJECT, Lcont->label());
2386 }
2387 LIR_Opr src_klass = new_register(T_OBJECT);
2388 if (gen_type_check) {
2389 // We have determined that offset == referent_offset && src != null.
2390 // if (src->_klass->_reference_type == REF_NONE) -> continue
2391 __ move(new LIR_Address(src.result(), oopDesc::klass_offset_in_bytes(), T_ADDRESS), src_klass);
2392 LIR_Address* reference_type_addr = new LIR_Address(src_klass, in_bytes(InstanceKlass::reference_type_offset()), T_BYTE);
2393 LIR_Opr reference_type = new_register(T_INT);
2394 __ move(reference_type_addr, reference_type);
2395 __ cmp(lir_cond_equal, reference_type, LIR_OprFact::intConst(REF_NONE));
2396 __ branch(lir_cond_equal, T_INT, Lcont->label());
2397 }
2398 {
2399 // We have determined that src->_klass->_reference_type != REF_NONE
2400 // so register the value in the referent field with the pre-barrier.
2401 pre_barrier(LIR_OprFact::illegalOpr /* addr_opr */,
2402 value /* pre_val */,
2403 false /* do_load */,
2404 false /* patch */,
2405 NULL /* info */);
2406 }
2407 __ branch_destination(Lcont->label());
2408 }
2409 }
2410 #endif // INCLUDE_ALL_GCS
2411
2412 if (x->is_volatile() && os::is_MP()) __ membar_acquire();
2413
2414 /* Normalize boolean value returned by unsafe operation, i.e., value != 0 ? value = true : value false. */
2415 if (type == T_BOOLEAN) {
2416 LabelObj* equalZeroLabel = new LabelObj();
2417 __ cmp(lir_cond_equal, value, 0);
2418 __ branch(lir_cond_equal, T_BOOLEAN, equalZeroLabel->label());
2419 __ move(LIR_OprFact::intConst(1), value);
2420 __ branch_destination(equalZeroLabel->label());
2421 }
2422 }
2423
2424
2425 void LIRGenerator::do_UnsafePutObject(UnsafePutObject* x) {
2426 BasicType type = x->basic_type();
2427 LIRItem src(x->object(), this);
2428 LIRItem off(x->offset(), this);
2429 LIRItem data(x->value(), this);
2430
2431 src.load_item();
2432 if (type == T_BOOLEAN || type == T_BYTE) {
2433 data.load_byte_item();
2434 } else {
2435 data.load_item();
2436 }
2437 off.load_item();
2438
2439 set_no_result(x);
2440
2441 if (x->is_volatile() && os::is_MP()) __ membar_release();
2442 put_Object_unsafe(src.result(), off.result(), data.result(), type, x->is_volatile());
2443 if (!support_IRIW_for_not_multiple_copy_atomic_cpu && x->is_volatile() && os::is_MP()) __ membar();
2444 }
2445
2446
2447 void LIRGenerator::do_SwitchRanges(SwitchRangeArray* x, LIR_Opr value, BlockBegin* default_sux) {
2448 int lng = x->length();
2449
2450 for (int i = 0; i < lng; i++) {
2451 SwitchRange* one_range = x->at(i);
2452 int low_key = one_range->low_key();
2453 int high_key = one_range->high_key();
2454 BlockBegin* dest = one_range->sux();
2455 if (low_key == high_key) {
2456 __ cmp(lir_cond_equal, value, low_key);
2457 __ branch(lir_cond_equal, T_INT, dest);
2458 } else if (high_key - low_key == 1) {
2459 __ cmp(lir_cond_equal, value, low_key);
2460 __ branch(lir_cond_equal, T_INT, dest);
2461 __ cmp(lir_cond_equal, value, high_key);
2462 __ branch(lir_cond_equal, T_INT, dest);
2463 } else {
2464 LabelObj* L = new LabelObj();
2465 __ cmp(lir_cond_less, value, low_key);
2466 __ branch(lir_cond_less, T_INT, L->label());
2467 __ cmp(lir_cond_lessEqual, value, high_key);
2468 __ branch(lir_cond_lessEqual, T_INT, dest);
2469 __ branch_destination(L->label());
2470 }
2471 }
2472 __ jump(default_sux);
2473 }
2474
2475
2476 SwitchRangeArray* LIRGenerator::create_lookup_ranges(TableSwitch* x) {
2477 SwitchRangeList* res = new SwitchRangeList();
2478 int len = x->length();
2479 if (len > 0) {
2480 BlockBegin* sux = x->sux_at(0);
2481 int key = x->lo_key();
2482 BlockBegin* default_sux = x->default_sux();
2483 SwitchRange* range = new SwitchRange(key, sux);
2484 for (int i = 0; i < len; i++, key++) {
2485 BlockBegin* new_sux = x->sux_at(i);
2486 if (sux == new_sux) {
2487 // still in same range
2488 range->set_high_key(key);
2489 } else {
2490 // skip tests which explicitly dispatch to the default
2491 if (sux != default_sux) {
2492 res->append(range);
2493 }
2494 range = new SwitchRange(key, new_sux);
2495 }
2496 sux = new_sux;
2497 }
2498 if (res->length() == 0 || res->last() != range) res->append(range);
2499 }
2500 return res;
2501 }
2502
2503
2504 // we expect the keys to be sorted by increasing value
2505 SwitchRangeArray* LIRGenerator::create_lookup_ranges(LookupSwitch* x) {
2506 SwitchRangeList* res = new SwitchRangeList();
2507 int len = x->length();
2508 if (len > 0) {
2509 BlockBegin* default_sux = x->default_sux();
2510 int key = x->key_at(0);
2511 BlockBegin* sux = x->sux_at(0);
2512 SwitchRange* range = new SwitchRange(key, sux);
2513 for (int i = 1; i < len; i++) {
2514 int new_key = x->key_at(i);
2515 BlockBegin* new_sux = x->sux_at(i);
2516 if (key+1 == new_key && sux == new_sux) {
2517 // still in same range
2518 range->set_high_key(new_key);
2519 } else {
2520 // skip tests which explicitly dispatch to the default
2521 if (range->sux() != default_sux) {
2522 res->append(range);
2523 }
2524 range = new SwitchRange(new_key, new_sux);
2525 }
2526 key = new_key;
2527 sux = new_sux;
2528 }
2529 if (res->length() == 0 || res->last() != range) res->append(range);
2530 }
2531 return res;
2532 }
2533
2534
2535 void LIRGenerator::do_TableSwitch(TableSwitch* x) {
2536 LIRItem tag(x->tag(), this);
2537 tag.load_item();
2538 set_no_result(x);
2539
2540 if (x->is_safepoint()) {
2541 __ safepoint(safepoint_poll_register(), state_for(x, x->state_before()));
2542 }
2543
2544 // move values into phi locations
2545 move_to_phi(x->state());
2546
2547 int lo_key = x->lo_key();
2548 int hi_key = x->hi_key();
2549 int len = x->length();
2550 LIR_Opr value = tag.result();
2551 if (UseTableRanges) {
2552 do_SwitchRanges(create_lookup_ranges(x), value, x->default_sux());
2553 } else {
2554 for (int i = 0; i < len; i++) {
2555 __ cmp(lir_cond_equal, value, i + lo_key);
2556 __ branch(lir_cond_equal, T_INT, x->sux_at(i));
2557 }
2558 __ jump(x->default_sux());
2559 }
2560 }
2561
2562
2563 void LIRGenerator::do_LookupSwitch(LookupSwitch* x) {
2564 LIRItem tag(x->tag(), this);
2565 tag.load_item();
2566 set_no_result(x);
2567
2568 if (x->is_safepoint()) {
2569 __ safepoint(safepoint_poll_register(), state_for(x, x->state_before()));
2570 }
2571
2572 // move values into phi locations
2573 move_to_phi(x->state());
2574
2575 LIR_Opr value = tag.result();
2576 if (UseTableRanges) {
2577 do_SwitchRanges(create_lookup_ranges(x), value, x->default_sux());
2578 } else {
2579 int len = x->length();
2580 for (int i = 0; i < len; i++) {
2581 __ cmp(lir_cond_equal, value, x->key_at(i));
2582 __ branch(lir_cond_equal, T_INT, x->sux_at(i));
2583 }
2584 __ jump(x->default_sux());
2585 }
2586 }
2587
2588
2589 void LIRGenerator::do_Goto(Goto* x) {
2590 set_no_result(x);
2591
2592 if (block()->next()->as_OsrEntry()) {
2593 // need to free up storage used for OSR entry point
2594 LIR_Opr osrBuffer = block()->next()->operand();
2595 BasicTypeList signature;
2596 signature.append(NOT_LP64(T_INT) LP64_ONLY(T_LONG)); // pass a pointer to osrBuffer
2597 CallingConvention* cc = frame_map()->c_calling_convention(&signature);
2598 __ move(osrBuffer, cc->args()->at(0));
2599 __ call_runtime_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::OSR_migration_end),
2600 getThreadTemp(), LIR_OprFact::illegalOpr, cc->args());
2601 }
2602
2603 if (x->is_safepoint()) {
2604 ValueStack* state = x->state_before() ? x->state_before() : x->state();
2605
2606 // increment backedge counter if needed
2607 CodeEmitInfo* info = state_for(x, state);
2608 increment_backedge_counter(info, x->profiled_bci());
2609 CodeEmitInfo* safepoint_info = state_for(x, state);
2610 __ safepoint(safepoint_poll_register(), safepoint_info);
2611 }
2612
2613 // Gotos can be folded Ifs, handle this case.
2614 if (x->should_profile()) {
2615 ciMethod* method = x->profiled_method();
2616 assert(method != NULL, "method should be set if branch is profiled");
2617 ciMethodData* md = method->method_data_or_null();
2618 assert(md != NULL, "Sanity");
2619 ciProfileData* data = md->bci_to_data(x->profiled_bci());
2620 assert(data != NULL, "must have profiling data");
2621 int offset;
2622 if (x->direction() == Goto::taken) {
2623 assert(data->is_BranchData(), "need BranchData for two-way branches");
2624 offset = md->byte_offset_of_slot(data, BranchData::taken_offset());
2625 } else if (x->direction() == Goto::not_taken) {
2626 assert(data->is_BranchData(), "need BranchData for two-way branches");
2627 offset = md->byte_offset_of_slot(data, BranchData::not_taken_offset());
2628 } else {
2629 assert(data->is_JumpData(), "need JumpData for branches");
2630 offset = md->byte_offset_of_slot(data, JumpData::taken_offset());
2631 }
2632 LIR_Opr md_reg = new_register(T_METADATA);
2633 __ metadata2reg(md->constant_encoding(), md_reg);
2634
2635 increment_counter(new LIR_Address(md_reg, offset,
2636 NOT_LP64(T_INT) LP64_ONLY(T_LONG)), DataLayout::counter_increment);
2637 }
2638
2639 // emit phi-instruction move after safepoint since this simplifies
2640 // describing the state as the safepoint.
2641 move_to_phi(x->state());
2642
2643 __ jump(x->default_sux());
2644 }
2645
2646 /**
2647 * Emit profiling code if needed for arguments, parameters, return value types
2648 *
2649 * @param md MDO the code will update at runtime
2650 * @param md_base_offset common offset in the MDO for this profile and subsequent ones
2651 * @param md_offset offset in the MDO (on top of md_base_offset) for this profile
2652 * @param profiled_k current profile
2653 * @param obj IR node for the object to be profiled
2654 * @param mdp register to hold the pointer inside the MDO (md + md_base_offset).
2655 * Set once we find an update to make and use for next ones.
2656 * @param not_null true if we know obj cannot be null
2657 * @param signature_at_call_k signature at call for obj
2658 * @param callee_signature_k signature of callee for obj
2659 * at call and callee signatures differ at method handle call
2660 * @return the only klass we know will ever be seen at this profile point
2661 */
2662 ciKlass* LIRGenerator::profile_type(ciMethodData* md, int md_base_offset, int md_offset, intptr_t profiled_k,
2663 Value obj, LIR_Opr& mdp, bool not_null, ciKlass* signature_at_call_k,
2664 ciKlass* callee_signature_k) {
2665 ciKlass* result = NULL;
2666 bool do_null = !not_null && !TypeEntries::was_null_seen(profiled_k);
2667 bool do_update = !TypeEntries::is_type_unknown(profiled_k);
2668 // known not to be null or null bit already set and already set to
2669 // unknown: nothing we can do to improve profiling
2670 if (!do_null && !do_update) {
2671 return result;
2672 }
2673
2674 ciKlass* exact_klass = NULL;
2675 Compilation* comp = Compilation::current();
2676 if (do_update) {
2677 // try to find exact type, using CHA if possible, so that loading
2678 // the klass from the object can be avoided
2679 ciType* type = obj->exact_type();
2680 if (type == NULL) {
2681 type = obj->declared_type();
2682 type = comp->cha_exact_type(type);
2683 }
2684 assert(type == NULL || type->is_klass(), "type should be class");
2685 exact_klass = (type != NULL && type->is_loaded()) ? (ciKlass*)type : NULL;
2686
2687 do_update = exact_klass == NULL || ciTypeEntries::valid_ciklass(profiled_k) != exact_klass;
2688 }
2689
2690 if (!do_null && !do_update) {
2691 return result;
2692 }
2693
2694 ciKlass* exact_signature_k = NULL;
2695 if (do_update) {
2696 // Is the type from the signature exact (the only one possible)?
2697 exact_signature_k = signature_at_call_k->exact_klass();
2698 if (exact_signature_k == NULL) {
2699 exact_signature_k = comp->cha_exact_type(signature_at_call_k);
2700 } else {
2701 result = exact_signature_k;
2702 // Known statically. No need to emit any code: prevent
2703 // LIR_Assembler::emit_profile_type() from emitting useless code
2704 profiled_k = ciTypeEntries::with_status(result, profiled_k);
2705 }
2706 // exact_klass and exact_signature_k can be both non NULL but
2707 // different if exact_klass is loaded after the ciObject for
2708 // exact_signature_k is created.
2709 if (exact_klass == NULL && exact_signature_k != NULL && exact_klass != exact_signature_k) {
2710 // sometimes the type of the signature is better than the best type
2711 // the compiler has
2712 exact_klass = exact_signature_k;
2713 }
2714 if (callee_signature_k != NULL &&
2715 callee_signature_k != signature_at_call_k) {
2716 ciKlass* improved_klass = callee_signature_k->exact_klass();
2717 if (improved_klass == NULL) {
2718 improved_klass = comp->cha_exact_type(callee_signature_k);
2719 }
2720 if (exact_klass == NULL && improved_klass != NULL && exact_klass != improved_klass) {
2721 exact_klass = exact_signature_k;
2722 }
2723 }
2724 do_update = exact_klass == NULL || ciTypeEntries::valid_ciklass(profiled_k) != exact_klass;
2725 }
2726
2727 if (!do_null && !do_update) {
2728 return result;
2729 }
2730
2731 if (mdp == LIR_OprFact::illegalOpr) {
2732 mdp = new_register(T_METADATA);
2733 __ metadata2reg(md->constant_encoding(), mdp);
2734 if (md_base_offset != 0) {
2735 LIR_Address* base_type_address = new LIR_Address(mdp, md_base_offset, T_ADDRESS);
2736 mdp = new_pointer_register();
2737 __ leal(LIR_OprFact::address(base_type_address), mdp);
2738 }
2739 }
2740 LIRItem value(obj, this);
2741 value.load_item();
2742 __ profile_type(new LIR_Address(mdp, md_offset, T_METADATA),
2743 value.result(), exact_klass, profiled_k, new_pointer_register(), not_null, exact_signature_k != NULL);
2744 return result;
2745 }
2746
2747 // profile parameters on entry to the root of the compilation
2748 void LIRGenerator::profile_parameters(Base* x) {
2749 if (compilation()->profile_parameters()) {
2750 CallingConvention* args = compilation()->frame_map()->incoming_arguments();
2751 ciMethodData* md = scope()->method()->method_data_or_null();
2752 assert(md != NULL, "Sanity");
2753
2754 if (md->parameters_type_data() != NULL) {
2755 ciParametersTypeData* parameters_type_data = md->parameters_type_data();
2756 ciTypeStackSlotEntries* parameters = parameters_type_data->parameters();
2757 LIR_Opr mdp = LIR_OprFact::illegalOpr;
2758 for (int java_index = 0, i = 0, j = 0; j < parameters_type_data->number_of_parameters(); i++) {
2759 LIR_Opr src = args->at(i);
2760 assert(!src->is_illegal(), "check");
2761 BasicType t = src->type();
2762 if (t == T_OBJECT || t == T_ARRAY) {
2763 intptr_t profiled_k = parameters->type(j);
2764 Local* local = x->state()->local_at(java_index)->as_Local();
2765 ciKlass* exact = profile_type(md, md->byte_offset_of_slot(parameters_type_data, ParametersTypeData::type_offset(0)),
2766 in_bytes(ParametersTypeData::type_offset(j)) - in_bytes(ParametersTypeData::type_offset(0)),
2767 profiled_k, local, mdp, false, local->declared_type()->as_klass(), NULL);
2768 // If the profile is known statically set it once for all and do not emit any code
2769 if (exact != NULL) {
2770 md->set_parameter_type(j, exact);
2771 }
2772 j++;
2773 }
2774 java_index += type2size[t];
2775 }
2776 }
2777 }
2778 }
2779
2780 void LIRGenerator::do_Base(Base* x) {
2781 __ std_entry(LIR_OprFact::illegalOpr);
2782 // Emit moves from physical registers / stack slots to virtual registers
2783 CallingConvention* args = compilation()->frame_map()->incoming_arguments();
2784 IRScope* irScope = compilation()->hir()->top_scope();
2785 int java_index = 0;
2786 for (int i = 0; i < args->length(); i++) {
2787 LIR_Opr src = args->at(i);
2788 assert(!src->is_illegal(), "check");
2789 BasicType t = src->type();
2790
2791 // Types which are smaller than int are passed as int, so
2792 // correct the type which passed.
2793 switch (t) {
2794 case T_BYTE:
2795 case T_BOOLEAN:
2796 case T_SHORT:
2797 case T_CHAR:
2798 t = T_INT;
2799 break;
2800 }
2801
2802 LIR_Opr dest = new_register(t);
2803 __ move(src, dest);
2804
2805 // Assign new location to Local instruction for this local
2806 Local* local = x->state()->local_at(java_index)->as_Local();
2807 assert(local != NULL, "Locals for incoming arguments must have been created");
2808 #ifndef __SOFTFP__
2809 // The java calling convention passes double as long and float as int.
2810 assert(as_ValueType(t)->tag() == local->type()->tag(), "check");
2811 #endif // __SOFTFP__
2812 local->set_operand(dest);
2813 _instruction_for_operand.at_put_grow(dest->vreg_number(), local, NULL);
2814 java_index += type2size[t];
2815 }
2816
2817 if (compilation()->env()->dtrace_method_probes()) {
2818 BasicTypeList signature;
2819 signature.append(LP64_ONLY(T_LONG) NOT_LP64(T_INT)); // thread
2820 signature.append(T_METADATA); // Method*
2821 LIR_OprList* args = new LIR_OprList();
2822 args->append(getThreadPointer());
2823 LIR_Opr meth = new_register(T_METADATA);
2824 __ metadata2reg(method()->constant_encoding(), meth);
2825 args->append(meth);
2826 call_runtime(&signature, args, CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_entry), voidType, NULL);
2827 }
2828
2829 if (method()->is_synchronized()) {
2830 LIR_Opr obj;
2831 if (method()->is_static()) {
2832 obj = new_register(T_OBJECT);
2833 __ oop2reg(method()->holder()->java_mirror()->constant_encoding(), obj);
2834 } else {
2835 Local* receiver = x->state()->local_at(0)->as_Local();
2836 assert(receiver != NULL, "must already exist");
2837 obj = receiver->operand();
2838 }
2839 assert(obj->is_valid(), "must be valid");
2840
2841 if (method()->is_synchronized() && GenerateSynchronizationCode) {
2842 LIR_Opr lock = syncLockOpr();
2843 __ load_stack_address_monitor(0, lock);
2844
2845 CodeEmitInfo* info = new CodeEmitInfo(scope()->start()->state()->copy(ValueStack::StateBefore, SynchronizationEntryBCI), NULL, x->check_flag(Instruction::DeoptimizeOnException));
2846 CodeStub* slow_path = new MonitorEnterStub(obj, lock, info);
2847
2848 // receiver is guaranteed non-NULL so don't need CodeEmitInfo
2849 __ lock_object(syncTempOpr(), obj, lock, new_register(T_OBJECT), slow_path, NULL);
2850 }
2851 }
2852 if (compilation()->age_code()) {
2853 CodeEmitInfo* info = new CodeEmitInfo(scope()->start()->state()->copy(ValueStack::StateBefore, 0), NULL, false);
2854 decrement_age(info);
2855 }
2856 // increment invocation counters if needed
2857 if (!method()->is_accessor()) { // Accessors do not have MDOs, so no counting.
2858 profile_parameters(x);
2859 CodeEmitInfo* info = new CodeEmitInfo(scope()->start()->state()->copy(ValueStack::StateBefore, SynchronizationEntryBCI), NULL, false);
2860 increment_invocation_counter(info);
2861 }
2862
2863 // all blocks with a successor must end with an unconditional jump
2864 // to the successor even if they are consecutive
2865 __ jump(x->default_sux());
2866 }
2867
2868
2869 void LIRGenerator::do_OsrEntry(OsrEntry* x) {
2870 // construct our frame and model the production of incoming pointer
2871 // to the OSR buffer.
2872 __ osr_entry(LIR_Assembler::osrBufferPointer());
2873 LIR_Opr result = rlock_result(x);
2874 __ move(LIR_Assembler::osrBufferPointer(), result);
2875 }
2876
2877
2878 void LIRGenerator::invoke_load_arguments(Invoke* x, LIRItemList* args, const LIR_OprList* arg_list) {
2879 assert(args->length() == arg_list->length(),
2880 "args=%d, arg_list=%d", args->length(), arg_list->length());
2881 for (int i = x->has_receiver() ? 1 : 0; i < args->length(); i++) {
2882 LIRItem* param = args->at(i);
2883 LIR_Opr loc = arg_list->at(i);
2884 if (loc->is_register()) {
2885 param->load_item_force(loc);
2886 } else {
2887 LIR_Address* addr = loc->as_address_ptr();
2888 param->load_for_store(addr->type());
2889 if (addr->type() == T_OBJECT) {
2890 __ move_wide(param->result(), addr);
2891 } else
2892 if (addr->type() == T_LONG || addr->type() == T_DOUBLE) {
2893 __ unaligned_move(param->result(), addr);
2894 } else {
2895 __ move(param->result(), addr);
2896 }
2897 }
2898 }
2899
2900 if (x->has_receiver()) {
2901 LIRItem* receiver = args->at(0);
2902 LIR_Opr loc = arg_list->at(0);
2903 if (loc->is_register()) {
2904 receiver->load_item_force(loc);
2905 } else {
2906 assert(loc->is_address(), "just checking");
2907 receiver->load_for_store(T_OBJECT);
2908 __ move_wide(receiver->result(), loc->as_address_ptr());
2909 }
2910 }
2911 }
2912
2913
2914 // Visits all arguments, returns appropriate items without loading them
2915 LIRItemList* LIRGenerator::invoke_visit_arguments(Invoke* x) {
2916 LIRItemList* argument_items = new LIRItemList();
2917 if (x->has_receiver()) {
2918 LIRItem* receiver = new LIRItem(x->receiver(), this);
2919 argument_items->append(receiver);
2920 }
2921 for (int i = 0; i < x->number_of_arguments(); i++) {
2922 LIRItem* param = new LIRItem(x->argument_at(i), this);
2923 argument_items->append(param);
2924 }
2925 return argument_items;
2926 }
2927
2928
2929 // The invoke with receiver has following phases:
2930 // a) traverse and load/lock receiver;
2931 // b) traverse all arguments -> item-array (invoke_visit_argument)
2932 // c) push receiver on stack
2933 // d) load each of the items and push on stack
2934 // e) unlock receiver
2935 // f) move receiver into receiver-register %o0
2936 // g) lock result registers and emit call operation
2937 //
2938 // Before issuing a call, we must spill-save all values on stack
2939 // that are in caller-save register. "spill-save" moves those registers
2940 // either in a free callee-save register or spills them if no free
2941 // callee save register is available.
2942 //
2943 // The problem is where to invoke spill-save.
2944 // - if invoked between e) and f), we may lock callee save
2945 // register in "spill-save" that destroys the receiver register
2946 // before f) is executed
2947 // - if we rearrange f) to be earlier (by loading %o0) it
2948 // may destroy a value on the stack that is currently in %o0
2949 // and is waiting to be spilled
2950 // - if we keep the receiver locked while doing spill-save,
2951 // we cannot spill it as it is spill-locked
2952 //
2953 void LIRGenerator::do_Invoke(Invoke* x) {
2954 CallingConvention* cc = frame_map()->java_calling_convention(x->signature(), true);
2955
2956 LIR_OprList* arg_list = cc->args();
2957 LIRItemList* args = invoke_visit_arguments(x);
2958 LIR_Opr receiver = LIR_OprFact::illegalOpr;
2959
2960 // setup result register
2961 LIR_Opr result_register = LIR_OprFact::illegalOpr;
2962 if (x->type() != voidType) {
2963 result_register = result_register_for(x->type());
2964 }
2965
2966 CodeEmitInfo* info = state_for(x, x->state());
2967
2968 invoke_load_arguments(x, args, arg_list);
2969
2970 if (x->has_receiver()) {
2971 args->at(0)->load_item_force(LIR_Assembler::receiverOpr());
2972 receiver = args->at(0)->result();
2973 }
2974
2975 // emit invoke code
2976 bool optimized = x->target_is_loaded() && x->target_is_final();
2977 assert(receiver->is_illegal() || receiver->is_equal(LIR_Assembler::receiverOpr()), "must match");
2978
2979 // JSR 292
2980 // Preserve the SP over MethodHandle call sites, if needed.
2981 ciMethod* target = x->target();
2982 bool is_method_handle_invoke = (// %%% FIXME: Are both of these relevant?
2983 target->is_method_handle_intrinsic() ||
2984 target->is_compiled_lambda_form());
2985 if (is_method_handle_invoke) {
2986 info->set_is_method_handle_invoke(true);
2987 if(FrameMap::method_handle_invoke_SP_save_opr() != LIR_OprFact::illegalOpr) {
2988 __ move(FrameMap::stack_pointer(), FrameMap::method_handle_invoke_SP_save_opr());
2989 }
2990 }
2991
2992 switch (x->code()) {
2993 case Bytecodes::_invokestatic:
2994 __ call_static(target, result_register,
2995 SharedRuntime::get_resolve_static_call_stub(),
2996 arg_list, info);
2997 break;
2998 case Bytecodes::_invokespecial:
2999 case Bytecodes::_invokevirtual:
3000 case Bytecodes::_invokeinterface:
3001 // for final target we still produce an inline cache, in order
3002 // to be able to call mixed mode
3003 if (x->code() == Bytecodes::_invokespecial || optimized) {
3004 __ call_opt_virtual(target, receiver, result_register,
3005 SharedRuntime::get_resolve_opt_virtual_call_stub(),
3006 arg_list, info);
3007 } else if (x->vtable_index() < 0) {
3008 __ call_icvirtual(target, receiver, result_register,
3009 SharedRuntime::get_resolve_virtual_call_stub(),
3010 arg_list, info);
3011 } else {
3012 int entry_offset = in_bytes(Klass::vtable_start_offset()) + x->vtable_index() * vtableEntry::size_in_bytes();
3013 int vtable_offset = entry_offset + vtableEntry::method_offset_in_bytes();
3014 __ call_virtual(target, receiver, result_register, vtable_offset, arg_list, info);
3015 }
3016 break;
3017 case Bytecodes::_invokedynamic: {
3018 __ call_dynamic(target, receiver, result_register,
3019 SharedRuntime::get_resolve_static_call_stub(),
3020 arg_list, info);
3021 break;
3022 }
3023 default:
3024 fatal("unexpected bytecode: %s", Bytecodes::name(x->code()));
3025 break;
3026 }
3027
3028 // JSR 292
3029 // Restore the SP after MethodHandle call sites, if needed.
3030 if (is_method_handle_invoke
3031 && FrameMap::method_handle_invoke_SP_save_opr() != LIR_OprFact::illegalOpr) {
3032 __ move(FrameMap::method_handle_invoke_SP_save_opr(), FrameMap::stack_pointer());
3033 }
3034
3035 if (x->type()->is_float() || x->type()->is_double()) {
3036 // Force rounding of results from non-strictfp when in strictfp
3037 // scope (or when we don't know the strictness of the callee, to
3038 // be safe.)
3039 if (method()->is_strict()) {
3040 if (!x->target_is_loaded() || !x->target_is_strictfp()) {
3041 result_register = round_item(result_register);
3042 }
3043 }
3044 }
3045
3046 if (result_register->is_valid()) {
3047 LIR_Opr result = rlock_result(x);
3048 __ move(result_register, result);
3049 }
3050 }
3051
3052
3053 void LIRGenerator::do_FPIntrinsics(Intrinsic* x) {
3054 assert(x->number_of_arguments() == 1, "wrong type");
3055 LIRItem value (x->argument_at(0), this);
3056 LIR_Opr reg = rlock_result(x);
3057 value.load_item();
3058 LIR_Opr tmp = force_to_spill(value.result(), as_BasicType(x->type()));
3059 __ move(tmp, reg);
3060 }
3061
3062
3063
3064 // Code for : x->x() {x->cond()} x->y() ? x->tval() : x->fval()
3065 void LIRGenerator::do_IfOp(IfOp* x) {
3066 #ifdef ASSERT
3067 {
3068 ValueTag xtag = x->x()->type()->tag();
3069 ValueTag ttag = x->tval()->type()->tag();
3070 assert(xtag == intTag || xtag == objectTag, "cannot handle others");
3071 assert(ttag == addressTag || ttag == intTag || ttag == objectTag || ttag == longTag, "cannot handle others");
3072 assert(ttag == x->fval()->type()->tag(), "cannot handle others");
3073 }
3074 #endif
3075
3076 LIRItem left(x->x(), this);
3077 LIRItem right(x->y(), this);
3078 left.load_item();
3079 if (can_inline_as_constant(right.value())) {
3080 right.dont_load_item();
3081 } else {
3082 right.load_item();
3083 }
3084
3085 LIRItem t_val(x->tval(), this);
3086 LIRItem f_val(x->fval(), this);
3087 t_val.dont_load_item();
3088 f_val.dont_load_item();
3089 LIR_Opr reg = rlock_result(x);
3090
3091 __ cmp(lir_cond(x->cond()), left.result(), right.result());
3092 __ cmove(lir_cond(x->cond()), t_val.result(), f_val.result(), reg, as_BasicType(x->x()->type()));
3093 }
3094
3095 #ifdef TRACE_HAVE_INTRINSICS
3096 void LIRGenerator::do_ClassIDIntrinsic(Intrinsic* x) {
3097 CodeEmitInfo* info = state_for(x);
3098 CodeEmitInfo* info2 = new CodeEmitInfo(info); // Clone for the second null check
3099
3100 assert(info != NULL, "must have info");
3101 LIRItem arg(x->argument_at(0), this);
3102
3103 arg.load_item();
3104 LIR_Opr klass = new_register(T_METADATA);
3105 __ move(new LIR_Address(arg.result(), java_lang_Class::klass_offset_in_bytes(), T_ADDRESS), klass, info);
3106 LIR_Opr id = new_register(T_LONG);
3107 ByteSize offset = TRACE_KLASS_TRACE_ID_OFFSET;
3108 LIR_Address* trace_id_addr = new LIR_Address(klass, in_bytes(offset), T_LONG);
3109
3110 __ move(trace_id_addr, id);
3111 __ logical_or(id, LIR_OprFact::longConst(0x01l), id);
3112 __ store(id, trace_id_addr);
3113
3114 #ifdef TRACE_ID_META_BITS
3115 __ logical_and(id, LIR_OprFact::longConst(~TRACE_ID_META_BITS), id);
3116 #endif
3117 #ifdef TRACE_ID_CLASS_SHIFT
3118 __ unsigned_shift_right(id, TRACE_ID_CLASS_SHIFT, id);
3119 #endif
3120
3121 __ move(id, rlock_result(x));
3122 }
3123 #endif
3124
3125
3126 void LIRGenerator::do_RuntimeCall(address routine, Intrinsic* x) {
3127 assert(x->number_of_arguments() == 0, "wrong type");
3128 // Enforce computation of _reserved_argument_area_size which is required on some platforms.
3129 BasicTypeList signature;
3130 CallingConvention* cc = frame_map()->c_calling_convention(&signature);
3131 LIR_Opr reg = result_register_for(x->type());
3132 __ call_runtime_leaf(routine, getThreadTemp(),
3133 reg, new LIR_OprList());
3134 LIR_Opr result = rlock_result(x);
3135 __ move(reg, result);
3136 }
3137
3138
3139
3140 void LIRGenerator::do_Intrinsic(Intrinsic* x) {
3141 switch (x->id()) {
3142 case vmIntrinsics::_intBitsToFloat :
3143 case vmIntrinsics::_doubleToRawLongBits :
3144 case vmIntrinsics::_longBitsToDouble :
3145 case vmIntrinsics::_floatToRawIntBits : {
3146 do_FPIntrinsics(x);
3147 break;
3148 }
3149
3150 #ifdef TRACE_HAVE_INTRINSICS
3151 case vmIntrinsics::_getClassId:
3152 do_ClassIDIntrinsic(x);
3153 break;
3154 case vmIntrinsics::_counterTime:
3155 do_RuntimeCall(CAST_FROM_FN_PTR(address, TRACE_TIME_METHOD), x);
3156 break;
3157 #endif
3158
3159 case vmIntrinsics::_currentTimeMillis:
3160 do_RuntimeCall(CAST_FROM_FN_PTR(address, os::javaTimeMillis), x);
3161 break;
3162
3163 case vmIntrinsics::_nanoTime:
3164 do_RuntimeCall(CAST_FROM_FN_PTR(address, os::javaTimeNanos), x);
3165 break;
3166
3167 case vmIntrinsics::_Object_init: do_RegisterFinalizer(x); break;
3168 case vmIntrinsics::_isInstance: do_isInstance(x); break;
3169 case vmIntrinsics::_isPrimitive: do_isPrimitive(x); break;
3170 case vmIntrinsics::_getClass: do_getClass(x); break;
3171 case vmIntrinsics::_currentThread: do_currentThread(x); break;
3172
3173 case vmIntrinsics::_dlog: // fall through
3174 case vmIntrinsics::_dlog10: // fall through
3175 case vmIntrinsics::_dabs: // fall through
3176 case vmIntrinsics::_dsqrt: // fall through
3177 case vmIntrinsics::_dtan: // fall through
3178 case vmIntrinsics::_dsin : // fall through
3179 case vmIntrinsics::_dcos : // fall through
3180 case vmIntrinsics::_dexp : // fall through
3181 case vmIntrinsics::_dpow : do_MathIntrinsic(x); break;
3182 case vmIntrinsics::_arraycopy: do_ArrayCopy(x); break;
3183
3184 case vmIntrinsics::_fmaD: do_FmaIntrinsic(x); break;
3185 case vmIntrinsics::_fmaF: do_FmaIntrinsic(x); break;
3186
3187 // java.nio.Buffer.checkIndex
3188 case vmIntrinsics::_checkIndex: do_NIOCheckIndex(x); break;
3189
3190 case vmIntrinsics::_compareAndSwapObject:
3191 do_CompareAndSwap(x, objectType);
3192 break;
3193 case vmIntrinsics::_compareAndSwapInt:
3194 do_CompareAndSwap(x, intType);
3195 break;
3196 case vmIntrinsics::_compareAndSwapLong:
3197 do_CompareAndSwap(x, longType);
3198 break;
3199
3200 case vmIntrinsics::_loadFence :
3201 if (os::is_MP()) __ membar_acquire();
3202 break;
3203 case vmIntrinsics::_storeFence:
3204 if (os::is_MP()) __ membar_release();
3205 break;
3206 case vmIntrinsics::_fullFence :
3207 if (os::is_MP()) __ membar();
3208 break;
3209 case vmIntrinsics::_onSpinWait:
3210 __ on_spin_wait();
3211 break;
3212 case vmIntrinsics::_Reference_get:
3213 do_Reference_get(x);
3214 break;
3215
3216 case vmIntrinsics::_updateCRC32:
3217 case vmIntrinsics::_updateBytesCRC32:
3218 case vmIntrinsics::_updateByteBufferCRC32:
3219 do_update_CRC32(x);
3220 break;
3221
3222 case vmIntrinsics::_updateBytesCRC32C:
3223 case vmIntrinsics::_updateDirectByteBufferCRC32C:
3224 do_update_CRC32C(x);
3225 break;
3226
3227 case vmIntrinsics::_vectorizedMismatch:
3228 do_vectorizedMismatch(x);
3229 break;
3230
3231 default: ShouldNotReachHere(); break;
3232 }
3233 }
3234
3235 void LIRGenerator::profile_arguments(ProfileCall* x) {
3236 if (compilation()->profile_arguments()) {
3237 int bci = x->bci_of_invoke();
3238 ciMethodData* md = x->method()->method_data_or_null();
3239 ciProfileData* data = md->bci_to_data(bci);
3240 if ((data->is_CallTypeData() && data->as_CallTypeData()->has_arguments()) ||
3241 (data->is_VirtualCallTypeData() && data->as_VirtualCallTypeData()->has_arguments())) {
3242 ByteSize extra = data->is_CallTypeData() ? CallTypeData::args_data_offset() : VirtualCallTypeData::args_data_offset();
3243 int base_offset = md->byte_offset_of_slot(data, extra);
3244 LIR_Opr mdp = LIR_OprFact::illegalOpr;
3245 ciTypeStackSlotEntries* args = data->is_CallTypeData() ? ((ciCallTypeData*)data)->args() : ((ciVirtualCallTypeData*)data)->args();
3246
3247 Bytecodes::Code bc = x->method()->java_code_at_bci(bci);
3248 int start = 0;
3249 int stop = data->is_CallTypeData() ? ((ciCallTypeData*)data)->number_of_arguments() : ((ciVirtualCallTypeData*)data)->number_of_arguments();
3250 if (x->callee()->is_loaded() && x->callee()->is_static() && Bytecodes::has_receiver(bc)) {
3251 // first argument is not profiled at call (method handle invoke)
3252 assert(x->method()->raw_code_at_bci(bci) == Bytecodes::_invokehandle, "invokehandle expected");
3253 start = 1;
3254 }
3255 ciSignature* callee_signature = x->callee()->signature();
3256 // method handle call to virtual method
3257 bool has_receiver = x->callee()->is_loaded() && !x->callee()->is_static() && !Bytecodes::has_receiver(bc);
3258 ciSignatureStream callee_signature_stream(callee_signature, has_receiver ? x->callee()->holder() : NULL);
3259
3260 bool ignored_will_link;
3261 ciSignature* signature_at_call = NULL;
3262 x->method()->get_method_at_bci(bci, ignored_will_link, &signature_at_call);
3263 ciSignatureStream signature_at_call_stream(signature_at_call);
3264
3265 // if called through method handle invoke, some arguments may have been popped
3266 for (int i = 0; i < stop && i+start < x->nb_profiled_args(); i++) {
3267 int off = in_bytes(TypeEntriesAtCall::argument_type_offset(i)) - in_bytes(TypeEntriesAtCall::args_data_offset());
3268 ciKlass* exact = profile_type(md, base_offset, off,
3269 args->type(i), x->profiled_arg_at(i+start), mdp,
3270 !x->arg_needs_null_check(i+start),
3271 signature_at_call_stream.next_klass(), callee_signature_stream.next_klass());
3272 if (exact != NULL) {
3273 md->set_argument_type(bci, i, exact);
3274 }
3275 }
3276 } else {
3277 #ifdef ASSERT
3278 Bytecodes::Code code = x->method()->raw_code_at_bci(x->bci_of_invoke());
3279 int n = x->nb_profiled_args();
3280 assert(MethodData::profile_parameters() && (MethodData::profile_arguments_jsr292_only() ||
3281 (x->inlined() && ((code == Bytecodes::_invokedynamic && n <= 1) || (code == Bytecodes::_invokehandle && n <= 2)))),
3282 "only at JSR292 bytecodes");
3283 #endif
3284 }
3285 }
3286 }
3287
3288 // profile parameters on entry to an inlined method
3289 void LIRGenerator::profile_parameters_at_call(ProfileCall* x) {
3290 if (compilation()->profile_parameters() && x->inlined()) {
3291 ciMethodData* md = x->callee()->method_data_or_null();
3292 if (md != NULL) {
3293 ciParametersTypeData* parameters_type_data = md->parameters_type_data();
3294 if (parameters_type_data != NULL) {
3295 ciTypeStackSlotEntries* parameters = parameters_type_data->parameters();
3296 LIR_Opr mdp = LIR_OprFact::illegalOpr;
3297 bool has_receiver = !x->callee()->is_static();
3298 ciSignature* sig = x->callee()->signature();
3299 ciSignatureStream sig_stream(sig, has_receiver ? x->callee()->holder() : NULL);
3300 int i = 0; // to iterate on the Instructions
3301 Value arg = x->recv();
3302 bool not_null = false;
3303 int bci = x->bci_of_invoke();
3304 Bytecodes::Code bc = x->method()->java_code_at_bci(bci);
3305 // The first parameter is the receiver so that's what we start
3306 // with if it exists. One exception is method handle call to
3307 // virtual method: the receiver is in the args list
3308 if (arg == NULL || !Bytecodes::has_receiver(bc)) {
3309 i = 1;
3310 arg = x->profiled_arg_at(0);
3311 not_null = !x->arg_needs_null_check(0);
3312 }
3313 int k = 0; // to iterate on the profile data
3314 for (;;) {
3315 intptr_t profiled_k = parameters->type(k);
3316 ciKlass* exact = profile_type(md, md->byte_offset_of_slot(parameters_type_data, ParametersTypeData::type_offset(0)),
3317 in_bytes(ParametersTypeData::type_offset(k)) - in_bytes(ParametersTypeData::type_offset(0)),
3318 profiled_k, arg, mdp, not_null, sig_stream.next_klass(), NULL);
3319 // If the profile is known statically set it once for all and do not emit any code
3320 if (exact != NULL) {
3321 md->set_parameter_type(k, exact);
3322 }
3323 k++;
3324 if (k >= parameters_type_data->number_of_parameters()) {
3325 #ifdef ASSERT
3326 int extra = 0;
3327 if (MethodData::profile_arguments() && TypeProfileParmsLimit != -1 &&
3328 x->nb_profiled_args() >= TypeProfileParmsLimit &&
3329 x->recv() != NULL && Bytecodes::has_receiver(bc)) {
3330 extra += 1;
3331 }
3332 assert(i == x->nb_profiled_args() - extra || (TypeProfileParmsLimit != -1 && TypeProfileArgsLimit > TypeProfileParmsLimit), "unused parameters?");
3333 #endif
3334 break;
3335 }
3336 arg = x->profiled_arg_at(i);
3337 not_null = !x->arg_needs_null_check(i);
3338 i++;
3339 }
3340 }
3341 }
3342 }
3343 }
3344
3345 void LIRGenerator::do_ProfileCall(ProfileCall* x) {
3346 // Need recv in a temporary register so it interferes with the other temporaries
3347 LIR_Opr recv = LIR_OprFact::illegalOpr;
3348 LIR_Opr mdo = new_register(T_OBJECT);
3349 // tmp is used to hold the counters on SPARC
3350 LIR_Opr tmp = new_pointer_register();
3351
3352 if (x->nb_profiled_args() > 0) {
3353 profile_arguments(x);
3354 }
3355
3356 // profile parameters on inlined method entry including receiver
3357 if (x->recv() != NULL || x->nb_profiled_args() > 0) {
3358 profile_parameters_at_call(x);
3359 }
3360
3361 if (x->recv() != NULL) {
3362 LIRItem value(x->recv(), this);
3363 value.load_item();
3364 recv = new_register(T_OBJECT);
3365 __ move(value.result(), recv);
3366 }
3367 __ profile_call(x->method(), x->bci_of_invoke(), x->callee(), mdo, recv, tmp, x->known_holder());
3368 }
3369
3370 void LIRGenerator::do_ProfileReturnType(ProfileReturnType* x) {
3371 int bci = x->bci_of_invoke();
3372 ciMethodData* md = x->method()->method_data_or_null();
3373 ciProfileData* data = md->bci_to_data(bci);
3374 assert(data->is_CallTypeData() || data->is_VirtualCallTypeData(), "wrong profile data type");
3375 ciReturnTypeEntry* ret = data->is_CallTypeData() ? ((ciCallTypeData*)data)->ret() : ((ciVirtualCallTypeData*)data)->ret();
3376 LIR_Opr mdp = LIR_OprFact::illegalOpr;
3377
3378 bool ignored_will_link;
3379 ciSignature* signature_at_call = NULL;
3380 x->method()->get_method_at_bci(bci, ignored_will_link, &signature_at_call);
3381
3382 // The offset within the MDO of the entry to update may be too large
3383 // to be used in load/store instructions on some platforms. So have
3384 // profile_type() compute the address of the profile in a register.
3385 ciKlass* exact = profile_type(md, md->byte_offset_of_slot(data, ret->type_offset()), 0,
3386 ret->type(), x->ret(), mdp,
3387 !x->needs_null_check(),
3388 signature_at_call->return_type()->as_klass(),
3389 x->callee()->signature()->return_type()->as_klass());
3390 if (exact != NULL) {
3391 md->set_return_type(bci, exact);
3392 }
3393 }
3394
3395 void LIRGenerator::do_ProfileInvoke(ProfileInvoke* x) {
3396 // We can safely ignore accessors here, since c2 will inline them anyway,
3397 // accessors are also always mature.
3398 if (!x->inlinee()->is_accessor()) {
3399 CodeEmitInfo* info = state_for(x, x->state(), true);
3400 // Notify the runtime very infrequently only to take care of counter overflows
3401 int freq_log = Tier23InlineeNotifyFreqLog;
3402 double scale;
3403 if (_method->has_option_value("CompileThresholdScaling", scale)) {
3404 freq_log = Arguments::scaled_freq_log(freq_log, scale);
3405 }
3406 increment_event_counter_impl(info, x->inlinee(), right_n_bits(freq_log), InvocationEntryBci, false, true);
3407 }
3408 }
3409
3410 void LIRGenerator::increment_event_counter(CodeEmitInfo* info, int bci, bool backedge) {
3411 int freq_log = 0;
3412 int level = compilation()->env()->comp_level();
3413 if (level == CompLevel_limited_profile) {
3414 freq_log = (backedge ? Tier2BackedgeNotifyFreqLog : Tier2InvokeNotifyFreqLog);
3415 } else if (level == CompLevel_full_profile) {
3416 freq_log = (backedge ? Tier3BackedgeNotifyFreqLog : Tier3InvokeNotifyFreqLog);
3417 } else {
3418 ShouldNotReachHere();
3419 }
3420 // Increment the appropriate invocation/backedge counter and notify the runtime.
3421 double scale;
3422 if (_method->has_option_value("CompileThresholdScaling", scale)) {
3423 freq_log = Arguments::scaled_freq_log(freq_log, scale);
3424 }
3425 increment_event_counter_impl(info, info->scope()->method(), right_n_bits(freq_log), bci, backedge, true);
3426 }
3427
3428 void LIRGenerator::decrement_age(CodeEmitInfo* info) {
3429 ciMethod* method = info->scope()->method();
3430 MethodCounters* mc_adr = method->ensure_method_counters();
3431 if (mc_adr != NULL) {
3432 LIR_Opr mc = new_pointer_register();
3433 __ move(LIR_OprFact::intptrConst(mc_adr), mc);
3434 int offset = in_bytes(MethodCounters::nmethod_age_offset());
3435 LIR_Address* counter = new LIR_Address(mc, offset, T_INT);
3436 LIR_Opr result = new_register(T_INT);
3437 __ load(counter, result);
3438 __ sub(result, LIR_OprFact::intConst(1), result);
3439 __ store(result, counter);
3440 // DeoptimizeStub will reexecute from the current state in code info.
3441 CodeStub* deopt = new DeoptimizeStub(info, Deoptimization::Reason_tenured,
3442 Deoptimization::Action_make_not_entrant);
3443 __ cmp(lir_cond_lessEqual, result, LIR_OprFact::intConst(0));
3444 __ branch(lir_cond_lessEqual, T_INT, deopt);
3445 }
3446 }
3447
3448
3449 void LIRGenerator::increment_event_counter_impl(CodeEmitInfo* info,
3450 ciMethod *method, int frequency,
3451 int bci, bool backedge, bool notify) {
3452 assert(frequency == 0 || is_power_of_2(frequency + 1), "Frequency must be x^2 - 1 or 0");
3453 int level = _compilation->env()->comp_level();
3454 assert(level > CompLevel_simple, "Shouldn't be here");
3455
3456 int offset = -1;
3457 LIR_Opr counter_holder = NULL;
3458 if (level == CompLevel_limited_profile) {
3459 MethodCounters* counters_adr = method->ensure_method_counters();
3460 if (counters_adr == NULL) {
3461 bailout("method counters allocation failed");
3462 return;
3463 }
3464 counter_holder = new_pointer_register();
3465 __ move(LIR_OprFact::intptrConst(counters_adr), counter_holder);
3466 offset = in_bytes(backedge ? MethodCounters::backedge_counter_offset() :
3467 MethodCounters::invocation_counter_offset());
3468 } else if (level == CompLevel_full_profile) {
3469 counter_holder = new_register(T_METADATA);
3470 offset = in_bytes(backedge ? MethodData::backedge_counter_offset() :
3471 MethodData::invocation_counter_offset());
3472 ciMethodData* md = method->method_data_or_null();
3473 assert(md != NULL, "Sanity");
3474 __ metadata2reg(md->constant_encoding(), counter_holder);
3475 } else {
3476 ShouldNotReachHere();
3477 }
3478 LIR_Address* counter = new LIR_Address(counter_holder, offset, T_INT);
3479 LIR_Opr result = new_register(T_INT);
3480 __ load(counter, result);
3481 __ add(result, LIR_OprFact::intConst(InvocationCounter::count_increment), result);
3482 __ store(result, counter);
3483 if (notify && (!backedge || UseOnStackReplacement)) {
3484 LIR_Opr meth = LIR_OprFact::metadataConst(method->constant_encoding());
3485 // The bci for info can point to cmp for if's we want the if bci
3486 CodeStub* overflow = new CounterOverflowStub(info, bci, meth);
3487 int freq = frequency << InvocationCounter::count_shift;
3488 if (freq == 0) {
3489 __ branch(lir_cond_always, T_ILLEGAL, overflow);
3490 } else {
3491 LIR_Opr mask = load_immediate(freq, T_INT);
3492 __ logical_and(result, mask, result);
3493 __ cmp(lir_cond_equal, result, LIR_OprFact::intConst(0));
3494 __ branch(lir_cond_equal, T_INT, overflow);
3495 }
3496 __ branch_destination(overflow->continuation());
3497 }
3498 }
3499
3500 void LIRGenerator::do_RuntimeCall(RuntimeCall* x) {
3501 LIR_OprList* args = new LIR_OprList(x->number_of_arguments());
3502 BasicTypeList* signature = new BasicTypeList(x->number_of_arguments());
3503
3504 if (x->pass_thread()) {
3505 signature->append(LP64_ONLY(T_LONG) NOT_LP64(T_INT)); // thread
3506 args->append(getThreadPointer());
3507 }
3508
3509 for (int i = 0; i < x->number_of_arguments(); i++) {
3510 Value a = x->argument_at(i);
3511 LIRItem* item = new LIRItem(a, this);
3512 item->load_item();
3513 args->append(item->result());
3514 signature->append(as_BasicType(a->type()));
3515 }
3516
3517 LIR_Opr result = call_runtime(signature, args, x->entry(), x->type(), NULL);
3518 if (x->type() == voidType) {
3519 set_no_result(x);
3520 } else {
3521 __ move(result, rlock_result(x));
3522 }
3523 }
3524
3525 #ifdef ASSERT
3526 void LIRGenerator::do_Assert(Assert *x) {
3527 ValueTag tag = x->x()->type()->tag();
3528 If::Condition cond = x->cond();
3529
3530 LIRItem xitem(x->x(), this);
3531 LIRItem yitem(x->y(), this);
3532 LIRItem* xin = &xitem;
3533 LIRItem* yin = &yitem;
3534
3535 assert(tag == intTag, "Only integer assertions are valid!");
3536
3537 xin->load_item();
3538 yin->dont_load_item();
3539
3540 set_no_result(x);
3541
3542 LIR_Opr left = xin->result();
3543 LIR_Opr right = yin->result();
3544
3545 __ lir_assert(lir_cond(x->cond()), left, right, x->message(), true);
3546 }
3547 #endif
3548
3549 void LIRGenerator::do_RangeCheckPredicate(RangeCheckPredicate *x) {
3550
3551
3552 Instruction *a = x->x();
3553 Instruction *b = x->y();
3554 if (!a || StressRangeCheckElimination) {
3555 assert(!b || StressRangeCheckElimination, "B must also be null");
3556
3557 CodeEmitInfo *info = state_for(x, x->state());
3558 CodeStub* stub = new PredicateFailedStub(info);
3559
3560 __ jump(stub);
3561 } else if (a->type()->as_IntConstant() && b->type()->as_IntConstant()) {
3562 int a_int = a->type()->as_IntConstant()->value();
3563 int b_int = b->type()->as_IntConstant()->value();
3564
3565 bool ok = false;
3566
3567 switch(x->cond()) {
3568 case Instruction::eql: ok = (a_int == b_int); break;
3569 case Instruction::neq: ok = (a_int != b_int); break;
3570 case Instruction::lss: ok = (a_int < b_int); break;
3571 case Instruction::leq: ok = (a_int <= b_int); break;
3572 case Instruction::gtr: ok = (a_int > b_int); break;
3573 case Instruction::geq: ok = (a_int >= b_int); break;
3574 case Instruction::aeq: ok = ((unsigned int)a_int >= (unsigned int)b_int); break;
3575 case Instruction::beq: ok = ((unsigned int)a_int <= (unsigned int)b_int); break;
3576 default: ShouldNotReachHere();
3577 }
3578
3579 if (ok) {
3580
3581 CodeEmitInfo *info = state_for(x, x->state());
3582 CodeStub* stub = new PredicateFailedStub(info);
3583
3584 __ jump(stub);
3585 }
3586 } else {
3587
3588 ValueTag tag = x->x()->type()->tag();
3589 If::Condition cond = x->cond();
3590 LIRItem xitem(x->x(), this);
3591 LIRItem yitem(x->y(), this);
3592 LIRItem* xin = &xitem;
3593 LIRItem* yin = &yitem;
3594
3595 assert(tag == intTag, "Only integer deoptimizations are valid!");
3596
3597 xin->load_item();
3598 yin->dont_load_item();
3599 set_no_result(x);
3600
3601 LIR_Opr left = xin->result();
3602 LIR_Opr right = yin->result();
3603
3604 CodeEmitInfo *info = state_for(x, x->state());
3605 CodeStub* stub = new PredicateFailedStub(info);
3606
3607 __ cmp(lir_cond(cond), left, right);
3608 __ branch(lir_cond(cond), right->type(), stub);
3609 }
3610 }
3611
3612
3613 LIR_Opr LIRGenerator::call_runtime(Value arg1, address entry, ValueType* result_type, CodeEmitInfo* info) {
3614 LIRItemList args(1);
3615 LIRItem value(arg1, this);
3616 args.append(&value);
3617 BasicTypeList signature;
3618 signature.append(as_BasicType(arg1->type()));
3619
3620 return call_runtime(&signature, &args, entry, result_type, info);
3621 }
3622
3623
3624 LIR_Opr LIRGenerator::call_runtime(Value arg1, Value arg2, address entry, ValueType* result_type, CodeEmitInfo* info) {
3625 LIRItemList args(2);
3626 LIRItem value1(arg1, this);
3627 LIRItem value2(arg2, this);
3628 args.append(&value1);
3629 args.append(&value2);
3630 BasicTypeList signature;
3631 signature.append(as_BasicType(arg1->type()));
3632 signature.append(as_BasicType(arg2->type()));
3633
3634 return call_runtime(&signature, &args, entry, result_type, info);
3635 }
3636
3637
3638 LIR_Opr LIRGenerator::call_runtime(BasicTypeArray* signature, LIR_OprList* args,
3639 address entry, ValueType* result_type, CodeEmitInfo* info) {
3640 // get a result register
3641 LIR_Opr phys_reg = LIR_OprFact::illegalOpr;
3642 LIR_Opr result = LIR_OprFact::illegalOpr;
3643 if (result_type->tag() != voidTag) {
3644 result = new_register(result_type);
3645 phys_reg = result_register_for(result_type);
3646 }
3647
3648 // move the arguments into the correct location
3649 CallingConvention* cc = frame_map()->c_calling_convention(signature);
3650 assert(cc->length() == args->length(), "argument mismatch");
3651 for (int i = 0; i < args->length(); i++) {
3652 LIR_Opr arg = args->at(i);
3653 LIR_Opr loc = cc->at(i);
3654 if (loc->is_register()) {
3655 __ move(arg, loc);
3656 } else {
3657 LIR_Address* addr = loc->as_address_ptr();
3658 // if (!can_store_as_constant(arg)) {
3659 // LIR_Opr tmp = new_register(arg->type());
3660 // __ move(arg, tmp);
3661 // arg = tmp;
3662 // }
3663 if (addr->type() == T_LONG || addr->type() == T_DOUBLE) {
3664 __ unaligned_move(arg, addr);
3665 } else {
3666 __ move(arg, addr);
3667 }
3668 }
3669 }
3670
3671 if (info) {
3672 __ call_runtime(entry, getThreadTemp(), phys_reg, cc->args(), info);
3673 } else {
3674 __ call_runtime_leaf(entry, getThreadTemp(), phys_reg, cc->args());
3675 }
3676 if (result->is_valid()) {
3677 __ move(phys_reg, result);
3678 }
3679 return result;
3680 }
3681
3682
3683 LIR_Opr LIRGenerator::call_runtime(BasicTypeArray* signature, LIRItemList* args,
3684 address entry, ValueType* result_type, CodeEmitInfo* info) {
3685 // get a result register
3686 LIR_Opr phys_reg = LIR_OprFact::illegalOpr;
3687 LIR_Opr result = LIR_OprFact::illegalOpr;
3688 if (result_type->tag() != voidTag) {
3689 result = new_register(result_type);
3690 phys_reg = result_register_for(result_type);
3691 }
3692
3693 // move the arguments into the correct location
3694 CallingConvention* cc = frame_map()->c_calling_convention(signature);
3695
3696 assert(cc->length() == args->length(), "argument mismatch");
3697 for (int i = 0; i < args->length(); i++) {
3698 LIRItem* arg = args->at(i);
3699 LIR_Opr loc = cc->at(i);
3700 if (loc->is_register()) {
3701 arg->load_item_force(loc);
3702 } else {
3703 LIR_Address* addr = loc->as_address_ptr();
3704 arg->load_for_store(addr->type());
3705 if (addr->type() == T_LONG || addr->type() == T_DOUBLE) {
3706 __ unaligned_move(arg->result(), addr);
3707 } else {
3708 __ move(arg->result(), addr);
3709 }
3710 }
3711 }
3712
3713 if (info) {
3714 __ call_runtime(entry, getThreadTemp(), phys_reg, cc->args(), info);
3715 } else {
3716 __ call_runtime_leaf(entry, getThreadTemp(), phys_reg, cc->args());
3717 }
3718 if (result->is_valid()) {
3719 __ move(phys_reg, result);
3720 }
3721 return result;
3722 }
3723
3724 void LIRGenerator::do_MemBar(MemBar* x) {
3725 if (os::is_MP()) {
3726 LIR_Code code = x->code();
3727 switch(code) {
3728 case lir_membar_acquire : __ membar_acquire(); break;
3729 case lir_membar_release : __ membar_release(); break;
3730 case lir_membar : __ membar(); break;
3731 case lir_membar_loadload : __ membar_loadload(); break;
3732 case lir_membar_storestore: __ membar_storestore(); break;
3733 case lir_membar_loadstore : __ membar_loadstore(); break;
3734 case lir_membar_storeload : __ membar_storeload(); break;
3735 default : ShouldNotReachHere(); break;
3736 }
3737 }
3738 }
3739
3740 LIR_Opr LIRGenerator::maybe_mask_boolean(StoreIndexed* x, LIR_Opr array, LIR_Opr value, CodeEmitInfo*& null_check_info) {
3741 if (x->check_boolean()) {
3742 LIR_Opr value_fixed = rlock_byte(T_BYTE);
3743 if (TwoOperandLIRForm) {
3744 __ move(value, value_fixed);
3745 __ logical_and(value_fixed, LIR_OprFact::intConst(1), value_fixed);
3746 } else {
3747 __ logical_and(value, LIR_OprFact::intConst(1), value_fixed);
3748 }
3749 LIR_Opr klass = new_register(T_METADATA);
3750 __ move(new LIR_Address(array, oopDesc::klass_offset_in_bytes(), T_ADDRESS), klass, null_check_info);
3751 null_check_info = NULL;
3752 LIR_Opr layout = new_register(T_INT);
3753 __ move(new LIR_Address(klass, in_bytes(Klass::layout_helper_offset()), T_INT), layout);
3754 int diffbit = Klass::layout_helper_boolean_diffbit();
3755 __ logical_and(layout, LIR_OprFact::intConst(diffbit), layout);
3756 __ cmp(lir_cond_notEqual, layout, LIR_OprFact::intConst(0));
3757 __ cmove(lir_cond_notEqual, value_fixed, value, value_fixed, T_BYTE);
3758 value = value_fixed;
3759 }
3760 return value;
3761 }