8238355: Update Graal

Reviewed-by: kvn

Author: Igor Veresov

src/hotspot/cpu/x86/nativeInst_x86.cpp

@@ -40,15 +40,17 @@ void NativeInstruction::wrote(int offset) {
   ICache::invalidate_word(addr_at(offset));
 }
 
+#ifdef ASSERT
 void NativeLoadGot::report_and_fail() const {
-  tty->print_cr("Addr: " INTPTR_FORMAT, p2i(instruction_address()));
+  tty->print_cr("Addr: " INTPTR_FORMAT " Code: %x %x %x", p2i(instruction_address()),
+                  (has_rex ? ubyte_at(0) : 0), ubyte_at(rex_size), ubyte_at(rex_size + 1));
   fatal("not a indirect rip mov to rbx");
 }
 
 void NativeLoadGot::verify() const {
   if (has_rex) {
     int rex = ubyte_at(0);
-    if (rex != rex_prefix) {
+    if (rex != rex_prefix && rex != rex_b_prefix) {
       report_and_fail();
     }
   }
@@ -62,6 +64,7 @@ void NativeLoadGot::verify() const {
     report_and_fail();
   }
 }
+#endif
 
 intptr_t NativeLoadGot::data() const {
   return *(intptr_t *) got_address();
@@ -149,14 +152,30 @@ address NativeGotJump::destination() const {
   return *got_entry;
 }
 
+#ifdef ASSERT
+void NativeGotJump::report_and_fail() const {
+  tty->print_cr("Addr: " INTPTR_FORMAT " Code: %x %x %x", p2i(instruction_address()),
+                 (has_rex() ? ubyte_at(0) : 0), ubyte_at(rex_size()), ubyte_at(rex_size() + 1));
+  fatal("not a indirect rip jump");
+}
+
 void NativeGotJump::verify() const {
-  int inst = ubyte_at(0);
+  if (has_rex()) {
+    int rex = ubyte_at(0);
+    if (rex != rex_prefix) {
+      report_and_fail();
+    }
+  }
+  int inst = ubyte_at(rex_size());
   if (inst != instruction_code) {
-    tty->print_cr("Addr: " INTPTR_FORMAT " Code: 0x%x", p2i(instruction_address()),
-                                                        inst);
-    fatal("not a indirect rip jump");
+    report_and_fail();
+  }
+  int modrm = ubyte_at(rex_size() + 1);
+  if (modrm != modrm_code) {
+    report_and_fail();
   }
 }
+#endif
 
 void NativeCall::verify() {
   // Make sure code pattern is actually a call imm32 instruction.

src/hotspot/cpu/x86/nativeInst_x86.hpp

@@ -455,31 +455,35 @@ class NativeLoadGot: public NativeInstruction {
   static const bool has_rex = false;
   static const int rex_size = 0;
 #endif
-public:
+
   enum Intel_specific_constants {
     rex_prefix = 0x48,
+    rex_b_prefix = 0x49,
     instruction_code = 0x8b,
     modrm_rbx_code = 0x1d,
     modrm_rax_code = 0x05,
     instruction_length = 6 + rex_size,
     offset_offset = 2 + rex_size
   };
 
-  address instruction_address() const { return addr_at(0); }
-  address rip_offset_address() const { return addr_at(offset_offset); }
   int rip_offset() const { return int_at(offset_offset); }
   address return_address() const { return addr_at(instruction_length); }
   address got_address() const { return return_address() + rip_offset(); }
+
+#ifdef ASSERT
+  void report_and_fail() const;
+  address instruction_address() const { return addr_at(0); }
+#endif
+
+public:
   address next_instruction_address() const { return return_address(); }
   intptr_t data() const;
   void set_data(intptr_t data) {
     intptr_t *addr = (intptr_t *) got_address();
     *addr = data;
   }
 
-  void verify() const;
-private:
-  void report_and_fail() const;
+  DEBUG_ONLY( void verify() const );
 };
 
 inline NativeLoadGot* nativeLoadGot_at(address addr) {
@@ -607,27 +611,37 @@ inline NativeGeneralJump* nativeGeneralJump_at(address address) {
 }
 
 class NativeGotJump: public NativeInstruction {
-public:
   enum Intel_specific_constants {
+    rex_prefix = 0x41,
     instruction_code = 0xff,
-    instruction_offset = 0,
+    modrm_code = 0x25,
     instruction_size = 6,
     rip_offset = 2
   };
 
-  void verify() const;
-  address instruction_address() const { return addr_at(instruction_offset); }
-  address destination() const;
-  address return_address() const { return addr_at(instruction_size); }
-  int got_offset() const { return (jint) int_at(rip_offset); }
+  bool has_rex() const { return ubyte_at(0) == rex_prefix; }
+  int rex_size() const { return has_rex() ? 1 : 0; }
+
+  address return_address() const { return addr_at(instruction_size + rex_size()); }
+  int got_offset() const { return (jint) int_at(rip_offset + rex_size()); }
+
+#ifdef ASSERT
+  void report_and_fail() const;
+  address instruction_address() const { return addr_at(0); }
+#endif
+
+public:
   address got_address() const { return return_address() + got_offset(); }
-  address next_instruction_address() const { return addr_at(instruction_size); }
-  bool is_GotJump() const { return ubyte_at(0) == instruction_code; }
+  address next_instruction_address() const { return return_address(); }
+  bool is_GotJump() const { return ubyte_at(rex_size()) == instruction_code; }
 
+  address destination() const;
   void set_jump_destination(address dest)  {
     address *got_entry = (address *) got_address();
     *got_entry = dest;
   }
+
+  DEBUG_ONLY( void verify() const; )
 };
 
 inline NativeGotJump* nativeGotJump_at(address addr) {