diff a/src/hotspot/share/gc/shenandoah/shenandoahGenerationalFullGC.hpp b/src/hotspot/share/gc/shenandoah/shenandoahGenerationalFullGC.hpp
--- /dev/null
+++ b/src/hotspot/share/gc/shenandoah/shenandoahGenerationalFullGC.hpp
@@ -0,0 +1,122 @@
+/*
+ * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_GC_SHENANDOAH_SHENANDOAHGENERATIONALFULLGC_HPP
+#define SHARE_GC_SHENANDOAH_SHENANDOAHGENERATIONALFULLGC_HPP
+
+#include "gc/shared/preservedMarks.hpp"
+#include "memory/iterator.hpp"
+#include "oops/oop.inline.hpp"
+#include "utilities/growableArray.hpp"
+
+class ShenandoahHeap;
+class ShenandoahHeapRegion;
+
+class ShenandoahGenerationalFullGC {
+public:
+  // Prepares the generational mode heap for a full collection.
+  static void prepare();
+
+  // Full GC may have compacted objects in the old generation, so we need to rebuild the card tables.
+  static void rebuild_remembered_set(ShenandoahHeap* heap);
+
+  // Records end of cycle for young and old and establishes size of live bytes in old
+  static void handle_completion(ShenandoahHeap* heap);
+
+  // Full GC may have promoted regions and may have temporarily violated constraints on the usage and
+  // capacity of the old generation. This method will balance the accounting of regions between the
+  // young and old generations. This is somewhat vestigial, but the outcome of this method is used
+  // when rebuilding the free sets.
+  static void balance_generations_after_gc(ShenandoahHeap* heap);
+
+  // This will compute the target size for the old generation. It will be expressed in terms of
+  // a region surplus and deficit, which will be redistributed accordingly after rebuilding the
+  // free set.
+  static void compute_balances();
+
+  // Rebuilding the free set may have resulted in regions being pulled in to the old generation
+  // evacuation reserve. For this reason, we must update the usage and capacity of the generations
+  // again. In the distant past, the free set did not know anything about generations, so we had
+  // a layer built above it to represent how much young/old memory was available. This layer is
+  // redundant and adds complexity. We would like to one day remove it. Until then, we must keep it
+  // synchronized with the free set's view of things.
+  static void balance_generations_after_rebuilding_free_set();
+
+  // Logs the number of live bytes marked in the old generation. This is _not_ the same
+  // value used as the baseline for the old generation _after_ the full gc is complete.
+  // The value reported in the logs does not include objects and regions that may be
+  // promoted during the full gc.
+  static void log_live_in_old(ShenandoahHeap* heap);
+
+  // This is used to tally the number, usage and space wasted by humongous objects for each generation.
+  static void account_for_region(ShenandoahHeapRegion* r, size_t &region_count, size_t &region_usage, size_t &humongous_waste);
+
+  // Regions which are scheduled for in-place promotion during evacuation temporarily
+  // have their top set to their end to prevent new objects from being allocated in them
+  // before they are promoted. If the full GC encounters such a region, it means the
+  // in-place promotion did not happen, and we must restore the original value of top.
+  static void restore_top_before_promote(ShenandoahHeap* heap);
+
+  // Pinned regions are not compacted, so they may still hold unmarked objects with
+  // references to reclaimed memory. Remembered set scanning will crash if it attempts
+  // to iterate the oops in these objects. This method fills in dead objects for pinned,
+  // old regions.
+  static void maybe_coalesce_and_fill_region(ShenandoahHeapRegion* r);
+};
+
+class ShenandoahPrepareForGenerationalCompactionObjectClosure : public ObjectClosure {
+private:
+  PreservedMarks*             const _preserved_marks;
+  ShenandoahGenerationalHeap* const _heap;
+  uint                              _tenuring_threshold;
+
+  // _empty_regions is a thread-local list of heap regions that have been completely emptied by this worker thread's
+  // compaction efforts.  The worker thread that drives these efforts adds compacted regions to this list if the
+  // region has not been compacted onto itself.
+  GrowableArray<ShenandoahHeapRegion*>& _empty_regions;
+  int _empty_regions_pos;
+  ShenandoahHeapRegion*          _old_to_region;
+  ShenandoahHeapRegion*          _young_to_region;
+  ShenandoahHeapRegion*          _from_region;
+  ShenandoahAffiliation          _from_affiliation;
+  HeapWord*                      _old_compact_point;
+  HeapWord*                      _young_compact_point;
+  uint                           _worker_id;
+
+public:
+  ShenandoahPrepareForGenerationalCompactionObjectClosure(PreservedMarks* preserved_marks,
+                                                          GrowableArray<ShenandoahHeapRegion*>& empty_regions,
+                                                          ShenandoahHeapRegion* from_region, uint worker_id);
+
+  void set_from_region(ShenandoahHeapRegion* from_region);
+  void finish();
+  void finish_old_region();
+  void finish_young_region();
+  bool is_compact_same_region();
+  int empty_regions_pos() const { return _empty_regions_pos; }
+
+  void do_object(oop p) override;
+};
+
+#endif //SHARE_GC_SHENANDOAH_SHENANDOAHGENERATIONALFULLGC_HPP
