2006 #ifdef ASSERT
2007 intptr_t dist = (intptr_t)entry - ((intptr_t)pc() + short_size);
2008 intptr_t delta = short_branch_delta();
2009 if (delta != 0) {
2010 dist += (dist < 0 ? (-delta) :delta);
2011 }
2012 assert(is8bit(dist), "Dispacement too large for a short jmp");
2013 #endif
2014 intptr_t offs = (intptr_t)entry - (intptr_t)pc();
2015 // 0111 tttn #8-bit disp
2016 emit_int8(0x70 | cc);
2017 emit_int8((offs - short_size) & 0xFF);
2018 } else {
2019 InstructionMark im(this);
2020 L.add_patch_at(code(), locator());
2021 emit_int8(0x70 | cc);
2022 emit_int8(0);
2023 }
2024 }
2025
2026 void Assembler::jccb_if_possible(Condition cc, Label& L) {
2027
2028 #ifdef ASSERT
2029 if (UseShenandoahGC) {
2030 jcc(cc, L);
2031 } else
2032 #endif
2033 jccb(cc, L);
2034 }
2035
2036 void Assembler::jmp(Address adr) {
2037 InstructionMark im(this);
2038 prefix(adr);
2039 emit_int8((unsigned char)0xFF);
2040 emit_operand(rsp, adr);
2041 }
2042
2043 void Assembler::jmp(Label& L, bool maybe_short) {
2044 if (L.is_bound()) {
2045 address entry = target(L);
2046 assert(entry != NULL, "jmp most probably wrong");
2047 InstructionMark im(this);
2048 const int short_size = 2;
2049 const int long_size = 5;
2050 intptr_t offs = entry - pc();
2051 if (maybe_short && is8bit(offs - short_size)) {
2052 emit_int8((unsigned char)0xEB);
2053 emit_int8((offs - short_size) & 0xFF);
2054 } else {
2055 emit_int8((unsigned char)0xE9);
2087 const int short_size = 2;
2088 address entry = target(L);
2089 assert(entry != NULL, "jmp most probably wrong");
2090 #ifdef ASSERT
2091 intptr_t dist = (intptr_t)entry - ((intptr_t)pc() + short_size);
2092 intptr_t delta = short_branch_delta();
2093 if (delta != 0) {
2094 dist += (dist < 0 ? (-delta) :delta);
2095 }
2096 assert(is8bit(dist), "Dispacement too large for a short jmp");
2097 #endif
2098 intptr_t offs = entry - pc();
2099 emit_int8((unsigned char)0xEB);
2100 emit_int8((offs - short_size) & 0xFF);
2101 } else {
2102 InstructionMark im(this);
2103 L.add_patch_at(code(), locator());
2104 emit_int8((unsigned char)0xEB);
2105 emit_int8(0);
2106 }
2107 }
2108
2109 void Assembler::jmpb_if_possible(Label& L) {
2110
2111 #ifdef ASSERT
2112 if (UseShenandoahGC) {
2113 jmp(L);
2114 } else
2115 #endif
2116 jmpb(L);
2117 }
2118
2119 void Assembler::ldmxcsr( Address src) {
2120 if (UseAVX > 0 ) {
2121 InstructionMark im(this);
2122 InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
2123 vex_prefix(src, 0, 0, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
2124 emit_int8((unsigned char)0xAE);
2125 emit_operand(as_Register(2), src);
2126 } else {
2127 NOT_LP64(assert(VM_Version::supports_sse(), ""));
2128 InstructionMark im(this);
2129 prefix(src);
2130 emit_int8(0x0F);
2131 emit_int8((unsigned char)0xAE);
2132 emit_operand(as_Register(2), src);
2133 }
2134 }
2135
2136 void Assembler::leal(Register dst, Address src) {
|
2006 #ifdef ASSERT
2007 intptr_t dist = (intptr_t)entry - ((intptr_t)pc() + short_size);
2008 intptr_t delta = short_branch_delta();
2009 if (delta != 0) {
2010 dist += (dist < 0 ? (-delta) :delta);
2011 }
2012 assert(is8bit(dist), "Dispacement too large for a short jmp");
2013 #endif
2014 intptr_t offs = (intptr_t)entry - (intptr_t)pc();
2015 // 0111 tttn #8-bit disp
2016 emit_int8(0x70 | cc);
2017 emit_int8((offs - short_size) & 0xFF);
2018 } else {
2019 InstructionMark im(this);
2020 L.add_patch_at(code(), locator());
2021 emit_int8(0x70 | cc);
2022 emit_int8(0);
2023 }
2024 }
2025
2026 void Assembler::jmp(Address adr) {
2027 InstructionMark im(this);
2028 prefix(adr);
2029 emit_int8((unsigned char)0xFF);
2030 emit_operand(rsp, adr);
2031 }
2032
2033 void Assembler::jmp(Label& L, bool maybe_short) {
2034 if (L.is_bound()) {
2035 address entry = target(L);
2036 assert(entry != NULL, "jmp most probably wrong");
2037 InstructionMark im(this);
2038 const int short_size = 2;
2039 const int long_size = 5;
2040 intptr_t offs = entry - pc();
2041 if (maybe_short && is8bit(offs - short_size)) {
2042 emit_int8((unsigned char)0xEB);
2043 emit_int8((offs - short_size) & 0xFF);
2044 } else {
2045 emit_int8((unsigned char)0xE9);
2077 const int short_size = 2;
2078 address entry = target(L);
2079 assert(entry != NULL, "jmp most probably wrong");
2080 #ifdef ASSERT
2081 intptr_t dist = (intptr_t)entry - ((intptr_t)pc() + short_size);
2082 intptr_t delta = short_branch_delta();
2083 if (delta != 0) {
2084 dist += (dist < 0 ? (-delta) :delta);
2085 }
2086 assert(is8bit(dist), "Dispacement too large for a short jmp");
2087 #endif
2088 intptr_t offs = entry - pc();
2089 emit_int8((unsigned char)0xEB);
2090 emit_int8((offs - short_size) & 0xFF);
2091 } else {
2092 InstructionMark im(this);
2093 L.add_patch_at(code(), locator());
2094 emit_int8((unsigned char)0xEB);
2095 emit_int8(0);
2096 }
2097 }
2098
2099 void Assembler::ldmxcsr( Address src) {
2100 if (UseAVX > 0 ) {
2101 InstructionMark im(this);
2102 InstructionAttr attributes(AVX_128bit, /* vex_w */ false, /* legacy_mode */ true, /* no_mask_reg */ true, /* uses_vl */ false);
2103 vex_prefix(src, 0, 0, VEX_SIMD_NONE, VEX_OPCODE_0F, &attributes);
2104 emit_int8((unsigned char)0xAE);
2105 emit_operand(as_Register(2), src);
2106 } else {
2107 NOT_LP64(assert(VM_Version::supports_sse(), ""));
2108 InstructionMark im(this);
2109 prefix(src);
2110 emit_int8(0x0F);
2111 emit_int8((unsigned char)0xAE);
2112 emit_operand(as_Register(2), src);
2113 }
2114 }
2115
2116 void Assembler::leal(Register dst, Address src) {
|