src/hotspot/share/opto/compile.hpp

*** 46,55 ****
--- 46,56 ----
  #include "utilities/ticks.hpp"
  
  class AddPNode;
  class Block;
  class Bundle;
+ class CallNode;
  class C2Compiler;
  class CallGenerator;
  class CloneMap;
  class ConnectionGraph;
  class InlineTree;
*** 82,91 ****
--- 83,93 ----
  class TypeData;
  class TypeInt;
  class TypePtr;
  class TypeOopPtr;
  class TypeFunc;
+ class ValueTypeBaseNode;
  class Unique_Node_List;
  class nmethod;
  class WarmCallInfo;
  class Node_Stack;
  struct Final_Reshape_Counts;
*** 378,387 ****
--- 380,393 ----
    uintx                 _max_node_limit;        // Max unique node count during a single compilation.
    // For deopt
    int                   _orig_pc_slot;
    int                   _orig_pc_slot_offset_in_bytes;
  
+   // For value type calling convention
+   int                   _sp_inc_slot;
+   int                   _sp_inc_slot_offset_in_bytes;
+ 
    int                   _major_progress;        // Count of something big happening
    bool                  _inlining_progress;     // progress doing incremental inlining?
    bool                  _inlining_incrementally;// Are we doing incremental inlining (post parse)
    bool                  _do_cleanup;            // Cleanup is needed before proceeding with incremental inlining
    bool                  _has_loops;             // True if the method _may_ have some loops
*** 428,437 ****
--- 434,444 ----
    GrowableArray<Node*>* _macro_nodes;           // List of nodes which need to be expanded before matching.
    GrowableArray<Node*>* _predicate_opaqs;       // List of Opaque1 nodes for the loop predicates.
    GrowableArray<Node*>* _expensive_nodes;       // List of nodes that are expensive to compute and that we'd better not let the GVN freely common
    GrowableArray<Node*>* _range_check_casts;     // List of CastII nodes with a range check dependency
    GrowableArray<Node*>* _opaque4_nodes;         // List of Opaque4 nodes that have a default value
+   Unique_Node_List*     _value_type_nodes;      // List of ValueType nodes
    ConnectionGraph*      _congraph;
  #ifndef PRODUCT
    IdealGraphPrinter*    _printer;
  #endif
  
*** 713,722 ****
--- 720,734 ----
    bool              use_rtm() const              { return (_rtm_state & NoRTM) == 0; }
    bool          profile_rtm() const              { return _rtm_state == ProfileRTM; }
    uint              max_node_limit() const       { return (uint)_max_node_limit; }
    void          set_max_node_limit(uint n)       { _max_node_limit = n; }
  
+   // Support for scalarized value type calling convention
+   bool              has_scalarized_args() const  { return _method != NULL && _method->has_scalarized_args(); }
+   bool              needs_stack_repair()  const  { return _method != NULL && _method->get_Method()->needs_stack_repair(); }
+   int               sp_inc_offset()       const  { return _sp_inc_slot_offset_in_bytes; }
+ 
    // check the CompilerOracle for special behaviours for this compile
    bool          method_has_option(const char * option) {
      return method() != NULL && method()->has_option(option);
    }
  
*** 834,843 ****
--- 846,861 ----
    }
    Node* opaque4_node(int idx) const { return _opaque4_nodes->at(idx);  }
    int   opaque4_count()       const { return _opaque4_nodes->length(); }
    void  remove_opaque4_nodes(PhaseIterGVN &igvn);
  
+   // Keep track of value type nodes for later processing
+   void add_value_type(Node* n);
+   void remove_value_type(Node* n);
+   void process_value_types(PhaseIterGVN &igvn);
+   bool can_add_value_type() const { return _value_type_nodes != NULL; }
+ 
    // remove the opaque nodes that protect the predicates so that the unused checks and
    // uncommon traps will be eliminated from the graph.
    void cleanup_loop_predicates(PhaseIterGVN &igvn);
    bool is_predicate_opaq(Node * n) {
      return _predicate_opaqs->contains(n);
*** 1366,1375 ****
--- 1384,1395 ----
                                Node* ctrl = NULL);
  
    // Convert integer value to a narrowed long type dependent on ctrl (for example, a range check)
    static Node* constrained_convI2L(PhaseGVN* phase, Node* value, const TypeInt* itype, Node* ctrl);
  
+   Node* optimize_acmp(PhaseGVN* phase, Node* a, Node* b);
+ 
    // Auxiliary method for randomized fuzzing/stressing
    static bool randomized_select(int count);
  
    // supporting clone_map
    CloneMap&     clone_map();