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 "asm/assembler.hpp"
27 #include "asm/assembler.inline.hpp"
28 #include "compiler/disassembler.hpp"
29 #include "gc_interface/collectedHeap.inline.hpp"
30 #include "interpreter/interpreter.hpp"
31 #include "memory/cardTableModRefBS.hpp"
32 #include "memory/resourceArea.hpp"
33 #include "prims/methodHandles.hpp"
34 #include "runtime/biasedLocking.hpp"
35 #include "runtime/interfaceSupport.hpp"
36 #include "runtime/objectMonitor.hpp"
37 #include "runtime/os.hpp"
38 #include "runtime/sharedRuntime.hpp"
39 #include "runtime/stubRoutines.hpp"
40 #include "utilities/macros.hpp"
41 #if INCLUDE_ALL_GCS
42 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
43 #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
44 #include "gc_implementation/g1/heapRegion.hpp"
45 #endif // INCLUDE_ALL_GCS
46
47 #ifdef PRODUCT
48 #define BLOCK_COMMENT(str) /* nothing */
49 #define STOP(error) stop(error)
50 #else
51 #define BLOCK_COMMENT(str) block_comment(str)
52 #define STOP(error) block_comment(error); stop(error)
4793 // Either restore the x87 floating pointer control word after returning
4794 // from the JNI call or verify that it wasn't changed.
4795 if (CheckJNICalls) {
4796 call(RuntimeAddress(StubRoutines::x86::verify_fpu_cntrl_wrd_entry()));
4797 }
4798 #endif // _LP64
4799 }
4800
4801
4802 void MacroAssembler::load_klass(Register dst, Register src) {
4803 #ifdef _LP64
4804 if (UseCompressedKlassPointers) {
4805 movl(dst, Address(src, oopDesc::klass_offset_in_bytes()));
4806 decode_klass_not_null(dst);
4807 } else
4808 #endif
4809 movptr(dst, Address(src, oopDesc::klass_offset_in_bytes()));
4810 }
4811
4812 void MacroAssembler::load_prototype_header(Register dst, Register src) {
4813 #ifdef _LP64
4814 if (UseCompressedKlassPointers) {
4815 assert (Universe::heap() != NULL, "java heap should be initialized");
4816 movl(dst, Address(src, oopDesc::klass_offset_in_bytes()));
4817 if (Universe::narrow_klass_shift() != 0) {
4818 assert(LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
4819 assert(LogKlassAlignmentInBytes == Address::times_8, "klass not aligned on 64bits?");
4820 movq(dst, Address(r12_heapbase, dst, Address::times_8, Klass::prototype_header_offset()));
4821 } else {
4822 movq(dst, Address(dst, Klass::prototype_header_offset()));
4823 }
4824 } else
4825 #endif
4826 {
4827 movptr(dst, Address(src, oopDesc::klass_offset_in_bytes()));
4828 movptr(dst, Address(dst, Klass::prototype_header_offset()));
4829 }
4830 }
4831
4832 void MacroAssembler::store_klass(Register dst, Register src) {
4833 #ifdef _LP64
4834 if (UseCompressedKlassPointers) {
4835 encode_klass_not_null(src);
4836 movl(Address(dst, oopDesc::klass_offset_in_bytes()), src);
4837 } else
4838 #endif
4839 movptr(Address(dst, oopDesc::klass_offset_in_bytes()), src);
4840 }
4841
4842 void MacroAssembler::load_heap_oop(Register dst, Address src) {
4843 #ifdef _LP64
4844 // FIXME: Must change all places where we try to load the klass.
4845 if (UseCompressedOops) {
4846 movl(dst, src);
4847 decode_heap_oop(dst);
4848 } else
4849 #endif
4897 if (UseCompressedOops) {
4898 movl(dst, (int32_t)NULL_WORD);
4899 } else {
4900 movslq(dst, (int32_t)NULL_WORD);
4901 }
4902 #else
4903 movl(dst, (int32_t)NULL_WORD);
4904 #endif
4905 }
4906
4907 #ifdef _LP64
4908 void MacroAssembler::store_klass_gap(Register dst, Register src) {
4909 if (UseCompressedKlassPointers) {
4910 // Store to klass gap in destination
4911 movl(Address(dst, oopDesc::klass_gap_offset_in_bytes()), src);
4912 }
4913 }
4914
4915 #ifdef ASSERT
4916 void MacroAssembler::verify_heapbase(const char* msg) {
4917 assert (UseCompressedOops || UseCompressedKlassPointers, "should be compressed");
4918 assert (Universe::heap() != NULL, "java heap should be initialized");
4919 if (CheckCompressedOops) {
4920 Label ok;
4921 push(rscratch1); // cmpptr trashes rscratch1
4922 cmpptr(r12_heapbase, ExternalAddress((address)Universe::narrow_ptrs_base_addr()));
4923 jcc(Assembler::equal, ok);
4924 STOP(msg);
4925 bind(ok);
4926 pop(rscratch1);
4927 }
4928 }
4929 #endif
4930
4931 // Algorithm must match oop.inline.hpp encode_heap_oop.
4932 void MacroAssembler::encode_heap_oop(Register r) {
4933 #ifdef ASSERT
4934 verify_heapbase("MacroAssembler::encode_heap_oop: heap base corrupted?");
4935 #endif
4936 verify_oop(r, "broken oop in encode_heap_oop");
4937 if (Universe::narrow_oop_base() == NULL) {
5041 if (LogMinObjAlignmentInBytes == Address::times_8) {
5042 leaq(dst, Address(r12_heapbase, src, Address::times_8, 0));
5043 } else {
5044 if (dst != src) {
5045 movq(dst, src);
5046 }
5047 shlq(dst, LogMinObjAlignmentInBytes);
5048 if (Universe::narrow_oop_base() != NULL) {
5049 addq(dst, r12_heapbase);
5050 }
5051 }
5052 } else {
5053 assert (Universe::narrow_oop_base() == NULL, "sanity");
5054 if (dst != src) {
5055 movq(dst, src);
5056 }
5057 }
5058 }
5059
5060 void MacroAssembler::encode_klass_not_null(Register r) {
5061 assert(Metaspace::is_initialized(), "metaspace should be initialized");
5062 #ifdef ASSERT
5063 verify_heapbase("MacroAssembler::encode_klass_not_null: heap base corrupted?");
5064 #endif
5065 if (Universe::narrow_klass_base() != NULL) {
5066 subq(r, r12_heapbase);
5067 }
5068 if (Universe::narrow_klass_shift() != 0) {
5069 assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
5070 shrq(r, LogKlassAlignmentInBytes);
5071 }
5072 }
5073
5074 void MacroAssembler::encode_klass_not_null(Register dst, Register src) {
5075 assert(Metaspace::is_initialized(), "metaspace should be initialized");
5076 #ifdef ASSERT
5077 verify_heapbase("MacroAssembler::encode_klass_not_null2: heap base corrupted?");
5078 #endif
5079 if (dst != src) {
5080 movq(dst, src);
5081 }
5082 if (Universe::narrow_klass_base() != NULL) {
5083 subq(dst, r12_heapbase);
5084 }
5085 if (Universe::narrow_klass_shift() != 0) {
5086 assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
5087 shrq(dst, LogKlassAlignmentInBytes);
5088 }
5089 }
5090
5091 void MacroAssembler::decode_klass_not_null(Register r) {
5092 assert(Metaspace::is_initialized(), "metaspace should be initialized");
5093 // Note: it will change flags
5094 assert (UseCompressedKlassPointers, "should only be used for compressed headers");
5095 // Cannot assert, unverified entry point counts instructions (see .ad file)
5096 // vtableStubs also counts instructions in pd_code_size_limit.
5097 // Also do not verify_oop as this is called by verify_oop.
5098 if (Universe::narrow_klass_shift() != 0) {
5099 assert(LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
5100 shlq(r, LogKlassAlignmentInBytes);
5101 if (Universe::narrow_klass_base() != NULL) {
5102 addq(r, r12_heapbase);
5103 }
5104 } else {
5105 assert (Universe::narrow_klass_base() == NULL, "sanity");
5106 }
5107 }
5108
5109 void MacroAssembler::decode_klass_not_null(Register dst, Register src) {
5110 assert(Metaspace::is_initialized(), "metaspace should be initialized");
5111 // Note: it will change flags
5112 assert (UseCompressedKlassPointers, "should only be used for compressed headers");
5113 // Cannot assert, unverified entry point counts instructions (see .ad file)
5114 // vtableStubs also counts instructions in pd_code_size_limit.
5115 // Also do not verify_oop as this is called by verify_oop.
5116 if (Universe::narrow_klass_shift() != 0) {
5117 assert(LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
5118 assert(LogKlassAlignmentInBytes == Address::times_8, "klass not aligned on 64bits?");
5119 leaq(dst, Address(r12_heapbase, src, Address::times_8, 0));
5120 } else {
5121 assert (Universe::narrow_klass_base() == NULL, "sanity");
5122 if (dst != src) {
5123 movq(dst, src);
5124 }
5125 }
5126 }
5127
5128 void MacroAssembler::set_narrow_oop(Register dst, jobject obj) {
5129 assert (UseCompressedOops, "should only be used for compressed headers");
5130 assert (Universe::heap() != NULL, "java heap should be initialized");
5131 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5132 int oop_index = oop_recorder()->find_index(obj);
5133 RelocationHolder rspec = oop_Relocation::spec(oop_index);
5134 mov_narrow_oop(dst, oop_index, rspec);
5135 }
5136
5137 void MacroAssembler::set_narrow_oop(Address dst, jobject obj) {
5138 assert (UseCompressedOops, "should only be used for compressed headers");
5139 assert (Universe::heap() != NULL, "java heap should be initialized");
5140 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5141 int oop_index = oop_recorder()->find_index(obj);
5142 RelocationHolder rspec = oop_Relocation::spec(oop_index);
5143 mov_narrow_oop(dst, oop_index, rspec);
5144 }
5145
5146 void MacroAssembler::set_narrow_klass(Register dst, Klass* k) {
5147 assert (UseCompressedKlassPointers, "should only be used for compressed headers");
5148 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5149 int klass_index = oop_recorder()->find_index(k);
5150 RelocationHolder rspec = metadata_Relocation::spec(klass_index);
5151 mov_narrow_oop(dst, oopDesc::encode_klass(k), rspec);
5152 }
5153
5154 void MacroAssembler::set_narrow_klass(Address dst, Klass* k) {
5155 assert (UseCompressedKlassPointers, "should only be used for compressed headers");
5156 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5157 int klass_index = oop_recorder()->find_index(k);
5158 RelocationHolder rspec = metadata_Relocation::spec(klass_index);
5159 mov_narrow_oop(dst, oopDesc::encode_klass(k), rspec);
5160 }
5161
5162 void MacroAssembler::cmp_narrow_oop(Register dst, jobject obj) {
5163 assert (UseCompressedOops, "should only be used for compressed headers");
5164 assert (Universe::heap() != NULL, "java heap should be initialized");
5165 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5166 int oop_index = oop_recorder()->find_index(obj);
5167 RelocationHolder rspec = oop_Relocation::spec(oop_index);
5168 Assembler::cmp_narrow_oop(dst, oop_index, rspec);
5169 }
5170
5171 void MacroAssembler::cmp_narrow_oop(Address dst, jobject obj) {
5172 assert (UseCompressedOops, "should only be used for compressed headers");
5173 assert (Universe::heap() != NULL, "java heap should be initialized");
5174 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5175 int oop_index = oop_recorder()->find_index(obj);
5176 RelocationHolder rspec = oop_Relocation::spec(oop_index);
5177 Assembler::cmp_narrow_oop(dst, oop_index, rspec);
5178 }
5179
5180 void MacroAssembler::cmp_narrow_klass(Register dst, Klass* k) {
5181 assert (UseCompressedKlassPointers, "should only be used for compressed headers");
5182 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5183 int klass_index = oop_recorder()->find_index(k);
5184 RelocationHolder rspec = metadata_Relocation::spec(klass_index);
5185 Assembler::cmp_narrow_oop(dst, oopDesc::encode_klass(k), rspec);
5186 }
5187
5188 void MacroAssembler::cmp_narrow_klass(Address dst, Klass* k) {
5189 assert (UseCompressedKlassPointers, "should only be used for compressed headers");
5190 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5191 int klass_index = oop_recorder()->find_index(k);
5192 RelocationHolder rspec = metadata_Relocation::spec(klass_index);
5193 Assembler::cmp_narrow_oop(dst, oopDesc::encode_klass(k), rspec);
5194 }
5195
5196 void MacroAssembler::reinit_heapbase() {
5197 if (UseCompressedOops || UseCompressedKlassPointers) {
5198 movptr(r12_heapbase, ExternalAddress((address)Universe::narrow_ptrs_base_addr()));
5199 }
5200 }
5201 #endif // _LP64
5202
5203
5204 // C2 compiled method's prolog code.
5205 void MacroAssembler::verified_entry(int framesize, bool stack_bang, bool fp_mode_24b) {
5206
5207 // WARNING: Initial instruction MUST be 5 bytes or longer so that
5208 // NativeJump::patch_verified_entry will be able to patch out the entry
5209 // code safely. The push to verify stack depth is ok at 5 bytes,
5210 // the frame allocation can be either 3 or 6 bytes. So if we don't do
5211 // stack bang then we must use the 6 byte frame allocation even if
5212 // we have no frame. :-(
5213
5214 assert((framesize & (StackAlignmentInBytes-1)) == 0, "frame size not aligned");
5215 // Remove word for return addr
5216 framesize -= wordSize;
5217
5218 // Calls to C2R adapters often do not accept exceptional returns.
5219 // We require that their callers must bang for them. But be careful, because
5220 // some VM calls (such as call site linkage) can use several kilobytes of
|
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 "asm/assembler.hpp"
27 #include "asm/assembler.inline.hpp"
28 #include "compiler/disassembler.hpp"
29 #include "gc_interface/collectedHeap.inline.hpp"
30 #include "interpreter/interpreter.hpp"
31 #include "memory/cardTableModRefBS.hpp"
32 #include "memory/resourceArea.hpp"
33 #include "memory/universe.hpp"
34 #include "prims/methodHandles.hpp"
35 #include "runtime/biasedLocking.hpp"
36 #include "runtime/interfaceSupport.hpp"
37 #include "runtime/objectMonitor.hpp"
38 #include "runtime/os.hpp"
39 #include "runtime/sharedRuntime.hpp"
40 #include "runtime/stubRoutines.hpp"
41 #include "utilities/macros.hpp"
42 #if INCLUDE_ALL_GCS
43 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
44 #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
45 #include "gc_implementation/g1/heapRegion.hpp"
46 #endif // INCLUDE_ALL_GCS
47
48 #ifdef PRODUCT
49 #define BLOCK_COMMENT(str) /* nothing */
50 #define STOP(error) stop(error)
51 #else
52 #define BLOCK_COMMENT(str) block_comment(str)
53 #define STOP(error) block_comment(error); stop(error)
4794 // Either restore the x87 floating pointer control word after returning
4795 // from the JNI call or verify that it wasn't changed.
4796 if (CheckJNICalls) {
4797 call(RuntimeAddress(StubRoutines::x86::verify_fpu_cntrl_wrd_entry()));
4798 }
4799 #endif // _LP64
4800 }
4801
4802
4803 void MacroAssembler::load_klass(Register dst, Register src) {
4804 #ifdef _LP64
4805 if (UseCompressedKlassPointers) {
4806 movl(dst, Address(src, oopDesc::klass_offset_in_bytes()));
4807 decode_klass_not_null(dst);
4808 } else
4809 #endif
4810 movptr(dst, Address(src, oopDesc::klass_offset_in_bytes()));
4811 }
4812
4813 void MacroAssembler::load_prototype_header(Register dst, Register src) {
4814 load_klass(dst, src);
4815 movptr(dst, Address(dst, Klass::prototype_header_offset()));
4816 }
4817
4818 void MacroAssembler::store_klass(Register dst, Register src) {
4819 #ifdef _LP64
4820 if (UseCompressedKlassPointers) {
4821 encode_klass_not_null(src);
4822 movl(Address(dst, oopDesc::klass_offset_in_bytes()), src);
4823 } else
4824 #endif
4825 movptr(Address(dst, oopDesc::klass_offset_in_bytes()), src);
4826 }
4827
4828 void MacroAssembler::load_heap_oop(Register dst, Address src) {
4829 #ifdef _LP64
4830 // FIXME: Must change all places where we try to load the klass.
4831 if (UseCompressedOops) {
4832 movl(dst, src);
4833 decode_heap_oop(dst);
4834 } else
4835 #endif
4883 if (UseCompressedOops) {
4884 movl(dst, (int32_t)NULL_WORD);
4885 } else {
4886 movslq(dst, (int32_t)NULL_WORD);
4887 }
4888 #else
4889 movl(dst, (int32_t)NULL_WORD);
4890 #endif
4891 }
4892
4893 #ifdef _LP64
4894 void MacroAssembler::store_klass_gap(Register dst, Register src) {
4895 if (UseCompressedKlassPointers) {
4896 // Store to klass gap in destination
4897 movl(Address(dst, oopDesc::klass_gap_offset_in_bytes()), src);
4898 }
4899 }
4900
4901 #ifdef ASSERT
4902 void MacroAssembler::verify_heapbase(const char* msg) {
4903 assert (UseCompressedOops, "should be compressed");
4904 assert (Universe::heap() != NULL, "java heap should be initialized");
4905 if (CheckCompressedOops) {
4906 Label ok;
4907 push(rscratch1); // cmpptr trashes rscratch1
4908 cmpptr(r12_heapbase, ExternalAddress((address)Universe::narrow_ptrs_base_addr()));
4909 jcc(Assembler::equal, ok);
4910 STOP(msg);
4911 bind(ok);
4912 pop(rscratch1);
4913 }
4914 }
4915 #endif
4916
4917 // Algorithm must match oop.inline.hpp encode_heap_oop.
4918 void MacroAssembler::encode_heap_oop(Register r) {
4919 #ifdef ASSERT
4920 verify_heapbase("MacroAssembler::encode_heap_oop: heap base corrupted?");
4921 #endif
4922 verify_oop(r, "broken oop in encode_heap_oop");
4923 if (Universe::narrow_oop_base() == NULL) {
5027 if (LogMinObjAlignmentInBytes == Address::times_8) {
5028 leaq(dst, Address(r12_heapbase, src, Address::times_8, 0));
5029 } else {
5030 if (dst != src) {
5031 movq(dst, src);
5032 }
5033 shlq(dst, LogMinObjAlignmentInBytes);
5034 if (Universe::narrow_oop_base() != NULL) {
5035 addq(dst, r12_heapbase);
5036 }
5037 }
5038 } else {
5039 assert (Universe::narrow_oop_base() == NULL, "sanity");
5040 if (dst != src) {
5041 movq(dst, src);
5042 }
5043 }
5044 }
5045
5046 void MacroAssembler::encode_klass_not_null(Register r) {
5047 assert(Universe::narrow_klass_base() != NULL, "Base should be initialized");
5048 // Use r12 as a scratch register in which to temporarily load the narrow_klass_base.
5049 assert(r != r12_heapbase, "Encoding a klass in r12");
5050 mov64(r12_heapbase, (int64_t)Universe::narrow_klass_base());
5051 subq(r, r12_heapbase);
5052 if (Universe::narrow_klass_shift() != 0) {
5053 assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
5054 shrq(r, LogKlassAlignmentInBytes);
5055 }
5056 reinit_heapbase();
5057 }
5058
5059 void MacroAssembler::encode_klass_not_null(Register dst, Register src) {
5060 if (dst == src) {
5061 encode_klass_not_null(src);
5062 } else {
5063 mov64(dst, (int64_t)Universe::narrow_klass_base());
5064 negq(dst);
5065 addq(dst, src);
5066 if (Universe::narrow_klass_shift() != 0) {
5067 assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
5068 shrq(dst, LogKlassAlignmentInBytes);
5069 }
5070 }
5071 }
5072
5073 // Function instr_size_for_decode_klass_not_null() counts the instructions
5074 // generated by decode_klass_not_null(register r) and reinit_heapbase(),
5075 // when (Universe::heap() != NULL). Hence, if the instructions they
5076 // generate change, then this method needs to be updated.
5077 int MacroAssembler::instr_size_for_decode_klass_not_null() {
5078 assert (UseCompressedKlassPointers, "only for compressed klass ptrs");
5079 // mov64 + addq + shlq? + mov64 (for reinit_heapbase()).
5080 return (Universe::narrow_klass_shift() == 0 ? 20 : 24);
5081 }
5082
5083 // !!! If the instructions that get generated here change then function
5084 // instr_size_for_decode_klass_not_null() needs to get updated.
5085 void MacroAssembler::decode_klass_not_null(Register r) {
5086 // Note: it will change flags
5087 assert(Universe::narrow_klass_base() != NULL, "Base should be initialized");
5088 assert (UseCompressedKlassPointers, "should only be used for compressed headers");
5089 assert(r != r12_heapbase, "Decoding a klass in r12");
5090 // Cannot assert, unverified entry point counts instructions (see .ad file)
5091 // vtableStubs also counts instructions in pd_code_size_limit.
5092 // Also do not verify_oop as this is called by verify_oop.
5093 if (Universe::narrow_klass_shift() != 0) {
5094 assert(LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
5095 shlq(r, LogKlassAlignmentInBytes);
5096 }
5097 // Use r12 as a scratch register in which to temporarily load the narrow_klass_base.
5098 mov64(r12_heapbase, (int64_t)Universe::narrow_klass_base());
5099 addq(r, r12_heapbase);
5100 reinit_heapbase();
5101 }
5102
5103 void MacroAssembler::decode_klass_not_null(Register dst, Register src) {
5104 // Note: it will change flags
5105 assert(Universe::narrow_klass_base() != NULL, "Base should be initialized");
5106 assert (UseCompressedKlassPointers, "should only be used for compressed headers");
5107 if (dst == src) {
5108 decode_klass_not_null(dst);
5109 } else {
5110 // Cannot assert, unverified entry point counts instructions (see .ad file)
5111 // vtableStubs also counts instructions in pd_code_size_limit.
5112 // Also do not verify_oop as this is called by verify_oop.
5113
5114 mov64(dst, (int64_t)Universe::narrow_klass_base());
5115 if (Universe::narrow_klass_shift() != 0) {
5116 assert(LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
5117 assert(LogKlassAlignmentInBytes == Address::times_8, "klass not aligned on 64bits?");
5118 leaq(dst, Address(dst, src, Address::times_8, 0));
5119 } else {
5120 addq(dst, src);
5121 }
5122 }
5123 }
5124
5125 void MacroAssembler::set_narrow_oop(Register dst, jobject obj) {
5126 assert (UseCompressedOops, "should only be used for compressed headers");
5127 assert (Universe::heap() != NULL, "java heap should be initialized");
5128 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5129 int oop_index = oop_recorder()->find_index(obj);
5130 RelocationHolder rspec = oop_Relocation::spec(oop_index);
5131 mov_narrow_oop(dst, oop_index, rspec);
5132 }
5133
5134 void MacroAssembler::set_narrow_oop(Address dst, jobject obj) {
5135 assert (UseCompressedOops, "should only be used for compressed headers");
5136 assert (Universe::heap() != NULL, "java heap should be initialized");
5137 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5138 int oop_index = oop_recorder()->find_index(obj);
5139 RelocationHolder rspec = oop_Relocation::spec(oop_index);
5140 mov_narrow_oop(dst, oop_index, rspec);
5141 }
5142
5143 void MacroAssembler::set_narrow_klass(Register dst, Klass* k) {
5144 assert (UseCompressedKlassPointers, "should only be used for compressed headers");
5145 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5146 int klass_index = oop_recorder()->find_index(k);
5147 RelocationHolder rspec = metadata_Relocation::spec(klass_index);
5148 mov_narrow_oop(dst, Klass::encode_klass(k), rspec);
5149 }
5150
5151 void MacroAssembler::set_narrow_klass(Address dst, Klass* k) {
5152 assert (UseCompressedKlassPointers, "should only be used for compressed headers");
5153 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5154 int klass_index = oop_recorder()->find_index(k);
5155 RelocationHolder rspec = metadata_Relocation::spec(klass_index);
5156 mov_narrow_oop(dst, Klass::encode_klass(k), rspec);
5157 }
5158
5159 void MacroAssembler::cmp_narrow_oop(Register dst, jobject obj) {
5160 assert (UseCompressedOops, "should only be used for compressed headers");
5161 assert (Universe::heap() != NULL, "java heap should be initialized");
5162 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5163 int oop_index = oop_recorder()->find_index(obj);
5164 RelocationHolder rspec = oop_Relocation::spec(oop_index);
5165 Assembler::cmp_narrow_oop(dst, oop_index, rspec);
5166 }
5167
5168 void MacroAssembler::cmp_narrow_oop(Address dst, jobject obj) {
5169 assert (UseCompressedOops, "should only be used for compressed headers");
5170 assert (Universe::heap() != NULL, "java heap should be initialized");
5171 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5172 int oop_index = oop_recorder()->find_index(obj);
5173 RelocationHolder rspec = oop_Relocation::spec(oop_index);
5174 Assembler::cmp_narrow_oop(dst, oop_index, rspec);
5175 }
5176
5177 void MacroAssembler::cmp_narrow_klass(Register dst, Klass* k) {
5178 assert (UseCompressedKlassPointers, "should only be used for compressed headers");
5179 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5180 int klass_index = oop_recorder()->find_index(k);
5181 RelocationHolder rspec = metadata_Relocation::spec(klass_index);
5182 Assembler::cmp_narrow_oop(dst, Klass::encode_klass(k), rspec);
5183 }
5184
5185 void MacroAssembler::cmp_narrow_klass(Address dst, Klass* k) {
5186 assert (UseCompressedKlassPointers, "should only be used for compressed headers");
5187 assert (oop_recorder() != NULL, "this assembler needs an OopRecorder");
5188 int klass_index = oop_recorder()->find_index(k);
5189 RelocationHolder rspec = metadata_Relocation::spec(klass_index);
5190 Assembler::cmp_narrow_oop(dst, Klass::encode_klass(k), rspec);
5191 }
5192
5193 void MacroAssembler::reinit_heapbase() {
5194 if (UseCompressedOops || UseCompressedKlassPointers) {
5195 if (Universe::heap() != NULL) {
5196 if (Universe::narrow_oop_base() == NULL) {
5197 MacroAssembler::xorptr(r12_heapbase, r12_heapbase);
5198 } else {
5199 mov64(r12_heapbase, (int64_t)Universe::narrow_ptrs_base());
5200 }
5201 } else {
5202 movptr(r12_heapbase, ExternalAddress((address)Universe::narrow_ptrs_base_addr()));
5203 }
5204 }
5205 }
5206
5207 #endif // _LP64
5208
5209
5210 // C2 compiled method's prolog code.
5211 void MacroAssembler::verified_entry(int framesize, bool stack_bang, bool fp_mode_24b) {
5212
5213 // WARNING: Initial instruction MUST be 5 bytes or longer so that
5214 // NativeJump::patch_verified_entry will be able to patch out the entry
5215 // code safely. The push to verify stack depth is ok at 5 bytes,
5216 // the frame allocation can be either 3 or 6 bytes. So if we don't do
5217 // stack bang then we must use the 6 byte frame allocation even if
5218 // we have no frame. :-(
5219
5220 assert((framesize & (StackAlignmentInBytes-1)) == 0, "frame size not aligned");
5221 // Remove word for return addr
5222 framesize -= wordSize;
5223
5224 // Calls to C2R adapters often do not accept exceptional returns.
5225 // We require that their callers must bang for them. But be careful, because
5226 // some VM calls (such as call site linkage) can use several kilobytes of
|