< prev index next >

src/hotspot/share/opto/machnode.hpp

Print this page
@@ -50,10 +50,11 @@
  class MachProjNode;
  class MachPrologNode;
  class MachReturnNode;
  class MachSafePointNode;
  class MachSpillCopyNode;
+ class MachVEPNode;
  class Matcher;
  class PhaseRegAlloc;
  class RegMask;
  class RTMLockingCounters;
  class State;

@@ -488,17 +489,46 @@
    int  constant_offset() const { return ((MachConstantNode*) this)->constant_offset(); }
    // Unchecked version to avoid assertions in debug output.
    int  constant_offset_unchecked() const;
  };
  
+ //------------------------------MachVEPNode-----------------------------------
+ // Machine Inline Type Entry Point Node
+ class MachVEPNode : public MachIdealNode {
+ public:
+   Label* _verified_entry;
+ 
+   MachVEPNode(Label* verified_entry, bool verified, bool receiver_only) :
+     _verified_entry(verified_entry),
+     _verified(verified),
+     _receiver_only(receiver_only) {
+     init_class_id(Class_MachVEP);
+   }
+   virtual bool cmp(const Node &n) const {
+     return (_verified_entry == ((MachVEPNode&)n)._verified_entry) &&
+            (_verified == ((MachVEPNode&)n)._verified) &&
+            (_receiver_only == ((MachVEPNode&)n)._receiver_only) &&
+            MachIdealNode::cmp(n);
+   }
+   virtual uint size_of() const { return sizeof(*this); }
+   virtual void emit(CodeBuffer& cbuf, PhaseRegAlloc* ra_) const;
+ 
+ #ifndef PRODUCT
+   virtual const char* Name() const { return "InlineType Entry-Point"; }
+   virtual void format(PhaseRegAlloc*, outputStream* st) const;
+ #endif
+ private:
+   bool   _verified;
+   bool   _receiver_only;
+ };
+ 
  //------------------------------MachUEPNode-----------------------------------
  // Machine Unvalidated Entry Point Node
  class MachUEPNode : public MachIdealNode {
  public:
    MachUEPNode( ) {}
    virtual void emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const;
-   virtual uint size(PhaseRegAlloc *ra_) const;
  
  #ifndef PRODUCT
    virtual const char *Name() const { return "Unvalidated-Entry-Point"; }
    virtual void format( PhaseRegAlloc *, outputStream *st ) const;
  #endif

@@ -506,13 +536,20 @@
  
  //------------------------------MachPrologNode--------------------------------
  // Machine function Prolog Node
  class MachPrologNode : public MachIdealNode {
  public:
-   MachPrologNode( ) {}
+   Label* _verified_entry;
+ 
+   MachPrologNode(Label* verified_entry) : _verified_entry(verified_entry) {
+     init_class_id(Class_MachProlog);
+   }
+   virtual bool cmp(const Node &n) const {
+     return (_verified_entry == ((MachPrologNode&)n)._verified_entry) && MachIdealNode::cmp(n);
+   }
+   virtual uint size_of() const { return sizeof(*this); }
    virtual void emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const;
-   virtual uint size(PhaseRegAlloc *ra_) const;
    virtual int reloc() const;
  
  #ifndef PRODUCT
    virtual const char *Name() const { return "Prolog"; }
    virtual void format( PhaseRegAlloc *, outputStream *st ) const;

@@ -523,11 +560,10 @@
  // Machine function Epilog Node
  class MachEpilogNode : public MachIdealNode {
  public:
    MachEpilogNode(bool do_poll = false) : _do_polling(do_poll) {}
    virtual void emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const;
-   virtual uint size(PhaseRegAlloc *ra_) const;
    virtual int reloc() const;
    virtual const Pipeline *pipeline() const;
  
  private:
    bool _do_polling;

@@ -915,10 +951,11 @@
  
    NOT_LP64(bool return_value_is_used() const;)
  
    // Similar to cousin class CallNode::returns_pointer
    bool returns_pointer() const;
+   bool returns_scalarized() const;
  
    bool guaranteed_safepoint() const { return _guaranteed_safepoint; }
  
  #ifndef PRODUCT
    virtual void dump_spec(outputStream *st) const;
< prev index next >