diff -r 14c6e2f23fa0 -r d606512952cc hotspot/src/share/vm/memory/tenuredGeneration.hpp
--- a/hotspot/src/share/vm/memory/tenuredGeneration.hpp	Tue Dec 02 09:51:16 2014 +0100
+++ b/hotspot/src/share/vm/memory/tenuredGeneration.hpp	Mon Dec 01 14:37:25 2014 +0100
@@ -31,17 +31,41 @@
 #include "memory/generation.hpp"
 #include "utilities/macros.hpp"
 
-// TenuredGeneration models the heap containing old (promoted/tenured) objects.
+// TenuredGeneration models the heap containing old (promoted/tenured) objects
+// contained in a single contiguous space.
+//
+// Garbage collection is performed using mark-compact.
 
-class TenuredGeneration: public OneContigSpaceCardGeneration {
+class TenuredGeneration: public CardGeneration {
   friend class VMStructs;
+  // Abstractly, this is a subtype that gets access to protected fields.
+  friend class VM_PopulateDumpSharedSpace;
+
  protected:
+  ContiguousSpace*  _the_space;       // actual space holding objects
+  WaterMark  _last_gc;                // watermark between objects allocated before
+                                      // and after last GC.
+
   GenerationCounters*   _gen_counters;
   CSpaceCounters*       _space_counters;
 
+  // Grow generation with specified size (returns false if unable to grow)
+  virtual bool grow_by(size_t bytes);
+  // Grow generation to reserved size.
+  virtual bool grow_to_reserved();
+  // Shrink generation with specified size (returns false if unable to shrink)
+  void shrink_by(size_t bytes);
+
+  // Allocation failure
+  virtual bool expand(size_t bytes, size_t expand_bytes);
+  void shrink(size_t bytes);
+
+  // Accessing spaces
+  ContiguousSpace* the_space() const { return _the_space; }
+
  public:
-  TenuredGeneration(ReservedSpace rs, size_t initial_byte_size, int level,
-                    GenRemSet* remset);
+  TenuredGeneration(ReservedSpace rs, size_t initial_byte_size,
+                               int level, GenRemSet* remset);
 
   Generation::Name kind() { return Generation::MarkSweepCompact; }
 
@@ -57,7 +81,59 @@
     return !ScavengeBeforeFullGC;
   }
 
+  inline bool is_in(const void* p) const;
+
+  // Space enquiries
+  size_t capacity() const;
+  size_t used() const;
+  size_t free() const;
+
+  MemRegion used_region() const;
+
+  size_t unsafe_max_alloc_nogc() const;
+  size_t contiguous_available() const;
+
+  // Iteration
+  void object_iterate(ObjectClosure* blk);
+  void space_iterate(SpaceClosure* blk, bool usedOnly = false);
+
+  void younger_refs_iterate(OopsInGenClosure* blk);
+
+  inline CompactibleSpace* first_compaction_space() const;
+
+  virtual inline HeapWord* allocate(size_t word_size, bool is_tlab);
+  virtual inline HeapWord* par_allocate(size_t word_size, bool is_tlab);
+
+  // Accessing marks
+  inline WaterMark top_mark();
+  inline WaterMark bottom_mark();
+
+#define TenuredGen_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix)     \
+  void oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl);
+  TenuredGen_SINCE_SAVE_MARKS_DECL(OopsInGenClosure,_v)
+  SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(TenuredGen_SINCE_SAVE_MARKS_DECL)
+
+  void save_marks();
+  void reset_saved_marks();
+  bool no_allocs_since_save_marks();
+
+  inline size_t block_size(const HeapWord* addr) const;
+
+  inline bool block_is_obj(const HeapWord* addr) const;
+
+  virtual void collect(bool full,
+                       bool clear_all_soft_refs,
+                       size_t size,
+                       bool is_tlab);
+  HeapWord* expand_and_allocate(size_t size,
+                                bool is_tlab,
+                                bool parallel = false);
+
+  virtual void prepare_for_verify();
+
+
   virtual void gc_prologue(bool full);
+  virtual void gc_epilogue(bool full);
   bool should_collect(bool   full,
                       size_t word_size,
                       bool   is_tlab);
@@ -67,11 +143,16 @@
   // Performance Counter support
   void update_counters();
 
+  virtual void record_spaces_top();
+
   // Statistics
 
   virtual void update_gc_stats(int level, bool full);
 
   virtual bool promotion_attempt_is_safe(size_t max_promoted_in_bytes) const;
+
+  virtual void verify();
+  virtual void print_on(outputStream* st) const;
 };
 
 #endif // SHARE_VM_MEMORY_TENUREDGENERATION_HPP