Mercurial > hg > graal-jvmci-8

comparison src/share/vm/opto/memnode.hpp @ 23054:55d07ec5bde4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8036851: volatile double accesses are not explicitly atomic in C2 Summary: The C2 structure is adapted to distinguish between volatile and non-volatile double accesses. Reviewed-by: twisti, kvn Contributed-by: Tobias Hartmann <tobias.hartmann@oracle.com>
author anoll
date Tue, 06 May 2014 09:17:57 +0200
parents e7b3d177adda
children c1c199dde5c9
comparison
equal deleted inserted replaced
23053:8c3941f2020c 23054:55d07ec5bde4
334 : LoadNode(c, mem, adr, at, tl, mo), _require_atomic_access(require_atomic_access) {} 334 : LoadNode(c, mem, adr, at, tl, mo), _require_atomic_access(require_atomic_access) {}
335 virtual int Opcode() const; 335 virtual int Opcode() const;
336 virtual uint ideal_reg() const { return Op_RegL; } 336 virtual uint ideal_reg() const { return Op_RegL; }
337 virtual int store_Opcode() const { return Op_StoreL; } 337 virtual int store_Opcode() const { return Op_StoreL; }
338 virtual BasicType memory_type() const { return T_LONG; } 338 virtual BasicType memory_type() const { return T_LONG; }
339 bool require_atomic_access() { return _require_atomic_access; } 339 bool require_atomic_access() const { return _require_atomic_access; }
340 static LoadLNode* make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, 340 static LoadLNode* make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type,
341 const Type* rt, MemOrd mo); 341 const Type* rt, MemOrd mo);
342 #ifndef PRODUCT 342 #ifndef PRODUCT
343 virtual void dump_spec(outputStream *st) const { 343 virtual void dump_spec(outputStream *st) const {
344 LoadNode::dump_spec(st); 344 LoadNode::dump_spec(st);
369 }; 369 };
370 370
371 //------------------------------LoadDNode-------------------------------------- 371 //------------------------------LoadDNode--------------------------------------
372 // Load a double (64 bits) from memory 372 // Load a double (64 bits) from memory
373 class LoadDNode : public LoadNode { 373 class LoadDNode : public LoadNode {
374 public: 374 virtual uint hash() const { return LoadNode::hash() + _require_atomic_access; }
375 LoadDNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *t, MemOrd mo) 375 virtual uint cmp( const Node &n ) const {
376 : LoadNode(c, mem, adr, at, t, mo) {} 376 return _require_atomic_access == ((LoadDNode&)n)._require_atomic_access
377 && LoadNode::cmp(n);
378 }
379 virtual uint size_of() const { return sizeof(*this); }
380 const bool _require_atomic_access; // is piecewise load forbidden?
381
382 public:
383 LoadDNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *t,
384 MemOrd mo, bool require_atomic_access = false)
385 : LoadNode(c, mem, adr, at, t, mo), _require_atomic_access(require_atomic_access) {}
377 virtual int Opcode() const; 386 virtual int Opcode() const;
378 virtual uint ideal_reg() const { return Op_RegD; } 387 virtual uint ideal_reg() const { return Op_RegD; }
379 virtual int store_Opcode() const { return Op_StoreD; } 388 virtual int store_Opcode() const { return Op_StoreD; }
380 virtual BasicType memory_type() const { return T_DOUBLE; } 389 virtual BasicType memory_type() const { return T_DOUBLE; }
390 bool require_atomic_access() const { return _require_atomic_access; }
391 static LoadDNode* make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type,
392 const Type* rt, MemOrd mo);
393 #ifndef PRODUCT
394 virtual void dump_spec(outputStream *st) const {
395 LoadNode::dump_spec(st);
396 if (_require_atomic_access) st->print(" Atomic!");
397 }
398 #endif
381 }; 399 };
382 400
383 //------------------------------LoadD_unalignedNode---------------------------- 401 //------------------------------LoadD_unalignedNode----------------------------
384 // Load a double from unaligned memory 402 // Load a double from unaligned memory
385 class LoadD_unalignedNode : public LoadDNode { 403 class LoadD_unalignedNode : public LoadDNode {
580 public: 598 public:
581 StoreLNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo, bool require_atomic_access = false) 599 StoreLNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo, bool require_atomic_access = false)
582 : StoreNode(c, mem, adr, at, val, mo), _require_atomic_access(require_atomic_access) {} 600 : StoreNode(c, mem, adr, at, val, mo), _require_atomic_access(require_atomic_access) {}
583 virtual int Opcode() const; 601 virtual int Opcode() const;
584 virtual BasicType memory_type() const { return T_LONG; } 602 virtual BasicType memory_type() const { return T_LONG; }
585 bool require_atomic_access() { return _require_atomic_access; } 603 bool require_atomic_access() const { return _require_atomic_access; }
586 static StoreLNode* make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo); 604 static StoreLNode* make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo);
587 #ifndef PRODUCT 605 #ifndef PRODUCT
588 virtual void dump_spec(outputStream *st) const { 606 virtual void dump_spec(outputStream *st) const {
589 StoreNode::dump_spec(st); 607 StoreNode::dump_spec(st);
590 if (_require_atomic_access) st->print(" Atomic!"); 608 if (_require_atomic_access) st->print(" Atomic!");
603 }; 621 };
604 622
605 //------------------------------StoreDNode------------------------------------- 623 //------------------------------StoreDNode-------------------------------------
606 // Store double to memory 624 // Store double to memory
607 class StoreDNode : public StoreNode { 625 class StoreDNode : public StoreNode {
608 public: 626 virtual uint hash() const { return StoreNode::hash() + _require_atomic_access; }
609 StoreDNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) 627 virtual uint cmp( const Node &n ) const {
610 : StoreNode(c, mem, adr, at, val, mo) {} 628 return _require_atomic_access == ((StoreDNode&)n)._require_atomic_access
629 && StoreNode::cmp(n);
630 }
631 virtual uint size_of() const { return sizeof(*this); }
632 const bool _require_atomic_access; // is piecewise store forbidden?
633 public:
634 StoreDNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val,
635 MemOrd mo, bool require_atomic_access = false)
636 : StoreNode(c, mem, adr, at, val, mo), _require_atomic_access(require_atomic_access) {}
611 virtual int Opcode() const; 637 virtual int Opcode() const;
612 virtual BasicType memory_type() const { return T_DOUBLE; } 638 virtual BasicType memory_type() const { return T_DOUBLE; }
639 bool require_atomic_access() const { return _require_atomic_access; }
640 static StoreDNode* make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo);
641 #ifndef PRODUCT
642 virtual void dump_spec(outputStream *st) const {
643 StoreNode::dump_spec(st);
644 if (_require_atomic_access) st->print(" Atomic!");
645 }
646 #endif
647
613 }; 648 };
614 649
615 //------------------------------StorePNode------------------------------------- 650 //------------------------------StorePNode-------------------------------------
616 // Store pointer to memory 651 // Store pointer to memory
617 class StorePNode : public StoreNode { 652 class StorePNode : public StoreNode {