jdk-sandbox: comparison src/hotspot/cpu/x86/c1_LIRAssembler

equal deleted inserted replaced

-:e27564cd10e3
+:08a5148e7c4e
 /*
-* Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 }
 move_regs(src->as_register(), dest->as_register());
 } else if (dest->is_double_cpu()) {
 #ifdef _LP64
-if (src->type() == T_OBJECT || src->type() == T_ARRAY) {
+if (is_reference_type(src->type())) {
 // Surprising to me but we can see move of a long to t_object
 __ verify_oop(src->as_register());
 move_regs(src->as_register(), dest->as_register_lo());
 return;
 }
 assert(src->is_register(), "should not call otherwise");
 assert(dest->is_stack(), "should not call otherwise");
 if (src->is_single_cpu()) {
 Address dst = frame_map()->address_for_slot(dest->single_stack_ix());
-if (type == T_OBJECT || type == T_ARRAY) {
+if (is_reference_type(type)) {
 __ verify_oop(src->as_register());
 __ movptr (dst, src->as_register());
 } else if (type == T_METADATA) {
 __ movptr (dst, src->as_register());
 } else {
 void LIR_Assembler::reg2mem(LIR_Opr src, LIR_Opr dest, BasicType type, LIR_PatchCode patch_code, CodeEmitInfo* info, bool pop_fpu_stack, bool wide, bool /* unaligned */) {
 LIR_Address* to_addr = dest->as_address_ptr();
 PatchingStub* patch = NULL;
 Register compressed_src = rscratch1;
-if (type == T_ARRAY || type == T_OBJECT) {
+if (is_reference_type(type)) {
 __ verify_oop(src->as_register());
 #ifdef _LP64
 if (UseCompressedOops && !wide) {
 __ movptr(compressed_src, src->as_register());
 __ encode_heap_oop(compressed_src);
 void LIR_Assembler::stack2reg(LIR_Opr src, LIR_Opr dest, BasicType type) {
 assert(src->is_stack(), "should not call otherwise");
 assert(dest->is_register(), "should not call otherwise");
 if (dest->is_single_cpu()) {
-if (type == T_ARRAY || type == T_OBJECT) {
+if (is_reference_type(type)) {
 __ movptr(dest->as_register(), frame_map()->address_for_slot(src->single_stack_ix()));
 __ verify_oop(dest->as_register());
 } else if (type == T_METADATA) {
 __ movptr(dest->as_register(), frame_map()->address_for_slot(src->single_stack_ix()));
 } else {
 }
 void LIR_Assembler::stack2stack(LIR_Opr src, LIR_Opr dest, BasicType type) {
 if (src->is_single_stack()) {
-if (type == T_OBJECT || type == T_ARRAY) {
+if (is_reference_type(type)) {
 __ pushptr(frame_map()->address_for_slot(src ->single_stack_ix()));
 __ popptr (frame_map()->address_for_slot(dest->single_stack_ix()));
 } else {
 #ifndef _LP64
 __ pushl(frame_map()->address_for_slot(src ->single_stack_ix()));
 if (patch != NULL) {
 patching_epilog(patch, patch_code, addr->base()->as_register(), info);
 }
-if (type == T_ARRAY || type == T_OBJECT) {
+if (is_reference_type(type)) {
 #ifdef _LP64
 if (UseCompressedOops && !wide) {
 __ decode_heap_oop(dest->as_register());
 }
 #endif
 void LIR_Assembler::emit_alloc_array(LIR_OpAllocArray* op) {
 Register len =  op->len()->as_register();
 LP64_ONLY( __ movslq(len, len); )
 if (UseSlowPath ||
-(!UseFastNewObjectArray && (op->type() == T_OBJECT || op->type() == T_ARRAY)) ||
+(!UseFastNewObjectArray && is_reference_type(op->type())) ||
-(!UseFastNewTypeArray   && (op->type() != T_OBJECT && op->type() != T_ARRAY))) {
+(!UseFastNewTypeArray   && !is_reference_type(op->type()))) {
 __ jmp(*op->stub()->entry());
 } else {
 Register tmp1 = op->tmp1()->as_register();
 Register tmp2 = op->tmp2()->as_register();
 Register tmp3 = op->tmp3()->as_register();
 }
 #endif // _LP64
 } else {
 #ifdef _LP64
 Register r_lo;
-if (right->type() == T_OBJECT || right->type() == T_ARRAY) {
+if (is_reference_type(right->type())) {
 r_lo = right->as_register();
 } else {
 r_lo = right->as_register_lo();
 }
 #else
 void LIR_Assembler::comp_op(LIR_Condition condition, LIR_Opr opr1, LIR_Opr opr2, LIR_Op2* op) {
 if (opr1->is_single_cpu()) {
 Register reg1 = opr1->as_register();
 if (opr2->is_single_cpu()) {
 // cpu register - cpu register
-if (opr1->type() == T_OBJECT || opr1->type() == T_ARRAY) {
+if (is_reference_type(opr1->type())) {
 __ cmpoop(reg1, opr2->as_register());
 } else {
-assert(opr2->type() != T_OBJECT && opr2->type() != T_ARRAY, "cmp int, oop?");
+assert(!is_reference_type(opr2->type()), "cmp int, oop?");
 __ cmpl(reg1, opr2->as_register());
 }
 } else if (opr2->is_stack()) {
 // cpu register - stack
-if (opr1->type() == T_OBJECT || opr1->type() == T_ARRAY) {
+if (is_reference_type(opr1->type())) {
 __ cmpoop(reg1, frame_map()->address_for_slot(opr2->single_stack_ix()));
 } else {
 __ cmpl(reg1, frame_map()->address_for_slot(opr2->single_stack_ix()));
 }
 } else if (opr2->is_constant()) {
 // cpu register - constant
 LIR_Const* c = opr2->as_constant_ptr();
 if (c->type() == T_INT) {
 __ cmpl(reg1, c->as_jint());
-} else if (c->type() == T_OBJECT || c->type() == T_ARRAY) {
+} else if (is_reference_type(c->type())) {
 // In 64bit oops are single register
 jobject o = c->as_jobject();
 if (o == NULL) {
 __ cmpptr(reg1, (int32_t)NULL_WORD);
 } else {
 __ fcmp(noreg, opr2->fpu(), op->fpu_pop_count() > 0, op->fpu_pop_count() > 1);
 } else if (opr1->is_address() && opr2->is_constant()) {
 LIR_Const* c = opr2->as_constant_ptr();
 #ifdef _LP64
-if (c->type() == T_OBJECT || c->type() == T_ARRAY) {
+if (is_reference_type(c->type())) {
 assert(condition == lir_cond_equal || condition == lir_cond_notEqual, "need to reverse");
 __ movoop(rscratch1, c->as_jobject());
 }
 #endif // LP64
 if (op->info() != NULL) {
 }
 // special case: address - constant
 LIR_Address* addr = opr1->as_address_ptr();
 if (c->type() == T_INT) {
 __ cmpl(as_Address(addr), c->as_jint());
-} else if (c->type() == T_OBJECT || c->type() == T_ARRAY) {
+} else if (is_reference_type(c->type())) {
 #ifdef _LP64
 // %%% Make this explode if addr isn't reachable until we figure out a
 // better strategy by giving noreg as the temp for as_Address
 __ cmpoop(rscratch1, as_Address(addr, noreg));
 #else
 __ resolve(ACCESS_WRITE, dst);
 CodeStub* stub = op->stub();
 int flags = op->flags();
 BasicType basic_type = default_type != NULL ? default_type->element_type()->basic_type() : T_ILLEGAL;
-if (basic_type == T_ARRAY) basic_type = T_OBJECT;
+if (is_reference_type(basic_type)) basic_type = T_OBJECT;
 // if we don't know anything, just go through the generic arraycopy
 if (default_type == NULL) {
 // save outgoing arguments on stack in case call to System.arraycopy is needed
 // HACK ALERT. This code used to push the parameters in a hardwired fashion

changeset 58273	08a5148e7c4e
parent 55253	3c905e67e380
child 58679	9c3209ff7550
child 58925	9bbe560e8131