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

comparison: src/cpu/mips/vm/c1_LIRAssembler_mips.cpp

src/cpu/mips/vm/c1_LIRAssembler_mips.cpp

changeset 9167
1336d592e5b8
parent 9165
684adf8d599c
child 9174
e68eb4b91646
equal deleted inserted replaced
9166:7aec3140c7b6 9167:1336d592e5b8
1 /* 1 /*
2 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved. 2 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2015, 2016, Loongson Technology. All rights reserved. 3 * Copyright (c) 2015, 2018, Loongson Technology. All rights reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 * 5 *
6 * This code is free software; you can redistribute it and/or modify it 6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as 7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation. 8 * published by the Free Software Foundation.
5744 __ st_ptr(AT, counter_addr); 5744 __ st_ptr(AT, counter_addr);
5745 } 5745 }
5746 } 5746 }
5747 5747
5748 void LIR_Assembler::emit_profile_type(LIR_OpProfileType* op) { 5748 void LIR_Assembler::emit_profile_type(LIR_OpProfileType* op) {
5749 // Newly added in OpenJDK 8 5749 Register obj = op->obj()->as_register();
5750 Unimplemented(); 5750 Register tmp = op->tmp()->as_pointer_register();
5751 Register tmp1 = T1;
5752 Address mdo_addr = as_Address(op->mdp()->as_address_ptr());
5753 ciKlass* exact_klass = op->exact_klass();
5754 intptr_t current_klass = op->current_klass();
5755 bool not_null = op->not_null();
5756 bool no_conflict = op->no_conflict();
5757
5758 Label update, next, none;
5759
5760 bool do_null = !not_null;
5761 bool exact_klass_set = exact_klass != NULL && ciTypeEntries::valid_ciklass(current_klass) == exact_klass;
5762 bool do_update = !TypeEntries::is_type_unknown(current_klass) && !exact_klass_set;
5763
5764 assert(do_null || do_update, "why are we here?");
5765 assert(!TypeEntries::was_null_seen(current_klass) || do_update, "why are we here?");
5766
5767 __ verify_oop(obj);
5768
5769 if (tmp != obj) {
5770 __ move(tmp, obj);
5771 }
5772 if (do_null) {
5773 __ bne(tmp, R0, update);
5774 __ delayed()->nop();
5775 if (!TypeEntries::was_null_seen(current_klass)) {
5776 __ push(tmp1);
5777 if (mdo_addr.index() == noreg) {
5778 __ ld(tmp1, mdo_addr);
5779 } else {
5780 guarantee(tmp1 != mdo_addr.base(), "The base register will be corrupted !");
5781 guarantee(tmp1 != mdo_addr.index(), "The index register will be corrupted !");
5782
5783 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
5784 __ daddu(AT, AT, mdo_addr.base());
5785 __ ld(tmp1, AT, mdo_addr.disp());
5786 }
5787 __ li(AT, TypeEntries::null_seen);
5788 __ orr(AT, tmp1, AT);
5789 if (mdo_addr.index() == noreg) {
5790 __ sd(AT, mdo_addr);
5791 } else {
5792 guarantee(tmp1 != mdo_addr.base(), "The base register will be corrupted !");
5793 guarantee(tmp1 != mdo_addr.index(), "The index register will be corrupted !");
5794
5795 __ dsll(tmp1, mdo_addr.index(), mdo_addr.scale());
5796 __ daddu(tmp1, tmp1, mdo_addr.base());
5797 __ sd(AT, tmp1, mdo_addr.disp());
5798 }
5799 __ pop(tmp1);
5800
5801 }
5802 if (do_update) {
5803 #ifndef ASSERT
5804 __ b(next);
5805 __ delayed()->nop();
5806 }
5807 #else
5808 __ b(next);
5809 __ delayed()->nop();
5810 }
5811 } else {
5812 __ bne(tmp, R0, update);
5813 __ delayed()->nop();
5814 __ stop("unexpect null obj");
5815 #endif
5816 }
5817
5818 __ bind(update);
5819
5820 if (do_update) {
5821 #ifdef ASSERT
5822 if (exact_klass != NULL) {
5823 Label ok;
5824 __ load_klass(tmp, tmp);
5825 __ push(tmp);
5826 __ mov_metadata(tmp, exact_klass->constant_encoding());
5827 __ ld(AT, Address(SP, 0));
5828 __ beq(tmp, AT, ok);
5829 __ delayed()->nop();
5830 __ stop("exact klass and actual klass differ");
5831 __ bind(ok);
5832 __ pop(tmp);
5833 }
5834 #endif
5835 if (!no_conflict) {
5836 if (exact_klass == NULL || TypeEntries::is_type_none(current_klass)) {
5837 if (exact_klass != NULL) {
5838 __ mov_metadata(tmp, exact_klass->constant_encoding());
5839 } else {
5840 __ load_klass(tmp, tmp);
5841 }
5842
5843 if (mdo_addr.index() == noreg) {
5844 __ ld(AT, mdo_addr);
5845 } else {
5846 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
5847 __ daddu(AT, AT, mdo_addr.base());
5848 __ ld(AT, AT, mdo_addr.disp());
5849 }
5850 __ xorr(tmp, tmp, AT);
5851 __ li(AT, TypeEntries::type_klass_mask);
5852 __ andr(AT, tmp, AT);
5853 // klass seen before, nothing to do. The unknown bit may have been
5854 // set already but no need to check.
5855 __ beq(AT, R0, next);
5856 __ delayed()->nop();
5857
5858 __ li(AT, TypeEntries::type_unknown);
5859 __ andr(AT, tmp, AT);
5860 __ bne(AT, R0, next); // already unknown. Nothing to do anymore.
5861 __ delayed()->nop();
5862
5863 if (TypeEntries::is_type_none(current_klass)) {
5864 if (mdo_addr.index() == noreg) {
5865 __ ld(AT, mdo_addr);
5866 } else {
5867 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
5868 __ daddu(AT, AT, mdo_addr.base());
5869 __ ld(AT, AT, mdo_addr.disp());
5870 }
5871 __ beq(AT, R0, none);
5872 __ delayed()->nop();
5873
5874 __ push(tmp1);
5875 if (mdo_addr.index() == noreg) {
5876 __ ld(tmp1, mdo_addr);
5877 } else {
5878 guarantee(tmp1 != mdo_addr.base(), "The base register will be corrupted !");
5879 guarantee(tmp1 != mdo_addr.index(), "The index register will be corrupted !");
5880
5881 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
5882 __ daddu(AT, AT, mdo_addr.base());
5883 __ ld(tmp1, AT, mdo_addr.disp());
5884 }
5885 __ li(AT, TypeEntries::null_seen);
5886 __ subu(AT, AT, tmp1);
5887 __ pop(tmp1);
5888 __ beq(AT, R0, none);
5889 __ delayed()->nop();
5890 // There is a chance that the checks above (re-reading profiling
5891 // data from memory) fail if another thread has just set the
5892 // profiling to this obj's klass
5893
5894 if (mdo_addr.index() == noreg) {
5895 __ ld(AT, mdo_addr);
5896 } else {
5897 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
5898 __ daddu(AT, AT, mdo_addr.base());
5899 __ ld(AT, AT, mdo_addr.disp());
5900 }
5901 __ xorr(tmp, tmp, AT);
5902 __ li(AT, TypeEntries::type_klass_mask);
5903 __ andr(AT, tmp, AT);
5904 __ beq(AT, R0, next);
5905 __ delayed()->nop();
5906 }
5907 } else {
5908 assert(ciTypeEntries::valid_ciklass(current_klass) != NULL &&
5909 ciTypeEntries::valid_ciklass(current_klass) != exact_klass, "conflict only");
5910 if (mdo_addr.index() == noreg) {
5911 __ ld(tmp, mdo_addr);
5912 } else {
5913 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
5914 __ daddu(AT, AT, mdo_addr.base());
5915 __ ld(tmp, AT, mdo_addr.disp());
5916 }
5917 __ li(AT, TypeEntries::type_unknown);
5918 __ andr(AT, tmp, AT);
5919 __ bne(AT, R0, next); // already unknown. Nothing to do anymore.
5920 __ delayed()->nop();
5921 }
5922
5923 // different than before. Cannot keep accurate profile.
5924 __ push(tmp1);
5925 if (mdo_addr.index() == noreg) {
5926 __ ld(tmp1, mdo_addr);
5927 } else {
5928 guarantee(tmp1 != mdo_addr.base(), "The base register will be corrupted !");
5929 guarantee(tmp1 != mdo_addr.index(), "The index register will be corrupted !");
5930
5931 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
5932 __ daddu(AT, AT, mdo_addr.base());
5933 __ ld(tmp1, AT, mdo_addr.disp());
5934 }
5935 __ li(AT, TypeEntries::type_unknown);
5936 __ orr(AT, tmp1, AT);
5937 if (mdo_addr.index() == noreg) {
5938 __ sd(AT, mdo_addr);
5939 } else {
5940 guarantee(tmp1 != mdo_addr.base(), "The base register will be corrupted !");
5941 guarantee(tmp1 != mdo_addr.index(), "The index register will be corrupted !");
5942
5943 __ dsll(tmp1, mdo_addr.index(), mdo_addr.scale());
5944 __ daddu(tmp1, tmp1, mdo_addr.base());
5945 __ sd(AT, tmp1, mdo_addr.disp());
5946 }
5947 __ pop(tmp1);
5948
5949 if (TypeEntries::is_type_none(current_klass)) {
5950 __ b(next);
5951 __ delayed()->nop();
5952
5953 __ bind(none);
5954 // first time here. Set profile type.
5955 if (mdo_addr.index() == noreg) {
5956 __ sd(tmp, mdo_addr);
5957 } else {
5958 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
5959 __ daddu(AT, AT, mdo_addr.base());
5960 __ sd(tmp, AT, mdo_addr.disp());
5961 }
5962 }
5963 } else {
5964 // There's a single possible klass at this profile point
5965 assert(exact_klass != NULL, "should be");
5966 if (TypeEntries::is_type_none(current_klass)) {
5967 __ mov_metadata(tmp, exact_klass->constant_encoding());
5968 if (mdo_addr.index() == noreg) {
5969 __ ld(AT, mdo_addr);
5970 } else {
5971 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
5972 __ daddu(AT, AT, mdo_addr.base());
5973 __ ld(AT, AT, mdo_addr.disp());
5974 }
5975 __ xorr(tmp, tmp, AT);
5976 __ li(AT, TypeEntries::type_klass_mask);
5977 __ andr(AT, tmp, AT);
5978 #ifdef ASSERT
5979 __ beq_far(AT, R0, next);
5980 __ delayed()->nop();
5981
5982 {
5983 Label ok;
5984 __ push(tmp);
5985 if (mdo_addr.index() == noreg) {
5986 __ ld(AT, mdo_addr);
5987 } else {
5988 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
5989 __ daddu(AT, AT, mdo_addr.base());
5990 __ ld(AT, AT, mdo_addr.disp());
5991 }
5992 __ beq_far(AT, R0, ok);
5993 __ delayed()->nop();
5994
5995 __ push(tmp1);
5996 if (mdo_addr.index() == noreg) {
5997 __ ld(tmp1, mdo_addr);
5998 } else {
5999 guarantee(tmp1 != mdo_addr.base(), "The base register will be corrupted !");
6000 guarantee(tmp1 != mdo_addr.index(), "The index register will be corrupted !");
6001
6002 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
6003 __ daddu(AT, AT, mdo_addr.base());
6004 __ ld(tmp1, AT, mdo_addr.disp());
6005 }
6006 __ li(AT, TypeEntries::null_seen);
6007 __ subu(AT, AT, tmp1);
6008 __ pop(tmp1);
6009 __ beq_far(AT, R0, ok);
6010 __ delayed()->nop();
6011 // may have been set by another thread
6012 __ mov_metadata(tmp, exact_klass->constant_encoding());
6013 if (mdo_addr.index() == noreg) {
6014 __ ld(AT, mdo_addr);
6015 } else {
6016 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
6017 __ daddu(AT, AT, mdo_addr.base());
6018 __ ld(AT, AT, mdo_addr.disp());
6019 }
6020 __ xorr(tmp, tmp, AT);
6021 __ li(AT, TypeEntries::type_mask);
6022 __ andr(AT, tmp, AT);
6023 __ beq_far(AT, R0, ok);
6024 __ delayed()->nop();
6025
6026 __ stop("unexpected profiling mismatch");
6027 __ bind(ok);
6028 __ pop(tmp);
6029 }
6030 #else
6031 __ beq(AT, R0, next);
6032 __ delayed()->nop();
6033 #endif
6034 // first time here. Set profile type.
6035 if (mdo_addr.index() == noreg) {
6036 __ sd(tmp, mdo_addr);
6037 } else {
6038 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
6039 __ daddu(AT, AT, mdo_addr.base());
6040 __ sd(tmp, AT, mdo_addr.disp());
6041 }
6042 } else {
6043 assert(ciTypeEntries::valid_ciklass(current_klass) != NULL &&
6044 ciTypeEntries::valid_ciklass(current_klass) != exact_klass, "inconsistent");
6045
6046 if (mdo_addr.index() == noreg) {
6047 __ ld(tmp, mdo_addr);
6048 } else {
6049 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
6050 __ daddu(AT, AT, mdo_addr.base());
6051 __ ld(tmp, AT, mdo_addr.disp());
6052 }
6053 __ li(AT, TypeEntries::type_unknown);
6054 __ andr(AT, tmp, AT);
6055 __ bne(AT, R0, next); // already unknown. Nothing to do anymore.
6056 __ delayed()->nop();
6057
6058 __ push(tmp1);
6059 if (mdo_addr.index() == noreg) {
6060 __ ld(tmp1, mdo_addr);
6061 } else {
6062 guarantee(tmp1 != mdo_addr.base(), "The base register will be corrupted !");
6063 guarantee(tmp1 != mdo_addr.index(), "The index register will be corrupted !");
6064
6065 __ dsll(AT, mdo_addr.index(), mdo_addr.scale());
6066 __ daddu(AT, AT, mdo_addr.base());
6067 __ ld(tmp1, AT, mdo_addr.disp());
6068 }
6069 __ li(AT, TypeEntries::type_unknown);
6070 __ orr(AT, tmp1, AT);
6071 if (mdo_addr.index() == noreg) {
6072 __ sd(AT, mdo_addr);
6073 } else {
6074 guarantee(tmp1 != mdo_addr.base(), "The base register will be corrupted !");
6075 guarantee(tmp1 != mdo_addr.index(), "The index register will be corrupted !");
6076
6077 __ dsll(tmp1, mdo_addr.index(), mdo_addr.scale());
6078 __ daddu(tmp1, tmp1, mdo_addr.base());
6079 __ sd(AT, tmp1, mdo_addr.disp());
6080 }
6081 __ pop(tmp1);
6082 }
6083 }
6084
6085 __ bind(next);
6086 }
5751 } 6087 }
5752 6088
5753 void LIR_Assembler::emit_delay(LIR_OpDelay*) { 6089 void LIR_Assembler::emit_delay(LIR_OpDelay*) {
5754 Unimplemented(); 6090 Unimplemented();
5755 } 6091 }

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial