stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8214206: Fix for JDK-8213419 is broken on 32-bit

Browse Source 
Reviewed-by: mdoerr, shade
This commit is contained in:
Roland Westrelin 2018-11-22 17:25:47 +01:00
parent bde8307cf9
commit e530ca5cc2
12 changed files with 36 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/hotspot/cpu/ppc/c1_LIRGenerator_ppc.cpp
View File

@ -292,11 +292,11 @@ void LIRGenerator::cmp_reg_mem(LIR_Condition condition, LIR_Opr reg, LIR_Opr bas
bool LIRGenerator::strength_reduce_multiply(LIR_Opr left, int c, LIR_Opr result, LIR_Opr tmp) {
assert(left != result, "should be different registers");
if (is_power_of_2(c + 1)) {
__ shift_left(left, log2_intptr(c + 1), result);
__ shift_left(left, log2_int(c + 1), result);
__ sub(result, left, result);
return true;
} else if (is_power_of_2(c - 1)) {
__ shift_left(left, log2_intptr(c - 1), result);
__ shift_left(left, log2_int(c - 1), result);
__ add(result, left, result);
return true;
}

4
src/hotspot/cpu/s390/c1_LIRGenerator_s390.cpp
View File

@ -227,12 +227,12 @@ bool LIRGenerator::strength_reduce_multiply(LIR_Opr left, int c, LIR_Opr result,
if (tmp->is_valid()) {
if (is_power_of_2(c + 1)) {
__ move(left, tmp);
__ shift_left(left, log2_intptr(c + 1), left);
__ shift_left(left, log2_int(c + 1), left);
__ sub(left, tmp, result);
return true;
} else if (is_power_of_2(c - 1)) {
__ move(left, tmp);
__ shift_left(left, log2_intptr(c - 1), left);
__ shift_left(left, log2_int(c - 1), left);
__ add(left, tmp, result);
return true;
}

2
src/hotspot/cpu/sparc/c1_LIRAssembler_sparc.cpp
View File

@ -502,7 +502,7 @@ void LIR_Assembler::emit_op3(LIR_Op3* op) {
__ and3(Rscratch, divisor - 1, Rscratch);
}
__ add(Rdividend, Rscratch, Rscratch);
__ sra(Rscratch, log2_intptr(divisor), Rresult);
__ sra(Rscratch, log2_int(divisor), Rresult);
return;
} else {
if (divisor == 2) {

4
src/hotspot/cpu/sparc/c1_LIRGenerator_sparc.cpp
View File

@ -284,11 +284,11 @@ void LIRGenerator::cmp_reg_mem(LIR_Condition condition, LIR_Opr reg, LIR_Opr bas
bool LIRGenerator::strength_reduce_multiply(LIR_Opr left, int c, LIR_Opr result, LIR_Opr tmp) {
assert(left != result, "should be different registers");
if (is_power_of_2(c + 1)) {
__ shift_left(left, log2_intptr(c + 1), result);
__ shift_left(left, log2_int(c + 1), result);
__ sub(result, left, result);
return true;
} else if (is_power_of_2(c - 1)) {
__ shift_left(left, log2_intptr(c - 1), result);
__ shift_left(left, log2_int(c - 1), result);
__ add(result, left, result);
return true;
}

4
src/hotspot/cpu/x86/c1_LIRAssembler_x86.cpp
View File

@ -2555,7 +2555,7 @@ void LIR_Assembler::arithmetic_idiv(LIR_Code code, LIR_Opr left, LIR_Opr right,
Register dreg = result->as_register();
if (right->is_constant()) {
int divisor = right->as_constant_ptr()->as_jint();
jint divisor = right->as_constant_ptr()->as_jint();
assert(divisor > 0 && is_power_of_2(divisor), "must be");
if (code == lir_idiv) {
assert(lreg == rax, "must be rax,");
@ -2567,7 +2567,7 @@ void LIR_Assembler::arithmetic_idiv(LIR_Code code, LIR_Opr left, LIR_Opr right,
__ andl(rdx, divisor - 1);
__ addl(lreg, rdx);
}
__ sarl(lreg, log2_intptr(divisor));
__ sarl(lreg, log2_jint(divisor));
move_regs(lreg, dreg);
} else if (code == lir_irem) {
Label done;

4
src/hotspot/cpu/x86/c1_LIRGenerator_x86.cpp
View File

@ -244,12 +244,12 @@ bool LIRGenerator::strength_reduce_multiply(LIR_Opr left, jint c, LIR_Opr result
if (tmp->is_valid() && c > 0 && c < max_jint) {
if (is_power_of_2(c + 1)) {
__ move(left, tmp);
__ shift_left(left, log2_intptr(c + 1), left);
__ shift_left(left, log2_jint(c + 1), left);
__ sub(left, tmp, result);
return true;
} else if (is_power_of_2(c - 1)) {
__ move(left, tmp);
__ shift_left(left, log2_intptr(c - 1), left);
__ shift_left(left, log2_jint(c - 1), left);
__ add(left, tmp, result);
return true;
}

2
src/hotspot/share/opto/divnode.cpp
View File

@ -133,7 +133,7 @@ static Node *transform_int_divide( PhaseGVN *phase, Node *dividend, jint divisor
}
// Add rounding to the shift to handle the sign bit
int l = log2_intptr(d-1)+1;
int l = log2_jint(d-1)+1;
if (needs_rounding) {
// Divide-by-power-of-2 can be made into a shift, but you have to do
// more math for the rounding. You need to add 0 for positive

10
src/hotspot/share/opto/mulnode.cpp
View File

@ -199,21 +199,21 @@ Node *MulINode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node *res = NULL;
unsigned int bit1 = abs_con & (0-abs_con); // Extract low bit
if (bit1 == abs_con) { // Found a power of 2?
res = new LShiftINode(in(1), phase->intcon(log2_intptr(bit1)));
res = new LShiftINode(in(1), phase->intcon(log2_uint(bit1)));
} else {
// Check for constant with 2 bits set
unsigned int bit2 = abs_con-bit1;
bit2 = bit2 & (0-bit2); // Extract 2nd bit
if (bit2 + bit1 == abs_con) { // Found all bits in con?
Node *n1 = phase->transform( new LShiftINode(in(1), phase->intcon(log2_intptr(bit1))));
Node *n2 = phase->transform( new LShiftINode(in(1), phase->intcon(log2_intptr(bit2))));
Node *n1 = phase->transform( new LShiftINode(in(1), phase->intcon(log2_uint(bit1))));
Node *n2 = phase->transform( new LShiftINode(in(1), phase->intcon(log2_uint(bit2))));
res = new AddINode(n2, n1);
} else if (is_power_of_2(abs_con+1)) {
// Sleezy: power-of-2 -1. Next time be generic.
unsigned int temp = abs_con + 1;
Node *n1 = phase->transform(new LShiftINode(in(1), phase->intcon(log2_intptr(temp))));
Node *n1 = phase->transform(new LShiftINode(in(1), phase->intcon(log2_uint(temp))));
res = new SubINode(n1, in(1));
} else {
return MulNode::Ideal(phase, can_reshape);
@ -445,7 +445,7 @@ Node* AndINode::Identity(PhaseGVN* phase) {
// Masking off high bits which are always zero is useless.
const TypeInt* t1 = phase->type( in(1) )->isa_int();
if (t1 != NULL && t1->_lo >= 0) {
jint t1_support = right_n_bits(1 + log2_intptr(t1->_hi));
jint t1_support = right_n_bits(1 + log2_jint(t1->_hi));
if ((t1_support & con) == t1_support)
return in1;
}

2
src/hotspot/share/runtime/compilationPolicy.cpp
View File

@ -228,7 +228,7 @@ void NonTieredCompPolicy::initialize() {
// Example: if CICompilerCountPerCPU is true, then we get
// max(log2(8)-1,1) = 2 compiler threads on an 8-way machine.
// May help big-app startup time.
_compiler_count = MAX2(log2_intptr(os::active_processor_count())-1,1);
_compiler_count = MAX2(log2_int(os::active_processor_count())-1,1);
// Make sure there is enough space in the code cache to hold all the compiler buffers
size_t buffer_size = 1;
#ifdef COMPILER1

4
src/hotspot/share/runtime/tieredThresholdPolicy.cpp
View File

@ -226,8 +226,8 @@ void TieredThresholdPolicy::initialize() {
}
if (CICompilerCountPerCPU) {
// Simple log n seems to grow too slowly for tiered, try something faster: log n * log log n
int log_cpu = log2_intptr(os::active_processor_count());
int loglog_cpu = log2_intptr(MAX2(log_cpu, 1));
int log_cpu = log2_int(os::active_processor_count());
int loglog_cpu = log2_int(MAX2(log_cpu, 1));
count = MAX2(log_cpu * loglog_cpu * 3 / 2, 2);
// Make sure there is enough space in the code cache to hold all the compiler buffers
size_t c1_size = Compiler::code_buffer_size();

22
src/hotspot/share/utilities/globalDefinitions.hpp
View File

@ -1032,7 +1032,6 @@ inline bool is_power_of_2_long(jlong x) {
}
// Returns largest i such that 2^i <= x.
// If x < 0, the function returns 31 on a 32-bit machine and 63 on a 64-bit machine.
// If x == 0, the function returns -1.
inline int log2_intptr(uintptr_t x) {
int i = -1;
@ -1047,8 +1046,7 @@ inline int log2_intptr(uintptr_t x) {
}
//* largest i such that 2^i <= x
// A negative value of 'x' will return '63'
inline int log2_long(unsigned long x) {
inline int log2_long(julong x) {
int i = -1;
julong p = 1;
while (p != 0 && p <= x) {
@ -1060,20 +1058,30 @@ inline int log2_long(unsigned long x) {
return i;
}
// If x < 0, the function returns 31 on a 32-bit machine and 63 on a 64-bit machine.
inline int log2_intptr(intptr_t x) {
return log2_intptr((uintptr_t)x);
}
inline int log2_intptr(int x) {
inline int log2_int(int x) {
STATIC_ASSERT(sizeof(int) <= sizeof(uintptr_t));
return log2_intptr((uintptr_t)x);
}
inline int log2_intptr(uint x) {
inline int log2_jint(jint x) {
STATIC_ASSERT(sizeof(jint) <= sizeof(uintptr_t));
return log2_intptr((uintptr_t)x);
}
inline int log2_long(jlong x) {
return log2_long((unsigned long)x);
inline int log2_uint(uint x) {
STATIC_ASSERT(sizeof(uint) <= sizeof(uintptr_t));
return log2_intptr((uintptr_t)x);
}
// A negative value of 'x' will return '63'
inline int log2_jlong(jlong x) {
STATIC_ASSERT(sizeof(jlong) <= sizeof(julong));
return log2_long((julong)x);
}
//* the argument must be exactly a power of 2

2
src/hotspot/share/utilities/hashtable.cpp
View File

@ -63,7 +63,7 @@ template <MEMFLAGS F> BasicHashtableEntry<F>* BasicHashtable<F>::new_entry(unsig
if (_first_free_entry + _entry_size >= _end_block) {
int block_size = MIN2(512, MAX2((int)_table_size / 2, (int)_number_of_entries));
int len = _entry_size * block_size;
len = 1 << log2_intptr(len); // round down to power of 2
len = 1 << log2_int(len); // round down to power of 2
assert(len >= _entry_size, "");
_first_free_entry = NEW_C_HEAP_ARRAY2(char, len, F, CURRENT_PC);
_entry_blocks->append(_first_free_entry);