jdk8-mips64-public/hotspot: comparison src/share/vm/c1/c1

-:e4aeef458496
+:ffcdff41a92f
 /*
-* Copyright (c) 2005, 2016, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2005, 2015, 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.
 void LIRGenerator::init() {
 _bs = Universe::heap()->barrier_set();
 #ifdef MIPS64
 assert(_bs->kind() == BarrierSet::CardTableModRef, "Wrong barrier set kind");
 CardTableModRefBS* ct = (CardTableModRefBS*)_bs;
 assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust this code");
 //_card_table_base = new LIR_Const((intptr_t)ct->byte_map_base);
 //        //FIXME, untested in 32bit. by aoqi
 _card_table_base = new LIR_Const(ct->byte_map_base);
 #endif
 }
 void LIRGenerator::block_do_prolog(BlockBegin* block) {
 if (index->is_constant()) {
 #ifndef MIPS64
 cmp_mem_int(lir_cond_belowEqual, buffer, java_nio_Buffer::limit_offset(), index->as_jint(), info);
 __ branch(lir_cond_belowEqual, T_INT, stub); // forward branch
 #else
 LIR_Opr left = LIR_OprFact::address(new LIR_Address(buffer, java_nio_Buffer::limit_offset(),T_INT));
 LIR_Opr right = LIR_OprFact::intConst(index->as_jint());
 __ null_check_for_branch(lir_cond_belowEqual, left, right, info);
 __ branch(lir_cond_belowEqual,left, right ,T_INT, stub); // forward branch
 #endif
 } else {
 #ifndef MIPS64
 cmp_reg_mem(lir_cond_aboveEqual, index, buffer,
 java_nio_Buffer::limit_offset(), T_INT, info);
 #endif
 #ifndef MIPS64
 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) {
 #else
-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 scratch5, LIR_Opr scratch6, LIR_Opr klass_reg, CodeEmitInfo* info) {
+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 scratch5, LIR_Opr scratch6,LIR_Opr klass_reg, CodeEmitInfo* info) {
 #endif
 klass2reg_with_patching(klass_reg, klass, info, is_unresolved);
 // If klass is not loaded we do not know if the klass has finalizers:
 if (UseFastNewInstance && klass->is_loaded()
 && !Klass::layout_helper_needs_slow_path(klass->layout_helper())) {
 __ move(data_reg, data_addr);
 }
 }
 #else
 void LIRGenerator::profile_branch(If* if_instr, If::Condition cond , LIR_Opr left, LIR_Opr right) {
 if (if_instr->should_profile()) {
 ciMethod* method = if_instr->profiled_method();
 assert(method != NULL, "method should be set if branch is profiled");
 ciMethodData* md = method->method_data_or_null();
 if (md == NULL) {
 bailout("out of memory building methodDataOop");
 return;
 }
 ciProfileData* data = md->bci_to_data(if_instr->profiled_bci());
 assert(data != NULL, "must have profiling data");
 assert(data->is_BranchData(), "need BranchData for two-way branches");
 int taken_count_offset     = md->byte_offset_of_slot(data, BranchData::taken_offset());
 int not_taken_count_offset = md->byte_offset_of_slot(data, BranchData::not_taken_offset());
 if (if_instr->is_swapped()) {
 int t = taken_count_offset;
 taken_count_offset = not_taken_count_offset;
 not_taken_count_offset = t;
 }
 LIR_Opr md_reg = new_register(T_METADATA);
 __ metadata2reg(md->constant_encoding(), md_reg);
-//__ move(LIR_OprFact::oopConst(md->constant_encoding()), md_reg);
+LIR_Opr data_offset_reg = new_pointer_register();
-LIR_Opr data_offset_reg = new_pointer_register();
+LIR_Opr opr1 =  LIR_OprFact::intptrConst(taken_count_offset);
-LIR_Opr opr1 =  LIR_OprFact::intConst(taken_count_offset);
+LIR_Opr opr2 =  LIR_OprFact::intptrConst(not_taken_count_offset);
-LIR_Opr opr2 =  LIR_OprFact::intConst(not_taken_count_offset);
+LabelObj* skip = new LabelObj();
-LabelObj* skip = new LabelObj();
+__ move(opr1, data_offset_reg);
-__ move(opr1, data_offset_reg);
+__ branch( lir_cond(cond), left, right, skip->label());
-__ branch( lir_cond(cond), left, right, skip->label());
+__ move(opr2, data_offset_reg);
-__ move(opr2, data_offset_reg);
+__ branch_destination(skip->label());
-__ branch_destination(skip->label());
+LIR_Opr data_reg = new_pointer_register();
-LIR_Opr data_reg = new_pointer_register();
+LIR_Opr tmp_reg = new_pointer_register();
-LIR_Opr tmp_reg = new_pointer_register();
+__ move(data_offset_reg, tmp_reg);
-// LIR_Address* data_addr = new LIR_Address(md_reg, data_offset_reg, T_INT);
+__ add(tmp_reg, md_reg, tmp_reg);
-__ move(data_offset_reg, tmp_reg);
+LIR_Address* data_addr = new LIR_Address(tmp_reg, 0, data_reg->type());
-__ add(tmp_reg, md_reg, tmp_reg);
+__ move(LIR_OprFact::address(data_addr), data_reg);
-LIR_Address* data_addr = new LIR_Address(tmp_reg, 0, T_INT);
+LIR_Address* fake_incr_value = new LIR_Address(data_reg, DataLayout::counter_increment, T_INT);
-__ move(LIR_OprFact::address(data_addr), data_reg);
+// Use leal instead of add to avoid destroying condition codes on x86
-LIR_Address* fake_incr_value = new LIR_Address(data_reg, DataLayout::counter_increment, T_INT);
+__ leal(LIR_OprFact::address(fake_incr_value), data_reg);
-// Use leal instead of add to avoid destroying condition codes on x86
+__ move(data_reg, LIR_OprFact::address(data_addr));
-__ leal(LIR_OprFact::address(fake_incr_value), data_reg);
+}
-__ move(data_reg, LIR_OprFact::address(data_addr));
-}
 }
 #endif
 // Phi technique:
 if (index.result()->is_constant()) {
 #ifndef MIPS64
 cmp_mem_int(lir_cond_belowEqual, buf.result(), java_nio_Buffer::limit_offset(), index.result()->as_jint(), info);
 __ branch(lir_cond_belowEqual, T_INT, stub);
 #else
 LIR_Opr left = LIR_OprFact::address(new LIR_Address( buf.result(),
 java_nio_Buffer::limit_offset(),T_INT));
 LIR_Opr right = LIR_OprFact::intConst(index.result()->as_jint());
 __ null_check_for_branch(lir_cond_belowEqual, left, right, info);
 __ branch(lir_cond_belowEqual,left, right ,T_INT, stub); // forward branch
 #endif
 } else {
 #ifndef MIPS64
 cmp_reg_mem(lir_cond_aboveEqual, index.result(), buf.result(),
 java_nio_Buffer::limit_offset(), T_INT, info);
 __ branch(lir_cond_aboveEqual, T_INT, stub);
 #else
 LIR_Opr right = LIR_OprFact::address(new LIR_Address( buf.result(), java_nio_Buffer::limit_offset(),T_INT));
 LIR_Opr left =  index.result();
 __ null_check_for_branch(lir_cond_aboveEqual, left, right, info);
 __ branch(lir_cond_aboveEqual, left, right , T_INT, stub); // forward branch
 #endif
 }
 __ move(index.result(), result);
 } else {
 // Just load the index into the result register
 if (GenerateRangeChecks && needs_range_check) {
 if (StressLoopInvariantCodeMotion && range_check_info->deoptimize_on_exception()) {
 #ifndef MIPS64
 __ branch(lir_cond_always, T_ILLEGAL, new RangeCheckStub(range_check_info, index.result()));
 #else
 tty->print_cr("LIRGenerator::do_LoadIndexed(LoadIndexed* x) unimplemented yet!");
 Unimplemented();
 #endif
 } else if (use_length) {
 // TODO: use a (modified) version of array_range_check that does not require a
 //       constant length to be loaded to a register
 #ifndef MIPS64
 assert(data->is_JumpData(), "need JumpData for branches");
 offset = md->byte_offset_of_slot(data, JumpData::taken_offset());
 }
 LIR_Opr md_reg = new_register(T_METADATA);
 __ metadata2reg(md->constant_encoding(), md_reg);
 increment_counter(new LIR_Address(md_reg, offset,
 NOT_LP64(T_INT) LP64_ONLY(T_LONG)), DataLayout::counter_increment);
 }
 // emit phi-instruction move after safepoint since this simplifies

comparison: src/share/vm/c1/c1_LIRGenerator.cpp

src/share/vm/c1/c1_LIRGenerator.cpp

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/c1/c1_LIRGenerator.cpp

src/share/vm/c1/c1_LIRGenerator.cpp