src/hotspot/share/c1/c1_IR.hpp

@@ -207,24 +207,27 @@
    int                           _bci;
    GrowableArray<ScopeValue*>*   _locals;
    GrowableArray<ScopeValue*>*   _expressions;
    GrowableArray<MonitorValue*>* _monitors;
    IRScopeDebugInfo*             _caller;
+   bool                          _should_reexecute;
  
   public:
    IRScopeDebugInfo(IRScope*                      scope,
                     int                           bci,
                     GrowableArray<ScopeValue*>*   locals,
                     GrowableArray<ScopeValue*>*   expressions,
                     GrowableArray<MonitorValue*>* monitors,
-                    IRScopeDebugInfo*             caller):
+                    IRScopeDebugInfo*             caller,
+                    bool                          should_reexecute):
        _scope(scope)
      , _bci(bci)
      , _locals(locals)
      , _expressions(expressions)
      , _monitors(monitors)
-     , _caller(caller) {}
+     , _caller(caller)
+     , _should_reexecute(should_reexecute) {}
  
  
    IRScope*                      scope()       { return _scope;       }
    int                           bci()         { return _bci;         }
    GrowableArray<ScopeValue*>*   locals()      { return _locals;      }

@@ -233,25 +236,30 @@
    IRScopeDebugInfo*             caller()      { return _caller;      }
  
    //Whether we should reexecute this bytecode for deopt
    bool should_reexecute();
  
-   void record_debug_info(DebugInformationRecorder* recorder, int pc_offset, bool reexecute, bool is_method_handle_invoke = false) {
+   void record_debug_info(DebugInformationRecorder* recorder, int pc_offset, bool reexecute, bool is_method_handle_invoke = false, bool maybe_return_as_fields = false) {
      if (caller() != nullptr) {
        // Order is significant:  Must record caller first.
        caller()->record_debug_info(recorder, pc_offset, false/*reexecute*/);
      }
      DebugToken* locvals = recorder->create_scope_values(locals());
      DebugToken* expvals = recorder->create_scope_values(expressions());
      DebugToken* monvals = recorder->create_monitor_values(monitors());
      // reexecute allowed only for the topmost frame
-     bool return_oop = false; // This flag will be ignored since it used only for C2 with escape analysis.
+     bool return_oop = false;
+     bool return_scalarized = false;
+     if (maybe_return_as_fields) {
+       return_oop = true;
+       return_scalarized = true;
+     }
      bool rethrow_exception = false;
      bool has_ea_local_in_scope = false;
      bool arg_escape = false;
      recorder->describe_scope(pc_offset, methodHandle(), scope()->method(), bci(),
-                              reexecute, rethrow_exception, is_method_handle_invoke, return_oop,
+                              reexecute, rethrow_exception, is_method_handle_invoke, return_oop, return_scalarized,
                               has_ea_local_in_scope, arg_escape, locvals, expvals, monvals);
    }
  };
  
  

@@ -285,11 +293,11 @@
    XHandlers* exception_handlers() const          { return _exception_handlers; }
    ValueStack* stack() const                      { return _stack; }
    bool deoptimize_on_exception() const           { return _deoptimize_on_exception; }
  
    void add_register_oop(LIR_Opr opr);
-   void record_debug_info(DebugInformationRecorder* recorder, int pc_offset);
+   void record_debug_info(DebugInformationRecorder* recorder, int pc_offset, bool maybe_return_as_fields = false);
  
    bool     is_method_handle_invoke() const { return _is_method_handle_invoke;     }
    void set_is_method_handle_invoke(bool x) {        _is_method_handle_invoke = x; }
  
    bool     force_reexecute() const         { return _force_reexecute;             }