Mercurial > hg > graal-jvmci-8
comparison src/share/vm/opto/memnode.hpp @ 113:ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
Summary: Compressed oops in instances, arrays, and headers. Code contributors are coleenp, phh, never, swamyv
Reviewed-by: jmasa, kamg, acorn, tbell, kvn, rasbold
author | coleenp |
---|---|
date | Sun, 13 Apr 2008 17:43:42 -0400 |
parents | 2a9af0b9cb1c |
children | d1a5218d7eaf |
comparison
equal
deleted
inserted
replaced
110:a49a647afe9a | 113:ba764ed4b6f2 |
---|---|
135 : MemNode(c,mem,adr,at), _type(rt) { | 135 : MemNode(c,mem,adr,at), _type(rt) { |
136 init_class_id(Class_Load); | 136 init_class_id(Class_Load); |
137 } | 137 } |
138 | 138 |
139 // Polymorphic factory method: | 139 // Polymorphic factory method: |
140 static LoadNode* make( Compile *C, Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *rt, BasicType bt ); | 140 static Node* make( PhaseGVN& gvn, Node *c, Node *mem, Node *adr, |
141 const TypePtr* at, const Type *rt, BasicType bt ); | |
141 | 142 |
142 virtual uint hash() const; // Check the type | 143 virtual uint hash() const; // Check the type |
143 | 144 |
144 // Handle algebraic identities here. If we have an identity, return the Node | 145 // Handle algebraic identities here. If we have an identity, return the Node |
145 // we are equivalent to. We look for Load of a Store. | 146 // we are equivalent to. We look for Load of a Store. |
328 // other optimizations). Basically, it's ugly but so is the alternative. | 329 // other optimizations). Basically, it's ugly but so is the alternative. |
329 // See comment in macro.cpp, around line 125 expand_allocate_common(). | 330 // See comment in macro.cpp, around line 125 expand_allocate_common(). |
330 virtual bool depends_only_on_test() const { return adr_type() != TypeRawPtr::BOTTOM; } | 331 virtual bool depends_only_on_test() const { return adr_type() != TypeRawPtr::BOTTOM; } |
331 }; | 332 }; |
332 | 333 |
334 | |
335 //------------------------------LoadNNode-------------------------------------- | |
336 // Load a narrow oop from memory (either object or array) | |
337 class LoadNNode : public LoadNode { | |
338 public: | |
339 LoadNNode( Node *c, Node *mem, Node *adr, const TypePtr *at, const Type* t ) | |
340 : LoadNode(c,mem,adr,at,t) {} | |
341 virtual int Opcode() const; | |
342 virtual uint ideal_reg() const { return Op_RegN; } | |
343 virtual int store_Opcode() const { return Op_StoreN; } | |
344 virtual BasicType memory_type() const { return T_NARROWOOP; } | |
345 // depends_only_on_test is almost always true, and needs to be almost always | |
346 // true to enable key hoisting & commoning optimizations. However, for the | |
347 // special case of RawPtr loads from TLS top & end, the control edge carries | |
348 // the dependence preventing hoisting past a Safepoint instead of the memory | |
349 // edge. (An unfortunate consequence of having Safepoints not set Raw | |
350 // Memory; itself an unfortunate consequence of having Nodes which produce | |
351 // results (new raw memory state) inside of loops preventing all manner of | |
352 // other optimizations). Basically, it's ugly but so is the alternative. | |
353 // See comment in macro.cpp, around line 125 expand_allocate_common(). | |
354 virtual bool depends_only_on_test() const { return adr_type() != TypeRawPtr::BOTTOM; } | |
355 }; | |
356 | |
333 //------------------------------LoadKlassNode---------------------------------- | 357 //------------------------------LoadKlassNode---------------------------------- |
334 // Load a Klass from an object | 358 // Load a Klass from an object |
335 class LoadKlassNode : public LoadPNode { | 359 class LoadKlassNode : public LoadPNode { |
336 public: | 360 public: |
337 LoadKlassNode( Node *c, Node *mem, Node *adr, const TypePtr *at, const TypeKlassPtr *tk = TypeKlassPtr::OBJECT ) | 361 LoadKlassNode( Node *c, Node *mem, Node *adr, const TypePtr *at, const TypeKlassPtr *tk = TypeKlassPtr::OBJECT ) |
374 : MemNode(c,mem,adr,at,val,oop_store) { | 398 : MemNode(c,mem,adr,at,val,oop_store) { |
375 init_class_id(Class_Store); | 399 init_class_id(Class_Store); |
376 } | 400 } |
377 | 401 |
378 // Polymorphic factory method: | 402 // Polymorphic factory method: |
379 static StoreNode* make( Compile *C, Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, BasicType bt ); | 403 static StoreNode* make( PhaseGVN& gvn, Node *c, Node *mem, Node *adr, |
404 const TypePtr* at, Node *val, BasicType bt ); | |
380 | 405 |
381 virtual uint hash() const; // Check the type | 406 virtual uint hash() const; // Check the type |
382 | 407 |
383 // If the store is to Field memory and the pointer is non-null, we can | 408 // If the store is to Field memory and the pointer is non-null, we can |
384 // zero out the control input. | 409 // zero out the control input. |
484 class StorePNode : public StoreNode { | 509 class StorePNode : public StoreNode { |
485 public: | 510 public: |
486 StorePNode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val ) : StoreNode(c,mem,adr,at,val) {} | 511 StorePNode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val ) : StoreNode(c,mem,adr,at,val) {} |
487 virtual int Opcode() const; | 512 virtual int Opcode() const; |
488 virtual BasicType memory_type() const { return T_ADDRESS; } | 513 virtual BasicType memory_type() const { return T_ADDRESS; } |
514 }; | |
515 | |
516 //------------------------------StoreNNode------------------------------------- | |
517 // Store narrow oop to memory | |
518 class StoreNNode : public StoreNode { | |
519 public: | |
520 StoreNNode( Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val ) : StoreNode(c,mem,adr,at,val) {} | |
521 virtual int Opcode() const; | |
522 virtual BasicType memory_type() const { return T_NARROWOOP; } | |
489 }; | 523 }; |
490 | 524 |
491 //------------------------------StoreCMNode----------------------------------- | 525 //------------------------------StoreCMNode----------------------------------- |
492 // Store card-mark byte to memory for CM | 526 // Store card-mark byte to memory for CM |
493 // The last StoreCM before a SafePoint must be preserved and occur after its "oop" store | 527 // The last StoreCM before a SafePoint must be preserved and occur after its "oop" store |
595 | 629 |
596 //------------------------------CompareAndSwapPNode--------------------------- | 630 //------------------------------CompareAndSwapPNode--------------------------- |
597 class CompareAndSwapPNode : public LoadStoreNode { | 631 class CompareAndSwapPNode : public LoadStoreNode { |
598 public: | 632 public: |
599 CompareAndSwapPNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreNode(c, mem, adr, val, ex) { } | 633 CompareAndSwapPNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreNode(c, mem, adr, val, ex) { } |
634 virtual int Opcode() const; | |
635 }; | |
636 | |
637 //------------------------------CompareAndSwapNNode--------------------------- | |
638 class CompareAndSwapNNode : public LoadStoreNode { | |
639 public: | |
640 CompareAndSwapNNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex) : LoadStoreNode(c, mem, adr, val, ex) { } | |
600 virtual int Opcode() const; | 641 virtual int Opcode() const; |
601 }; | 642 }; |
602 | 643 |
603 //------------------------------ClearArray------------------------------------- | 644 //------------------------------ClearArray------------------------------------- |
604 class ClearArrayNode: public Node { | 645 class ClearArrayNode: public Node { |