src/share/vm/opto/memnode.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File 8036851 Sdiff src/share/vm/opto

src/share/vm/opto/memnode.hpp

Print this page




 350   LoadL_unalignedNode(Node *c, Node *mem, Node *adr, const TypePtr* at, MemOrd mo)
 351     : LoadLNode(c, mem, adr, at, TypeLong::LONG, mo) {}
 352   virtual int Opcode() const;
 353 };
 354 
 355 //------------------------------LoadFNode--------------------------------------
 356 // Load a float (64 bits) from memory
 357 class LoadFNode : public LoadNode {
 358 public:
 359   LoadFNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *t, MemOrd mo)
 360     : LoadNode(c, mem, adr, at, t, mo) {}
 361   virtual int Opcode() const;
 362   virtual uint ideal_reg() const { return Op_RegF; }
 363   virtual int store_Opcode() const { return Op_StoreF; }
 364   virtual BasicType memory_type() const { return T_FLOAT; }
 365 };
 366 
 367 //------------------------------LoadDNode--------------------------------------
 368 // Load a double (64 bits) from memory
 369 class LoadDNode : public LoadNode {








 370 public:
 371   LoadDNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *t, MemOrd mo)
 372     : LoadNode(c, mem, adr, at, t, mo) {}

 373   virtual int Opcode() const;
 374   virtual uint ideal_reg() const { return Op_RegD; }
 375   virtual int store_Opcode() const { return Op_StoreD; }
 376   virtual BasicType memory_type() const { return T_DOUBLE; }









 377 };
 378 
 379 //------------------------------LoadD_unalignedNode----------------------------
 380 // Load a double from unaligned memory
 381 class LoadD_unalignedNode : public LoadDNode {
 382 public:
 383   LoadD_unalignedNode(Node *c, Node *mem, Node *adr, const TypePtr* at, MemOrd mo)
 384     : LoadDNode(c, mem, adr, at, Type::DOUBLE, mo) {}
 385   virtual int Opcode() const;
 386 };
 387 
 388 //------------------------------LoadPNode--------------------------------------
 389 // Load a pointer from memory (either object or array)
 390 class LoadPNode : public LoadNode {
 391 public:
 392   LoadPNode(Node *c, Node *mem, Node *adr, const TypePtr *at, const TypePtr* t, MemOrd mo)
 393     : LoadNode(c, mem, adr, at, t, mo) {}
 394   virtual int Opcode() const;
 395   virtual uint ideal_reg() const { return Op_RegP; }
 396   virtual int store_Opcode() const { return Op_StoreP; }


 580   virtual void dump_spec(outputStream *st) const {
 581     StoreNode::dump_spec(st);
 582     if (_require_atomic_access)  st->print(" Atomic!");
 583   }
 584 #endif
 585 };
 586 
 587 //------------------------------StoreFNode-------------------------------------
 588 // Store float to memory
 589 class StoreFNode : public StoreNode {
 590 public:
 591   StoreFNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo)
 592     : StoreNode(c, mem, adr, at, val, mo) {}
 593   virtual int Opcode() const;
 594   virtual BasicType memory_type() const { return T_FLOAT; }
 595 };
 596 
 597 //------------------------------StoreDNode-------------------------------------
 598 // Store double to memory
 599 class StoreDNode : public StoreNode {







 600 public:
 601   StoreDNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo)
 602     : StoreNode(c, mem, adr, at, val, mo) {}

 603   virtual int Opcode() const;
 604   virtual BasicType memory_type() const { return T_DOUBLE; }









 605 };
 606 
 607 //------------------------------StorePNode-------------------------------------
 608 // Store pointer to memory
 609 class StorePNode : public StoreNode {
 610 public:
 611   StorePNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo)
 612     : StoreNode(c, mem, adr, at, val, mo) {}
 613   virtual int Opcode() const;
 614   virtual BasicType memory_type() const { return T_ADDRESS; }
 615 };
 616 
 617 //------------------------------StoreNNode-------------------------------------
 618 // Store narrow oop to memory
 619 class StoreNNode : public StoreNode {
 620 public:
 621   StoreNNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo)
 622     : StoreNode(c, mem, adr, at, val, mo) {}
 623   virtual int Opcode() const;
 624   virtual BasicType memory_type() const { return T_NARROWOOP; }




 350   LoadL_unalignedNode(Node *c, Node *mem, Node *adr, const TypePtr* at, MemOrd mo)
 351     : LoadLNode(c, mem, adr, at, TypeLong::LONG, mo) {}
 352   virtual int Opcode() const;
 353 };
 354 
 355 //------------------------------LoadFNode--------------------------------------
 356 // Load a float (64 bits) from memory
 357 class LoadFNode : public LoadNode {
 358 public:
 359   LoadFNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *t, MemOrd mo)
 360     : LoadNode(c, mem, adr, at, t, mo) {}
 361   virtual int Opcode() const;
 362   virtual uint ideal_reg() const { return Op_RegF; }
 363   virtual int store_Opcode() const { return Op_StoreF; }
 364   virtual BasicType memory_type() const { return T_FLOAT; }
 365 };
 366 
 367 //------------------------------LoadDNode--------------------------------------
 368 // Load a double (64 bits) from memory
 369 class LoadDNode : public LoadNode {
 370   virtual uint hash() const { return LoadNode::hash() + _require_atomic_access; }
 371   virtual uint cmp( const Node &n ) const {
 372     return _require_atomic_access == ((LoadDNode&)n)._require_atomic_access
 373       && LoadNode::cmp(n);
 374   }
 375   virtual uint size_of() const { return sizeof(*this); }
 376   const bool _require_atomic_access;  // is piecewise load forbidden?
 377 
 378 public:
 379   LoadDNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *t,
 380             MemOrd mo, bool require_atomic_access = false)
 381     : LoadNode(c, mem, adr, at, t, mo), _require_atomic_access(require_atomic_access) {}
 382   virtual int Opcode() const;
 383   virtual uint ideal_reg() const { return Op_RegD; }
 384   virtual int store_Opcode() const { return Op_StoreD; }
 385   virtual BasicType memory_type() const { return T_DOUBLE; }
 386   bool require_atomic_access() { return _require_atomic_access; }
 387   static LoadDNode* make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type,
 388                                 const Type* rt, MemOrd mo);
 389 #ifndef PRODUCT
 390   virtual void dump_spec(outputStream *st) const {
 391     LoadNode::dump_spec(st);
 392     if (_require_atomic_access)  st->print(" Atomic!");
 393   }
 394 #endif
 395 };
 396 
 397 //------------------------------LoadD_unalignedNode----------------------------
 398 // Load a double from unaligned memory
 399 class LoadD_unalignedNode : public LoadDNode {
 400 public:
 401   LoadD_unalignedNode(Node *c, Node *mem, Node *adr, const TypePtr* at, MemOrd mo)
 402     : LoadDNode(c, mem, adr, at, Type::DOUBLE, mo) {}
 403   virtual int Opcode() const;
 404 };
 405 
 406 //------------------------------LoadPNode--------------------------------------
 407 // Load a pointer from memory (either object or array)
 408 class LoadPNode : public LoadNode {
 409 public:
 410   LoadPNode(Node *c, Node *mem, Node *adr, const TypePtr *at, const TypePtr* t, MemOrd mo)
 411     : LoadNode(c, mem, adr, at, t, mo) {}
 412   virtual int Opcode() const;
 413   virtual uint ideal_reg() const { return Op_RegP; }
 414   virtual int store_Opcode() const { return Op_StoreP; }


 598   virtual void dump_spec(outputStream *st) const {
 599     StoreNode::dump_spec(st);
 600     if (_require_atomic_access)  st->print(" Atomic!");
 601   }
 602 #endif
 603 };
 604 
 605 //------------------------------StoreFNode-------------------------------------
 606 // Store float to memory
 607 class StoreFNode : public StoreNode {
 608 public:
 609   StoreFNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo)
 610     : StoreNode(c, mem, adr, at, val, mo) {}
 611   virtual int Opcode() const;
 612   virtual BasicType memory_type() const { return T_FLOAT; }
 613 };
 614 
 615 //------------------------------StoreDNode-------------------------------------
 616 // Store double to memory
 617 class StoreDNode : public StoreNode {
 618   virtual uint hash() const { return StoreNode::hash() + _require_atomic_access; }
 619   virtual uint cmp( const Node &n ) const {
 620     return _require_atomic_access == ((StoreDNode&)n)._require_atomic_access
 621       && StoreNode::cmp(n);
 622   }
 623   virtual uint size_of() const { return sizeof(*this); }
 624   const bool _require_atomic_access;  // is piecewise store forbidden?
 625 public:
 626   StoreDNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val,
 627              MemOrd mo, bool require_atomic_access = false)
 628     : StoreNode(c, mem, adr, at, val, mo), _require_atomic_access(require_atomic_access) {}
 629   virtual int Opcode() const;
 630   virtual BasicType memory_type() const { return T_DOUBLE; }
 631   bool require_atomic_access() { return _require_atomic_access; }
 632   static StoreDNode* make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo);
 633 #ifndef PRODUCT
 634   virtual void dump_spec(outputStream *st) const {
 635     StoreNode::dump_spec(st);
 636     if (_require_atomic_access)  st->print(" Atomic!");
 637   }
 638 #endif
 639 
 640 };
 641 
 642 //------------------------------StorePNode-------------------------------------
 643 // Store pointer to memory
 644 class StorePNode : public StoreNode {
 645 public:
 646   StorePNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo)
 647     : StoreNode(c, mem, adr, at, val, mo) {}
 648   virtual int Opcode() const;
 649   virtual BasicType memory_type() const { return T_ADDRESS; }
 650 };
 651 
 652 //------------------------------StoreNNode-------------------------------------
 653 // Store narrow oop to memory
 654 class StoreNNode : public StoreNode {
 655 public:
 656   StoreNNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo)
 657     : StoreNode(c, mem, adr, at, val, mo) {}
 658   virtual int Opcode() const;
 659   virtual BasicType memory_type() const { return T_NARROWOOP; }


src/share/vm/opto/memnode.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File