components/runtime/openjdk-23/patches/illumos-port-09.patch

   1 --- a/src/hotspot/os_cpu/solaris_x86/os_solaris_x86.cpp Fri Oct 16 12:20:06 2020
   2 +++ b/src/hotspot/os_cpu/solaris_x86/os_solaris_x86.cpp Fri Oct 16 14:58:59 2020
   3 @@ -218,42 +218,12 @@
   4    return frame(sp, fp, epc);
   5  }
   6
   7 -bool os::Solaris::get_frame_at_stack_banging_point(JavaThread* thread, ucontext_t* uc, frame* fr) {
   8 - address pc = (address) os::Solaris::ucontext_get_pc(uc);
   9 -  if (Interpreter::contains(pc)) {
  10 -    // interpreter performs stack banging after the fixed frame header has
  11 -    // been generated while the compilers perform it before. To maintain
  12 -    // semantic consistency between interpreted and compiled frames, the
  13 -    // method returns the Java sender of the current frame.
  14 -    *fr = os::fetch_frame_from_context(uc);
  15 -    if (!fr->is_first_java_frame()) {
  16 -      // get_frame_at_stack_banging_point() is only called when we
  17 -      // have well defined stacks so java_sender() calls do not need
  18 -      // to assert safe_for_sender() first.
  19 -      *fr = fr->java_sender();
  20 -    }
  21 -  } else {
  22 -    // more complex code with compiled code
  23 -    assert(!Interpreter::contains(pc), "Interpreted methods should have been handled above");
  24 -    CodeBlob* cb = CodeCache::find_blob(pc);
  25 -    if (cb == NULL || !cb->is_nmethod() || cb->is_frame_complete_at(pc)) {
  26 -      // Not sure where the pc points to, fallback to default
  27 -      // stack overflow handling
  28 -      return false;
  29 -    } else {
  30 -      // in compiled code, the stack banging is performed just after the return pc
  31 -      // has been pushed on the stack
  32 -      intptr_t* fp = os::Solaris::ucontext_get_fp(uc);
  33 -      intptr_t* sp = os::Solaris::ucontext_get_sp(uc);
  34 -      *fr = frame(sp + 1, fp, (address)*sp);
  35 -      if (!fr->is_java_frame()) {
  36 -        // See java_sender() comment above.
  37 -        *fr = fr->java_sender();
  38 -      }
  39 -    }
  40 -  }
  41 -  assert(fr->is_java_frame(), "Safety check");
  42 -  return true;
  43 +frame os::fetch_compiled_frame_from_context(const void* ucVoid) {
  44 +  const ucontext_t* uc = (const ucontext_t*)ucVoid;
  45 +  frame fr = os::fetch_frame_from_context(uc);
  46 +  // in compiled code, the stack banging is performed just after the return pc
  47 +  // has been pushed on the stack
  48 +  return frame(fr.sp() + 1, fr.fp(), (address)*(fr.sp()));
  49  }
  50
  51  frame os::get_sender_for_C_frame(frame* fr) {
  52 @@ -322,39 +292,8 @@
  53      // Handle ALL stack overflow variations here
  54      if (sig == SIGSEGV && info->si_code == SEGV_ACCERR) {
  55        address addr = (address) info->si_addr;
  56 -      if (thread->in_stack_yellow_reserved_zone(addr)) {
  57 -        if (thread->thread_state() == _thread_in_Java) {
  58 -          if (thread->in_stack_reserved_zone(addr)) {
  59 -            frame fr;
  60 -            if (os::Solaris::get_frame_at_stack_banging_point(thread, uc, &fr)) {
  61 -              assert(fr.is_java_frame(), "Must be Java frame");
  62 -              frame activation = SharedRuntime::look_for_reserved_stack_annotated_method(thread, fr);
  63 -              if (activation.sp() != NULL) {
  64 -                thread->disable_stack_reserved_zone();
  65 -                if (activation.is_interpreted_frame()) {
  66 -                  thread->set_reserved_stack_activation((address)(
  67 -                    activation.fp() + frame::interpreter_frame_initial_sp_offset));
  68 -                } else {
  69 -                  thread->set_reserved_stack_activation((address)activation.unextended_sp());
  70 -                }
  71 -                return true;
  72 -              }
  73 -            }
  74 -          }
  75 -          // Throw a stack overflow exception.  Guard pages will be reenabled
  76 -          // while unwinding the stack.
  77 -          thread->disable_stack_yellow_reserved_zone();
  78 -          stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW);
  79 -        } else {
  80 -          // Thread was in the vm or native code.  Return and try to finish.
  81 -          thread->disable_stack_yellow_reserved_zone();
  82 -          return true;
  83 -        }
  84 -      } else if (thread->in_stack_red_zone(addr)) {
  85 -        // Fatal red zone violation.  Disable the guard pages and fall through
  86 -        // to handle_unexpected_exception way down below.
  87 -        thread->disable_stack_red_zone();
  88 -        tty->print_raw_cr("An irrecoverable stack overflow has occurred.");
  89 +      if (os::Posix::handle_stack_overflow(thread, addr, pc, uc, &stub)) {
  90 +        return 1; // continue
  91        }
  92      }
  93