8367325: [s390x] build failure due to JDK-8361376

Reviewed-by: mdoerr, dlong

Author: offamitkumar

src/hotspot/cpu/s390/gc/shared/barrierSetAssembler_s390.cpp

@@ -171,6 +171,7 @@ void BarrierSetAssembler::try_resolve_jobject_in_native(MacroAssembler* masm, Re
 
 void BarrierSetAssembler::nmethod_entry_barrier(MacroAssembler* masm) {
   BarrierSetNMethod* bs_nm = BarrierSet::barrier_set()->barrier_set_nmethod();
+  __ align(4, __ offset() + OFFSET_TO_PATCHABLE_DATA); // must align the following block which requires atomic updates
   __ block_comment("nmethod_entry_barrier (nmethod_entry_barrier) {");
 
     // Load jump addr:

src/hotspot/cpu/s390/gc/shared/barrierSetAssembler_s390.hpp

@@ -66,6 +66,14 @@ class BarrierSetAssembler: public CHeapObj<mtGC> {
   OptoReg::Name refine_register(const Node* node,
                                 OptoReg::Name opto_reg) const;
 #endif // COMPILER2
+
+  static const int OFFSET_TO_PATCHABLE_DATA_INSTRUCTION = 6 + 6 + 6; // iihf(6) + iilf(6) + lg(6)
+  static const int BARRIER_TOTAL_LENGTH = OFFSET_TO_PATCHABLE_DATA_INSTRUCTION + 6 + 6 + 2; // cfi(6) + larl(6) + bcr(2)
+
+  // first 2 bytes are for cfi instruction opcode and next 4 bytes will be the value/data to be patched,
+  // so we are skipping first 2 bytes and returning the address of value/data field
+  static const int OFFSET_TO_PATCHABLE_DATA = 6 + 6 + 6 + 2; // iihf(6) + iilf(6) + lg(6) + CFI_OPCODE(2)
+
 };
 
 #ifdef COMPILER2

src/hotspot/cpu/s390/gc/shared/barrierSetNMethod_s390.cpp

@@ -26,26 +26,32 @@
 #include "code/codeBlob.hpp"
 #include "code/nativeInst.hpp"
 #include "code/nmethod.hpp"
+#include "gc/shared/barrierSetAssembler.hpp"
 #include "gc/shared/barrierSetNMethod.hpp"
 #include "utilities/debug.hpp"
 
 class NativeMethodBarrier: public NativeInstruction {
   private:
-    static const int PATCHABLE_INSTRUCTION_OFFSET = 3*6; // bytes
 
     address get_barrier_start_address() const {
       return NativeInstruction::addr_at(0);
     }
 
     address get_patchable_data_address() const {
-      address inst_addr = get_barrier_start_address() + PATCHABLE_INSTRUCTION_OFFSET;
+      address start_address = get_barrier_start_address();
+#ifdef ASSERT
+      address inst_addr = start_address + BarrierSetAssembler::OFFSET_TO_PATCHABLE_DATA_INSTRUCTION;
 
-      DEBUG_ONLY(Assembler::is_z_cfi(*((long*)inst_addr)));
-      return inst_addr + 2;
+      unsigned long instr = 0;
+      Assembler::get_instruction(inst_addr, &instr);
+      assert(Assembler::is_z_cfi(instr), "sanity check");
+#endif // ASSERT
+
+      return start_address + BarrierSetAssembler::OFFSET_TO_PATCHABLE_DATA;
     }
 
   public:
-    static const int BARRIER_TOTAL_LENGTH = PATCHABLE_INSTRUCTION_OFFSET + 2*6 + 2; // bytes
+    static const int BARRIER_TOTAL_LENGTH = BarrierSetAssembler::BARRIER_TOTAL_LENGTH;
 
     int get_guard_value() const {
       address data_addr = get_patchable_data_address();
@@ -77,23 +83,30 @@ class NativeMethodBarrier: public NativeInstruction {
 
     #ifdef ASSERT
       void verify() const {
+        unsigned long instr = 0;
         int offset = 0; // bytes
         const address start = get_barrier_start_address();
 
-        MacroAssembler::is_load_const(/* address */ start + offset); // two instructions
+        assert(MacroAssembler::is_load_const(/* address */ start + offset), "sanity check"); // two instructions
         offset += Assembler::instr_len(&start[offset]);
         offset += Assembler::instr_len(&start[offset]);
 
-        Assembler::is_z_lg(*((long*)(start + offset)));
+        Assembler::get_instruction(start + offset, &instr);
+        assert(Assembler::is_z_lg(instr), "sanity check");
         offset += Assembler::instr_len(&start[offset]);
 
-        Assembler::is_z_cfi(*((long*)(start + offset)));
+        // it will be assignment operation, So it doesn't matter what value is already present in instr
+        // hence, no need to 0 it out.
+        Assembler::get_instruction(start + offset, &instr);
+        assert(Assembler::is_z_cfi(instr), "sanity check");
         offset += Assembler::instr_len(&start[offset]);
 
-        Assembler::is_z_larl(*((long*)(start + offset)));
+        Assembler::get_instruction(start + offset, &instr);
+        assert(Assembler::is_z_larl(instr), "sanity check");
         offset += Assembler::instr_len(&start[offset]);
 
-        Assembler::is_z_bcr(*((long*)(start + offset)));
+        Assembler::get_instruction(start + offset, &instr);
+        assert(Assembler::is_z_bcr(instr), "sanity check");
         offset += Assembler::instr_len(&start[offset]);
 
         assert(offset == BARRIER_TOTAL_LENGTH, "check offset == barrier length constant");