src/hotspot/share/opto/compile.hpp

*** 380,389 ****
--- 380,391 ----
                                                        // main parsing has finished.
    GrowableArray<CallGenerator*> _string_late_inlines; // same but for string operations
  
    GrowableArray<CallGenerator*> _boxing_late_inlines; // same but for boxing operations
  
+   GrowableArray<CallGenerator*> _vector_reboxing_late_inlines; // same but for vector reboxing operations
+ 
    int                           _late_inlines_pos;    // Where in the queue should the next late inlining candidate go (emulate depth first inlining)
    uint                          _number_of_mh_late_inlines; // number of method handle late inlining still pending
  
  
    // Inlining may not happen in parse order which would make
*** 641,651 ****
--- 643,655 ----
  #else
      return false;
  #endif
    }
  
+   void print_method(CompilerPhaseType cpt, const char *name, int level = 1, int idx = 0);
    void print_method(CompilerPhaseType cpt, int level = 1, int idx = 0);
+   void print_method(CompilerPhaseType cpt, Node* n, int level = 3);
  
  #ifndef PRODUCT
    void igv_print_method_to_file(const char* phase_name = "Debug", bool append = false);
    void igv_print_method_to_network(const char* phase_name = "Debug");
    static IdealGraphPrinter* debug_file_printer() { return _debug_file_printer; }
*** 862,875 ****
    CallGenerator*    call_generator(ciMethod* call_method, int vtable_index, bool call_does_dispatch,
                                     JVMState* jvms, bool allow_inline, float profile_factor, ciKlass* speculative_receiver_type = NULL,
                                     bool allow_intrinsics = true);
    bool should_delay_inlining(ciMethod* call_method, JVMState* jvms) {
      return should_delay_string_inlining(call_method, jvms) ||
!            should_delay_boxing_inlining(call_method, jvms);
    }
    bool should_delay_string_inlining(ciMethod* call_method, JVMState* jvms);
    bool should_delay_boxing_inlining(ciMethod* call_method, JVMState* jvms);
  
    // Helper functions to identify inlining potential at call-site
    ciMethod* optimize_virtual_call(ciMethod* caller, int bci, ciInstanceKlass* klass,
                                    ciKlass* holder, ciMethod* callee,
                                    const TypeOopPtr* receiver_type, bool is_virtual,
--- 866,882 ----
    CallGenerator*    call_generator(ciMethod* call_method, int vtable_index, bool call_does_dispatch,
                                     JVMState* jvms, bool allow_inline, float profile_factor, ciKlass* speculative_receiver_type = NULL,
                                     bool allow_intrinsics = true);
    bool should_delay_inlining(ciMethod* call_method, JVMState* jvms) {
      return should_delay_string_inlining(call_method, jvms) ||
!            should_delay_boxing_inlining(call_method, jvms) ||
!            should_delay_vector_inlining(call_method, jvms);
    }
    bool should_delay_string_inlining(ciMethod* call_method, JVMState* jvms);
    bool should_delay_boxing_inlining(ciMethod* call_method, JVMState* jvms);
+   bool should_delay_vector_inlining(ciMethod* call_method, JVMState* jvms);
+   bool should_delay_vector_reboxing_inlining(ciMethod* call_method, JVMState* jvms);
  
    // Helper functions to identify inlining potential at call-site
    ciMethod* optimize_virtual_call(ciMethod* caller, int bci, ciInstanceKlass* klass,
                                    ciKlass* holder, ciMethod* callee,
                                    const TypeOopPtr* receiver_type, bool is_virtual,
*** 937,946 ****
--- 944,957 ----
  
    void              add_boxing_late_inline(CallGenerator* cg) {
      _boxing_late_inlines.push(cg);
    }
  
+   void              add_vector_reboxing_late_inline(CallGenerator* cg) {
+     _vector_reboxing_late_inlines.push(cg);
+   }
+ 
    void remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Unique_Node_List &useful);
  
    void process_print_inlining();
    void dump_print_inlining();
  
*** 966,975 ****
--- 977,989 ----
    void inline_string_calls(bool parse_time);
    void inline_boxing_calls(PhaseIterGVN& igvn);
    bool optimize_loops(PhaseIterGVN& igvn, LoopOptsMode mode);
    void remove_root_to_sfpts_edges(PhaseIterGVN& igvn);
  
+   void inline_vector_reboxing_calls();
+   bool has_vbox_nodes();
+ 
    // Matching, CFG layout, allocation, code generation
    PhaseCFG*         cfg()                       { return _cfg; }
    bool              has_java_calls() const      { return _java_calls > 0; }
    int               java_calls() const          { return _java_calls; }
    int               inner_loops() const         { return _inner_loops; }