From f8968f398ce7a64b4f9e9b1e95f5be1d8b70c913 Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Apr 20 2016 12:53:23 +0000 Subject: import java-1.8.0-openjdk-1.8.0.91-0.b14.el7_2 --- diff --git a/.gitignore b/.gitignore index 1c3a93e..47c217d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,2 @@ -SOURCES/aarch64-port-jdk8u-aarch64-jdk8u77-b03.tar.xz +SOURCES/aarch64-port-jdk8u-aarch64-jdk8u91-b14.tar.xz SOURCES/systemtap-tapset.tar.gz diff --git a/.java-1.8.0-openjdk.metadata b/.java-1.8.0-openjdk.metadata index 242fe0a..4e09d30 100644 --- a/.java-1.8.0-openjdk.metadata +++ b/.java-1.8.0-openjdk.metadata @@ -1,2 +1,2 @@ -a0284d124e9356661f2feb770ba829796809c4ef SOURCES/aarch64-port-jdk8u-aarch64-jdk8u77-b03.tar.xz +56832db6ccf56ada368fa614a09cfd63a0ce2015 SOURCES/aarch64-port-jdk8u-aarch64-jdk8u91-b14.tar.xz 8dd5345808d840741a9619becc84302f44b54e78 SOURCES/systemtap-tapset.tar.gz diff --git a/SOURCES/8132051-aarch64.patch b/SOURCES/8132051-aarch64.patch new file mode 100644 index 0000000..802a8d8 --- /dev/null +++ b/SOURCES/8132051-aarch64.patch @@ -0,0 +1,248 @@ +# HG changeset patch +# User aph +# Date 1460374398 0 +# Mon Apr 11 11:33:18 2016 +0000 +# Node ID 388e9d0905e69727a15a94f825bdde17e2ed96d6 +# Parent e2b90ce9a1d12eae1a8edbd34eacd9a9674e315b +8132051: Better byte behavior +Reviewed-by: adinn + +diff --git a/src/cpu/aarch64/vm/c1_LIRGenerator_aarch64.cpp b/src/cpu/aarch64/vm/c1_LIRGenerator_aarch64.cpp +--- openjdk/hotspot/src/cpu/aarch64/vm/c1_LIRGenerator_aarch64.cpp ++++ openjdk/hotspot/src/cpu/aarch64/vm/c1_LIRGenerator_aarch64.cpp +@@ -337,7 +337,7 @@ + length.load_item(); + + } +- if (needs_store_check) { ++ if (needs_store_check || x->check_boolean()) { + value.load_item(); + } else { + value.load_for_store(x->elt_type()); +@@ -386,7 +386,8 @@ + // Seems to be a precise + post_barrier(LIR_OprFact::address(array_addr), value.result()); + } else { +- __ move(value.result(), array_addr, null_check_info); ++ LIR_Opr result = maybe_mask_boolean(x, array.result(), value.result(), null_check_info); ++ __ move(result, array_addr, null_check_info); + } + } + +diff --git a/src/cpu/aarch64/vm/interp_masm_aarch64.cpp b/src/cpu/aarch64/vm/interp_masm_aarch64.cpp +--- openjdk/hotspot/src/cpu/aarch64/vm/interp_masm_aarch64.cpp ++++ openjdk/hotspot/src/cpu/aarch64/vm/interp_masm_aarch64.cpp +@@ -41,7 +41,43 @@ + #include "runtime/thread.inline.hpp" + + +-// Implementation of InterpreterMacroAssembler ++void InterpreterMacroAssembler::narrow(Register result) { ++ ++ // Get method->_constMethod->_result_type ++ ldr(rscratch1, Address(rfp, frame::interpreter_frame_method_offset * wordSize)); ++ ldr(rscratch1, Address(rscratch1, Method::const_offset())); ++ ldrb(rscratch1, Address(rscratch1, ConstMethod::result_type_offset())); ++ ++ Label done, notBool, notByte, notChar; ++ ++ // common case first ++ cmpw(rscratch1, T_INT); ++ br(Assembler::EQ, done); ++ ++ // mask integer result to narrower return type. ++ cmpw(rscratch1, T_BOOLEAN); ++ br(Assembler::NE, notBool); ++ andw(result, result, 0x1); ++ b(done); ++ ++ bind(notBool); ++ cmpw(rscratch1, T_BYTE); ++ br(Assembler::NE, notByte); ++ sbfx(result, result, 0, 8); ++ b(done); ++ ++ bind(notByte); ++ cmpw(rscratch1, T_CHAR); ++ br(Assembler::NE, notChar); ++ ubfx(result, result, 0, 16); // truncate upper 16 bits ++ b(done); ++ ++ bind(notChar); ++ sbfx(result, result, 0, 16); // sign-extend short ++ ++ // Nothing to do for T_INT ++ bind(done); ++} + + #ifndef CC_INTERP + +@@ -79,6 +115,7 @@ + verify_oop(r0, state); break; + case ltos: ldr(r0, val_addr); break; + case btos: // fall through ++ case ztos: // fall through + case ctos: // fall through + case stos: // fall through + case itos: ldrw(r0, val_addr); break; +@@ -312,6 +349,7 @@ + switch (state) { + case atos: pop_ptr(); break; + case btos: ++ case ztos: + case ctos: + case stos: + case itos: pop_i(); break; +@@ -329,6 +367,7 @@ + switch (state) { + case atos: push_ptr(); break; + case btos: ++ case ztos: + case ctos: + case stos: + case itos: push_i(); break; +diff --git a/src/cpu/aarch64/vm/interp_masm_aarch64.hpp b/src/cpu/aarch64/vm/interp_masm_aarch64.hpp +--- openjdk/hotspot/src/cpu/aarch64/vm/interp_masm_aarch64.hpp ++++ openjdk/hotspot/src/cpu/aarch64/vm/interp_masm_aarch64.hpp +@@ -252,6 +252,9 @@ + void update_mdp_by_constant(Register mdp_in, int constant); + void update_mdp_for_ret(Register return_bci); + ++ // narrow int return value ++ void narrow(Register result); ++ + void profile_taken_branch(Register mdp, Register bumped_count); + void profile_not_taken_branch(Register mdp); + void profile_call(Register mdp); +diff --git a/src/cpu/aarch64/vm/templateTable_aarch64.cpp b/src/cpu/aarch64/vm/templateTable_aarch64.cpp +--- openjdk/hotspot/src/cpu/aarch64/vm/templateTable_aarch64.cpp ++++ openjdk/hotspot/src/cpu/aarch64/vm/templateTable_aarch64.cpp +@@ -233,6 +233,7 @@ + switch (bc) { + case Bytecodes::_fast_aputfield: + case Bytecodes::_fast_bputfield: ++ case Bytecodes::_fast_zputfield: + case Bytecodes::_fast_cputfield: + case Bytecodes::_fast_dputfield: + case Bytecodes::_fast_fputfield: +@@ -1072,6 +1073,18 @@ + // r1: index + // r3: array + index_check(r3, r1); // prefer index in r1 ++ ++ // Need to check whether array is boolean or byte ++ // since both types share the bastore bytecode. ++ __ load_klass(r2, r3); ++ __ ldrw(r2, Address(r2, Klass::layout_helper_offset())); ++ int diffbit = Klass::layout_helper_boolean_diffbit(); ++ __ andw(rscratch1, r2, diffbit); ++ Label L_skip; ++ __ cbzw(rscratch1, L_skip); ++ __ andw(r0, r0, 1); // if it is a T_BOOLEAN array, mask the stored value to 0/1 ++ __ bind(L_skip); ++ + __ lea(rscratch1, Address(r3, r1, Address::uxtw(0))); + __ strb(r0, Address(rscratch1, + arrayOopDesc::base_offset_in_bytes(T_BYTE))); +@@ -2186,6 +2199,13 @@ + if (_desc->bytecode() == Bytecodes::_return) + __ membar(MacroAssembler::StoreStore); + ++ // Narrow result if state is itos but result type is smaller. ++ // Need to narrow in the return bytecode rather than in generate_return_entry ++ // since compiled code callers expect the result to already be narrowed. ++ if (state == itos) { ++ __ narrow(r0); ++ } ++ + __ remove_activation(state); + __ ret(lr); + } +@@ -2395,7 +2415,7 @@ + + const Address field(obj, off); + +- Label Done, notByte, notInt, notShort, notChar, ++ Label Done, notByte, notBool, notInt, notShort, notChar, + notLong, notFloat, notObj, notDouble; + + // x86 uses a shift and mask or wings it with a shift plus assert +@@ -2415,6 +2435,20 @@ + __ b(Done); + + __ bind(notByte); ++ __ cmp(flags, ztos); ++ __ br(Assembler::NE, notBool); ++ ++ // ztos (same code as btos) ++ __ ldrsb(r0, field); ++ __ push(ztos); ++ // Rewrite bytecode to be faster ++ if (!is_static) { ++ // use btos rewriting, no truncating to t/f bit is needed for getfield. ++ patch_bytecode(Bytecodes::_fast_bgetfield, bc, r1); ++ } ++ __ b(Done); ++ ++ __ bind(notBool); + __ cmp(flags, atos); + __ br(Assembler::NE, notObj); + // atos +@@ -2606,7 +2640,7 @@ + // field address + const Address field(obj, off); + +- Label notByte, notInt, notShort, notChar, ++ Label notByte, notBool, notInt, notShort, notChar, + notLong, notFloat, notObj, notDouble; + + // x86 uses a shift and mask or wings it with a shift plus assert +@@ -2628,6 +2662,22 @@ + } + + __ bind(notByte); ++ __ cmp(flags, ztos); ++ __ br(Assembler::NE, notBool); ++ ++ // ztos ++ { ++ __ pop(ztos); ++ if (!is_static) pop_and_check_object(obj); ++ __ andw(r0, r0, 0x1); ++ __ strb(r0, field); ++ if (!is_static) { ++ patch_bytecode(Bytecodes::_fast_zputfield, bc, r1, true, byte_no); ++ } ++ __ b(Done); ++ } ++ ++ __ bind(notBool); + __ cmp(flags, atos); + __ br(Assembler::NE, notObj); + +@@ -2778,6 +2828,7 @@ + switch (bytecode()) { // load values into the jvalue object + case Bytecodes::_fast_aputfield: __ push_ptr(r0); break; + case Bytecodes::_fast_bputfield: // fall through ++ case Bytecodes::_fast_zputfield: // fall through + case Bytecodes::_fast_sputfield: // fall through + case Bytecodes::_fast_cputfield: // fall through + case Bytecodes::_fast_iputfield: __ push_i(r0); break; +@@ -2803,6 +2854,7 @@ + switch (bytecode()) { // restore tos values + case Bytecodes::_fast_aputfield: __ pop_ptr(r0); break; + case Bytecodes::_fast_bputfield: // fall through ++ case Bytecodes::_fast_zputfield: // fall through + case Bytecodes::_fast_sputfield: // fall through + case Bytecodes::_fast_cputfield: // fall through + case Bytecodes::_fast_iputfield: __ pop_i(r0); break; +@@ -2858,6 +2910,9 @@ + case Bytecodes::_fast_iputfield: + __ strw(r0, field); + break; ++ case Bytecodes::_fast_zputfield: ++ __ andw(r0, r0, 0x1); // boolean is true if LSB is 1 ++ // fall through to bputfield + case Bytecodes::_fast_bputfield: + __ strb(r0, field); + break; diff --git a/SOURCES/8132051-zero.patch b/SOURCES/8132051-zero.patch new file mode 100644 index 0000000..77dd9c2 --- /dev/null +++ b/SOURCES/8132051-zero.patch @@ -0,0 +1,74 @@ +diff -r 388e9d0905e6 src/cpu/zero/vm/cppInterpreter_zero.cpp +--- openjdk/hotspot/src/cpu/zero/vm/cppInterpreter_zero.cpp Mon Apr 11 11:33:18 2016 +0000 ++++ openjdk/hotspot/src/cpu/zero/vm/cppInterpreter_zero.cpp Mon Apr 11 21:42:21 2016 +0100 +@@ -93,6 +93,7 @@ + case T_SHORT: + return (intptr_t)(jshort)result; + case T_OBJECT: // nothing to do fall through ++ case T_ARRAY: + case T_LONG: + case T_INT: + case T_FLOAT: +@@ -219,9 +219,16 @@ + // Push our result + for (int i = 0; i < result_slots; i++) { + // Adjust result to smaller +- intptr_t res = result[-i]; ++ union { ++ intptr_t res; ++ jint res_jint; ++ }; ++ res = result[-i]; + if (result_slots == 1) { +- res = narrow(result_type_of(method), res); ++ BasicType t = result_type_of(method); ++ if (is_subword_type(t)) { ++ res_jint = (jint)narrow(t, res_jint); ++ } + } + stack->push(res); + } +@@ -796,22 +797,10 @@ + } + + BasicType CppInterpreter::result_type_of(Method* method) { +- BasicType t; +- switch (method->result_index()) { +- case 0 : t = T_BOOLEAN; break; +- case 1 : t = T_CHAR; break; +- case 2 : t = T_BYTE; break; +- case 3 : t = T_SHORT; break; +- case 4 : t = T_INT; break; +- case 5 : t = T_LONG; break; +- case 6 : t = T_VOID; break; +- case 7 : t = T_FLOAT; break; +- case 8 : t = T_DOUBLE; break; +- case 9 : t = T_OBJECT; break; +- default: ShouldNotReachHere(); +- } +- assert(AbstractInterpreter::BasicType_as_index(t) == method->result_index(), +- "out of step with AbstractInterpreter::BasicType_as_index"); ++ // Get method->_constMethod->_result_type ++ u1 *p = ((unsigned char *)method->constMethod() ++ + in_bytes(ConstMethod::result_type_offset())); ++ BasicType t = (BasicType)*p; + return t; + } + +diff -r 388e9d0905e6 src/share/vm/interpreter/bytecodeInterpreter.cpp +--- openjdk/hotspot/src/share/vm/interpreter/bytecodeInterpreter.cpp Mon Apr 11 11:33:18 2016 +0000 ++++ openjdk/hotspot/src/share/vm/interpreter/bytecodeInterpreter.cpp Mon Apr 11 21:42:21 2016 +0100 +@@ -593,9 +593,10 @@ + /* 0xDC */ &&opc_default, &&opc_default, &&opc_default, &&opc_default, + + /* 0xE0 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default, +-/* 0xE4 */ &&opc_default, &&opc_fast_aldc, &&opc_fast_aldc_w, &&opc_return_register_finalizer, +-/* 0xE8 */ &&opc_invokehandle,&&opc_default, &&opc_default, &&opc_default, +-/* 0xEC */ &&opc_default, &&opc_default, &&opc_default, &&opc_default, ++/* 0xE4 */ &&opc_default, &&opc_default, &&opc_fast_aldc, &&opc_fast_aldc_w, ++/* 0xE8 */ &&opc_return_register_finalizer, ++ &&opc_invokehandle, &&opc_default, &&opc_default, ++/* 0xEC */ &&opc_default, &&opc_default, &&opc_default, &&opc_default, + + /* 0xF0 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default, + /* 0xF4 */ &&opc_default, &&opc_default, &&opc_default, &&opc_default, diff --git a/SPECS/java-1.8.0-openjdk.spec b/SPECS/java-1.8.0-openjdk.spec index 0a0a3ce..55ceeca 100644 --- a/SPECS/java-1.8.0-openjdk.spec +++ b/SPECS/java-1.8.0-openjdk.spec @@ -39,7 +39,11 @@ # is expected in one single case at the end of build %global rev_build_loop %{build_loop2} %{build_loop1} +%ifarch %{jit_arches} +%global bootstrap_build 1 +%else %global bootstrap_build 0 +%endif %if %{bootstrap_build} %global targets bootcycle-images docs @@ -143,7 +147,7 @@ # note, following three variables are sedded from update_sources if used correctly. Hardcode them rather there. %global project aarch64-port %global repo jdk8u -%global revision aarch64-jdk8u77-b03 +%global revision aarch64-jdk8u91-b14 # eg # jdk8u60-b27 -> jdk8u60 or # aarch64-jdk8u60-b27 -> aarch64-jdk8u60 (dont forget spec escape % by %%) %global whole_update %(VERSION=%{revision}; echo ${VERSION%%-*}) # eg jdk8u60 -> 60 or aarch64-jdk8u60 -> 60 @@ -731,7 +735,7 @@ URL: http://openjdk.java.net/ # aarch64-port now contains integration forest of both aarch64 and normal jdk # Source from upstream OpenJDK8 project. To regenerate, use -# VERSION=aarch64-jdk8u77-b03 FILE_NAME_ROOT=aarch64-port-jdk8u-${VERSION} +# VERSION=aarch64-jdk8u91-b14 FILE_NAME_ROOT=aarch64-port-jdk8u-${VERSION} # REPO_ROOT= generate_source_tarball.sh # where the source is obtained from http://hg.openjdk.java.net/%%{project}/%%{repo} Source0: %{project}-%{repo}-%{revision}.tar.xz @@ -806,6 +810,12 @@ Patch203: system-lcms.patch Patch502: pr2462.patch # S8140620, PR2769: Find and load default.sf2 as the default soundbank on Linux Patch605: soundFontPatch.patch +# S8132051: Better byte behaviour for Zero +Patch606: 8132051-zero.patch + +# Patches which need adding to aarch64/8u +# S8132051: Better byte behaviour for AArch64 +Patch701: 8132051-aarch64.patch # Patches upstream and appearing in 8u76 # Fixes StackOverflowError on ARM32 bit Zero. See RHBZ#1206656 @@ -1083,8 +1093,13 @@ sh %{SOURCE12} %patch102 %patch103 -# Zero PPC fixes. +# Zero fixes. %patch403 +%patch505 +%patch606 + +# AArch64 fixes +%patch701 %patch603 %patch601 @@ -1093,7 +1108,6 @@ sh %{SOURCE12} %patch502 %patch504 -%patch505 %patch511 %patch512 @@ -1787,6 +1801,39 @@ end %endif %changelog +* Tue Apr 12 2016 Andrew Hughes - 1:1.8.0.91-0.b14 +- Add additional fix to Zero patch to properly handle result on 64-bit big-endian +- Resolves: rhbz#1325422 + +* Tue Apr 12 2016 Andrew Hughes - 1:1.8.0.91-0.b14 +- Revert settings to production defaults so we can at least get a build. +- Resolves: rhbz#1325422 + +* Tue Apr 12 2016 Andrew Hughes - 1:1.8.0.91-0.b14 +- Switch to a slowdebug build to try and unearth remaining issue on s390x. +- Resolves: rhbz#1325422 + +* Mon Apr 11 2016 Andrew Hughes - 1:1.8.0.91-0.b14 +- Add missing comma in 8132051 patch. +- Resolves: rhbz#1325422 + +* Mon Apr 11 2016 Andrew Hughes - 1:1.8.0.91-0.b14 +- Add 8132051 port to Zero. +- Turn on bootstrap build for all to ensure we are now good to go. +- Resolves: rhbz#1325422 + +* Mon Apr 11 2016 Andrew Hughes - 1:1.8.0.91-0.b14 +- Add 8132051 port to AArch64. +- Resolves: rhbz#1325422 + +* Mon Apr 11 2016 Andrew Hughes - 1:1.8.0.91-0.b14 +- Enable a full bootstrap on JIT archs. Full build held back by Zero archs anyway. +- Resolves: rhbz#1325422 + +* Sun Apr 10 2016 Andrew Hughes - 1:1.8.0.91-0.b14 +- Update to u91b14. +- Resolves: rhbz#1325422 + * Wed Mar 23 2016 Andrew Hughes - 1:1.8.0.77-0.b03 - Remove what remains of the SunEC sources in the remove-intree-libraries script. - Resolves: rhbz#1320664