--- old/src/share/vm/opto/machnode.hpp	2014-01-28 10:58:56.122406099 +0100
+++ new/src/share/vm/opto/machnode.hpp	2014-01-28 10:58:56.018406094 +0100
@@ -511,6 +511,126 @@
 #endif
 };
 
+// Inserted when coalescing of a two-address-instruction node and its input fails
+class TwoAddressSpillNode : public MachSpillCopyNode {
+public:
+  TwoAddressSpillNode(Node *n, const RegMask &in, const RegMask &out) : MachSpillCopyNode(n, in, out) {}
+#ifndef PRODUCT
+  virtual const char* Name() const { return "TwoAddressSpill"; }
+#endif
+};
+
+// Inserted when coalescing of a phi node and its input fails
+class PhiInputSpillNode : public MachSpillCopyNode {
+public:
+  PhiInputSpillNode(Node *n, const RegMask &in, const RegMask &out) : MachSpillCopyNode(n, in, out) {}
+#ifndef PRODUCT
+  virtual const char* Name() const { return "PhiInputSpill"; }
+#endif
+};
+
+// Inserted as debug info spills to safepoints in non-frequent blocks 
+class DebugUseSpillNode : public MachSpillCopyNode {
+public:
+  DebugUseSpillNode(Node *n, const RegMask &in, const RegMask &out) : MachSpillCopyNode(n, in, out) {}
+#ifndef PRODUCT
+  virtual const char* Name() const { return "DebugUseSpill"; }
+#endif
+};
+
+// Pre-split compares of loop-phis
+class LoopPhiInputSpillNode : public MachSpillCopyNode {
+public:
+  LoopPhiInputSpillNode(Node *n, const RegMask &in, const RegMask &out) : MachSpillCopyNode(n, in, out) {}
+#ifndef PRODUCT
+  virtual const char* Name() const { return "LoopPhiInputSpill"; }
+#endif
+};
+
+// An lrg marked as spilled will be spilled to memory right 
+// after its definition, if in high pressure region or the lrg is bound
+class DefinitionSpillNode : public MachSpillCopyNode {
+public:
+  DefinitionSpillNode(Node *n, const RegMask &in, const RegMask &out) : MachSpillCopyNode(n, in, out) {}
+#ifndef PRODUCT
+  virtual const char* Name() const { return "DefinitionSpill"; }
+#endif
+};
+
+// A register to register move
+class RegToRegSpillNode : public MachSpillCopyNode {
+public:
+  RegToRegSpillNode(Node *n, const RegMask &in, const RegMask &out) : MachSpillCopyNode(n, in, out) {}
+#ifndef PRODUCT
+  virtual const char* Name() const { return "RegToRegSpill"; }
+#endif
+};
+
+// A register to memory move
+class RegToMemSpillNode : public MachSpillCopyNode {
+public:
+  RegToMemSpillNode(Node *n, const RegMask &in, const RegMask &out) : MachSpillCopyNode(n, in, out) {}
+#ifndef PRODUCT
+  virtual const char* Name() const { return "RegToMemSpill"; }
+#endif
+};
+
+// A memory to register move
+class MemToRegSpillNode : public MachSpillCopyNode {
+public:
+  MemToRegSpillNode(Node *n, const RegMask &in, const RegMask &out) : MachSpillCopyNode(n, in, out) {}
+#ifndef PRODUCT
+  virtual const char* Name() const { return "MemToRegSpill"; }
+#endif
+};
+
+// When coalescing phi nodes in PhaseChaitin::Split(), a move spill is inserted if the phi and its input
+// resides at different locations (i.e. reg or mem) 
+class PhiLocationDifferToInputLocationSpillNode : public MachSpillCopyNode {
+public:
+  PhiLocationDifferToInputLocationSpillNode(Node *n, const RegMask &in, const RegMask &out) : MachSpillCopyNode(n, in, out) {}
+#ifndef PRODUCT
+  virtual const char* Name() const { return "PhiLocationDifferToInputLocationSpill"; }
+#endif
+};
+
+// Spill base pointer to memory at safepoint
+class BasePointerToMemSpillNode : public MachSpillCopyNode {
+public:
+  BasePointerToMemSpillNode(Node *n, const RegMask &in, const RegMask &out) : MachSpillCopyNode(n, in, out) {}
+#ifndef PRODUCT
+  virtual const char* Name() const { return "BasePointerToMemSpill"; }
+#endif
+};
+
+// When rematerializing a node we stretch the inputs liveranges, and they might be stretched beyond a new 
+// definition point, therefore we split out new copies instead
+class InputToRematerializationSpillNode : public MachSpillCopyNode {
+public:
+  InputToRematerializationSpillNode(Node *n, const RegMask &in, const RegMask &out) : MachSpillCopyNode(n, in, out) {}
+#ifndef PRODUCT
+  virtual const char* Name() const { return "InputToRematerializationSpill"; }
+#endif
+};
+
+// Spill use at a call
+class CallUseSpillNode : public MachSpillCopyNode {
+public:
+  CallUseSpillNode(Node *n, const RegMask &in, const RegMask &out) : MachSpillCopyNode(n, in, out) {}
+#ifndef PRODUCT
+  virtual const char* Name() const { return "CallUseSpill"; }
+#endif
+};
+
+// An lrg marked as spill that is bound and needs to be spilled at a use
+class BoundSpillNode : public MachSpillCopyNode {
+public:
+  BoundSpillNode(Node *n, const RegMask &in, const RegMask &out) : MachSpillCopyNode(n, in, out) {}
+#ifndef PRODUCT
+  virtual const char* Name() const { return "BoundSpill"; }
+#endif
+};
+
 //------------------------------MachBranchNode--------------------------------
 // Abstract machine branch Node
 class MachBranchNode : public MachIdealNode {