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