src/share/vm/opto/graphKit.hpp

rev 9120 : 8136473: failed: no mismatched stores, except on raw memory: StoreB StoreI
Summary: Mismatched stores on same slice possible with Unsafe.Put*Unaligned methods
Reviewed-by:

*** 511,537 ****
    // We choose the unordered semantics by default because we have
    // adapted the `do_put_xxx' and `do_get_xxx' procedures for the case
    // of volatile fields.
    Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt,
                    MemNode::MemOrd mo, LoadNode::ControlDependency control_dependency = LoadNode::DependsOnlyOnTest,
!                   bool require_atomic_access = false) {
      // This version computes alias_index from bottom_type
      return make_load(ctl, adr, t, bt, adr->bottom_type()->is_ptr(),
!                      mo, control_dependency, require_atomic_access);
    }
    Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, const TypePtr* adr_type,
                    MemNode::MemOrd mo, LoadNode::ControlDependency control_dependency = LoadNode::DependsOnlyOnTest,
!                   bool require_atomic_access = false) {
      // This version computes alias_index from an address type
      assert(adr_type != NULL, "use other make_load factory");
      return make_load(ctl, adr, t, bt, C->get_alias_index(adr_type),
!                      mo, control_dependency, require_atomic_access);
    }
    // This is the base version which is given an alias index.
    Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, int adr_idx,
                    MemNode::MemOrd mo, LoadNode::ControlDependency control_dependency = LoadNode::DependsOnlyOnTest,
!                   bool require_atomic_access = false);
  
    // Create & transform a StoreNode and store the effect into the
    // parser's memory state.
    //
    // We must ensure that stores of object references will be visible
--- 511,542 ----
    // We choose the unordered semantics by default because we have
    // adapted the `do_put_xxx' and `do_get_xxx' procedures for the case
    // of volatile fields.
    Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt,
                    MemNode::MemOrd mo, LoadNode::ControlDependency control_dependency = LoadNode::DependsOnlyOnTest,
!                   bool require_atomic_access = false, bool unaligned = false,
!                   bool mismatched = false) {
      // This version computes alias_index from bottom_type
      return make_load(ctl, adr, t, bt, adr->bottom_type()->is_ptr(),
!                      mo, control_dependency, require_atomic_access,
!                      unaligned, mismatched);
    }
    Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, const TypePtr* adr_type,
                    MemNode::MemOrd mo, LoadNode::ControlDependency control_dependency = LoadNode::DependsOnlyOnTest,
!                   bool require_atomic_access = false, bool unaligned = false,
!                   bool mismatched = false) {
      // This version computes alias_index from an address type
      assert(adr_type != NULL, "use other make_load factory");
      return make_load(ctl, adr, t, bt, C->get_alias_index(adr_type),
!                      mo, control_dependency, require_atomic_access,
!                      unaligned, mismatched);
    }
    // This is the base version which is given an alias index.
    Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, int adr_idx,
                    MemNode::MemOrd mo, LoadNode::ControlDependency control_dependency = LoadNode::DependsOnlyOnTest,
!                   bool require_atomic_access = false, bool unaligned = false,
!                   bool mismatched = false);
  
    // Create & transform a StoreNode and store the effect into the
    // parser's memory state.
    //
    // We must ensure that stores of object references will be visible
*** 540,562 ****
    // semantics, if the stored value is an object reference that might
    // point to a new object and may become externally visible.
    Node* store_to_memory(Node* ctl, Node* adr, Node* val, BasicType bt,
                          const TypePtr* adr_type,
                          MemNode::MemOrd mo,
!                         bool require_atomic_access = false) {
      // This version computes alias_index from an address type
      assert(adr_type != NULL, "use other store_to_memory factory");
      return store_to_memory(ctl, adr, val, bt,
                             C->get_alias_index(adr_type),
!                            mo, require_atomic_access);
    }
    // This is the base version which is given alias index
    // Return the new StoreXNode
    Node* store_to_memory(Node* ctl, Node* adr, Node* val, BasicType bt,
                          int adr_idx,
                          MemNode::MemOrd,
!                         bool require_atomic_access = false);
  
  
    // All in one pre-barrier, store, post_barrier
    // Insert a write-barrier'd store.  This is to let generational GC
    // work; we have to flag all oop-stores before the next GC point.
--- 545,572 ----
    // semantics, if the stored value is an object reference that might
    // point to a new object and may become externally visible.
    Node* store_to_memory(Node* ctl, Node* adr, Node* val, BasicType bt,
                          const TypePtr* adr_type,
                          MemNode::MemOrd mo,
!                         bool require_atomic_access = false,
!                         bool unaligned = false,
!                         bool mismatched = false) {
      // This version computes alias_index from an address type
      assert(adr_type != NULL, "use other store_to_memory factory");
      return store_to_memory(ctl, adr, val, bt,
                             C->get_alias_index(adr_type),
!                            mo, require_atomic_access,
!                            unaligned, mismatched);
    }
    // This is the base version which is given alias index
    // Return the new StoreXNode
    Node* store_to_memory(Node* ctl, Node* adr, Node* val, BasicType bt,
                          int adr_idx,
                          MemNode::MemOrd,
!                         bool require_atomic_access = false,
!                         bool unaligned = false,
!                         bool mismatched = false);
  
  
    // All in one pre-barrier, store, post_barrier
    // Insert a write-barrier'd store.  This is to let generational GC
    // work; we have to flag all oop-stores before the next GC point.
*** 575,585 ****
                    const TypePtr* adr_type,
                    Node* val,
                    const TypeOopPtr* val_type,
                    BasicType bt,
                    bool use_precise,
!                   MemNode::MemOrd mo);
  
    Node* store_oop_to_object(Node* ctl,
                              Node* obj,   // containing obj
                              Node* adr,   // actual adress to store val at
                              const TypePtr* adr_type,
--- 585,596 ----
                    const TypePtr* adr_type,
                    Node* val,
                    const TypeOopPtr* val_type,
                    BasicType bt,
                    bool use_precise,
!                   MemNode::MemOrd mo,
!                   bool mismatched = false);
  
    Node* store_oop_to_object(Node* ctl,
                              Node* obj,   // containing obj
                              Node* adr,   // actual adress to store val at
                              const TypePtr* adr_type,
*** 606,616 ****
                               Node* obj,   // containing obj
                               Node* adr,   // actual adress to store val at
                               const TypePtr* adr_type,
                               Node* val,
                               BasicType bt,
!                              MemNode::MemOrd mo);
  
    // For the few case where the barriers need special help
    void pre_barrier(bool do_load, Node* ctl,
                     Node* obj, Node* adr, uint adr_idx, Node* val, const TypeOopPtr* val_type,
                     Node* pre_val,
--- 617,628 ----
                               Node* obj,   // containing obj
                               Node* adr,   // actual adress to store val at
                               const TypePtr* adr_type,
                               Node* val,
                               BasicType bt,
!                              MemNode::MemOrd mo,
!                              bool mismatched = false);
  
    // For the few case where the barriers need special help
    void pre_barrier(bool do_load, Node* ctl,
                     Node* obj, Node* adr, uint adr_idx, Node* val, const TypeOopPtr* val_type,
                     Node* pre_val,