src/share/vm/opto/memnode.hpp

*** 1,7 ****
  /*
!  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
--- 1,7 ----
  /*
!  * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
*** 331,341 ****
    virtual int Opcode() const;
    virtual uint ideal_reg() const { return Op_RegL; }
    virtual int store_Opcode() const { return Op_StoreL; }
    virtual BasicType memory_type() const { return T_LONG; }
    bool require_atomic_access() const { return _require_atomic_access; }
!   static LoadLNode* make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type,
                                  const Type* rt, MemOrd mo);
  #ifndef PRODUCT
    virtual void dump_spec(outputStream *st) const {
      LoadNode::dump_spec(st);
      if (_require_atomic_access)  st->print(" Atomic!");
--- 331,341 ----
    virtual int Opcode() const;
    virtual uint ideal_reg() const { return Op_RegL; }
    virtual int store_Opcode() const { return Op_StoreL; }
    virtual BasicType memory_type() const { return T_LONG; }
    bool require_atomic_access() const { return _require_atomic_access; }
!   static LoadLNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type,
                                  const Type* rt, MemOrd mo);
  #ifndef PRODUCT
    virtual void dump_spec(outputStream *st) const {
      LoadNode::dump_spec(st);
      if (_require_atomic_access)  st->print(" Atomic!");
*** 382,392 ****
    virtual int Opcode() const;
    virtual uint ideal_reg() const { return Op_RegD; }
    virtual int store_Opcode() const { return Op_StoreD; }
    virtual BasicType memory_type() const { return T_DOUBLE; }
    bool require_atomic_access() const { return _require_atomic_access; }
!   static LoadDNode* make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type,
                                  const Type* rt, MemOrd mo);
  #ifndef PRODUCT
    virtual void dump_spec(outputStream *st) const {
      LoadNode::dump_spec(st);
      if (_require_atomic_access)  st->print(" Atomic!");
--- 382,392 ----
    virtual int Opcode() const;
    virtual uint ideal_reg() const { return Op_RegD; }
    virtual int store_Opcode() const { return Op_StoreD; }
    virtual BasicType memory_type() const { return T_DOUBLE; }
    bool require_atomic_access() const { return _require_atomic_access; }
!   static LoadDNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type,
                                  const Type* rt, MemOrd mo);
  #ifndef PRODUCT
    virtual void dump_spec(outputStream *st) const {
      LoadNode::dump_spec(st);
      if (_require_atomic_access)  st->print(" Atomic!");
*** 591,601 ****
    StoreLNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo, bool require_atomic_access = false)
      : StoreNode(c, mem, adr, at, val, mo), _require_atomic_access(require_atomic_access) {}
    virtual int Opcode() const;
    virtual BasicType memory_type() const { return T_LONG; }
    bool require_atomic_access() const { return _require_atomic_access; }
!   static StoreLNode* make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo);
  #ifndef PRODUCT
    virtual void dump_spec(outputStream *st) const {
      StoreNode::dump_spec(st);
      if (_require_atomic_access)  st->print(" Atomic!");
    }
--- 591,601 ----
    StoreLNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo, bool require_atomic_access = false)
      : StoreNode(c, mem, adr, at, val, mo), _require_atomic_access(require_atomic_access) {}
    virtual int Opcode() const;
    virtual BasicType memory_type() const { return T_LONG; }
    bool require_atomic_access() const { return _require_atomic_access; }
!   static StoreLNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo);
  #ifndef PRODUCT
    virtual void dump_spec(outputStream *st) const {
      StoreNode::dump_spec(st);
      if (_require_atomic_access)  st->print(" Atomic!");
    }
*** 627,637 ****
               MemOrd mo, bool require_atomic_access = false)
      : StoreNode(c, mem, adr, at, val, mo), _require_atomic_access(require_atomic_access) {}
    virtual int Opcode() const;
    virtual BasicType memory_type() const { return T_DOUBLE; }
    bool require_atomic_access() const { return _require_atomic_access; }
!   static StoreDNode* make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo);
  #ifndef PRODUCT
    virtual void dump_spec(outputStream *st) const {
      StoreNode::dump_spec(st);
      if (_require_atomic_access)  st->print(" Atomic!");
    }
--- 627,637 ----
               MemOrd mo, bool require_atomic_access = false)
      : StoreNode(c, mem, adr, at, val, mo), _require_atomic_access(require_atomic_access) {}
    virtual int Opcode() const;
    virtual BasicType memory_type() const { return T_DOUBLE; }
    bool require_atomic_access() const { return _require_atomic_access; }
!   static StoreDNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo);
  #ifndef PRODUCT
    virtual void dump_spec(outputStream *st) const {
      StoreNode::dump_spec(st);
      if (_require_atomic_access)  st->print(" Atomic!");
    }
*** 1136,1146 ****
  
  public:
    // If the input is a whole memory state, clone it with all its slices intact.
    // Otherwise, make a new memory state with just that base memory input.
    // In either case, the result is a newly created MergeMem.
!   static MergeMemNode* make(Compile* C, Node* base_memory);
  
    virtual int Opcode() const;
    virtual Node *Identity( PhaseTransform *phase );
    virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
    virtual uint ideal_reg() const { return NotAMachineReg; }
--- 1136,1146 ----
  
  public:
    // If the input is a whole memory state, clone it with all its slices intact.
    // Otherwise, make a new memory state with just that base memory input.
    // In either case, the result is a newly created MergeMem.
!   static MergeMemNode* make(Node* base_memory);
  
    virtual int Opcode() const;
    virtual Node *Identity( PhaseTransform *phase );
    virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
    virtual uint ideal_reg() const { return NotAMachineReg; }