536   }
 537   // This is the base version which is given an alias index.
 538   Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, int adr_idx,
 539                   MemNode::MemOrd mo, LoadNode::ControlDependency control_dependency = LoadNode::DependsOnlyOnTest,
 540                   bool require_atomic_access = false, bool unaligned = false,
 541                   bool mismatched = false);
 542 
 543   // Create & transform a StoreNode and store the effect into the
 544   // parser's memory state.
 545   //
 546   // We must ensure that stores of object references will be visible
 547   // only after the object's initialization. So the clients of this
 548   // procedure must indicate that the store requires `release'
 549   // semantics, if the stored value is an object reference that might
 550   // point to a new object and may become externally visible.
 551   Node* store_to_memory(Node* ctl, Node* adr, Node* val, BasicType bt,
 552                         const TypePtr* adr_type,
 553                         MemNode::MemOrd mo,
 554                         bool require_atomic_access = false,
 555                         bool unaligned = false,
 556                         bool mismatched = false) {

 557     // This version computes alias_index from an address type
 558     assert(adr_type != NULL, "use other store_to_memory factory");
 559     return store_to_memory(ctl, adr, val, bt,
 560                            C->get_alias_index(adr_type),
 561                            mo, require_atomic_access,
 562                            unaligned, mismatched);

 563   }
 564   // This is the base version which is given alias index
 565   // Return the new StoreXNode
 566   Node* store_to_memory(Node* ctl, Node* adr, Node* val, BasicType bt,
 567                         int adr_idx,
 568                         MemNode::MemOrd,
 569                         bool require_atomic_access = false,
 570                         bool unaligned = false,
 571                         bool mismatched = false);

 572 
 573   // Perform decorated accesses
 574 
 575   Node* access_store_at(Node* ctl,
 576                         Node* obj,   // containing obj
 577                         Node* adr,   // actual adress to store val at
 578                         const TypePtr* adr_type,
 579                         Node* val,
 580                         const Type* val_type,
 581                         BasicType bt,
 582                         DecoratorSet decorators);
 583 
 584   Node* access_load_at(Node* obj,   // containing obj
 585                        Node* adr,   // actual adress to load val at
 586                        const TypePtr* adr_type,
 587                        const Type* val_type,
 588                        BasicType bt,
 589                        DecoratorSet decorators);
 590 
 591   Node* access_load(Node* adr,   // actual adress to load val at

 536   }
 537   // This is the base version which is given an alias index.
 538   Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, int adr_idx,
 539                   MemNode::MemOrd mo, LoadNode::ControlDependency control_dependency = LoadNode::DependsOnlyOnTest,
 540                   bool require_atomic_access = false, bool unaligned = false,
 541                   bool mismatched = false);
 542 
 543   // Create & transform a StoreNode and store the effect into the
 544   // parser's memory state.
 545   //
 546   // We must ensure that stores of object references will be visible
 547   // only after the object's initialization. So the clients of this
 548   // procedure must indicate that the store requires `release'
 549   // semantics, if the stored value is an object reference that might
 550   // point to a new object and may become externally visible.
 551   Node* store_to_memory(Node* ctl, Node* adr, Node* val, BasicType bt,
 552                         const TypePtr* adr_type,
 553                         MemNode::MemOrd mo,
 554                         bool require_atomic_access = false,
 555                         bool unaligned = false,
 556                         bool mismatched = false,
 557                         int storeZ = -1) {
 558     // This version computes alias_index from an address type
 559     assert(adr_type != NULL, "use other store_to_memory factory");
 560     return store_to_memory(ctl, adr, val, bt,
 561                            C->get_alias_index(adr_type),
 562                            mo, require_atomic_access,
 563                            unaligned, mismatched,
 564                            storeZ);
 565   }
 566   // This is the base version which is given alias index
 567   // Return the new StoreXNode
 568   Node* store_to_memory(Node* ctl, Node* adr, Node* val, BasicType bt,
 569                         int adr_idx,
 570                         MemNode::MemOrd,
 571                         bool require_atomic_access = false,
 572                         bool unaligned = false,
 573                         bool mismatched = false,
 574                         int storeZ = -1);
 575 
 576   // Perform decorated accesses
 577 
 578   Node* access_store_at(Node* ctl,
 579                         Node* obj,   // containing obj
 580                         Node* adr,   // actual adress to store val at
 581                         const TypePtr* adr_type,
 582                         Node* val,
 583                         const Type* val_type,
 584                         BasicType bt,
 585                         DecoratorSet decorators);
 586 
 587   Node* access_load_at(Node* obj,   // containing obj
 588                        Node* adr,   // actual adress to load val at
 589                        const TypePtr* adr_type,
 590                        const Type* val_type,
 591                        BasicType bt,
 592                        DecoratorSet decorators);
 593 
 594   Node* access_load(Node* adr,   // actual adress to load val at