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