--- a/src/hotspot/share/gc/z/zList.hpp	Mon Oct 21 09:57:26 2019 +0200
+++ b/src/hotspot/share/gc/z/zList.hpp	Mon Oct 21 09:58:07 2019 +0200
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2019, Oracle and/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
@@ -25,7 +25,6 @@
 #define SHARE_GC_Z_ZLIST_HPP
 
 #include "memory/allocation.hpp"
-#include "utilities/debug.hpp"
 
 template <typename T> class ZList;
 
@@ -38,27 +37,15 @@
   ZListNode* _next;
   ZListNode* _prev;
 
-  ZListNode(ZListNode* next, ZListNode* prev) :
-      _next(next),
-      _prev(prev) {}
+  ZListNode(ZListNode* next, ZListNode* prev);
 
-  void set_unused() {
-    _next = NULL;
-    _prev = NULL;
-  }
+  void set_unused();
 
 public:
-  ZListNode() {
-    set_unused();
-  }
+  ZListNode();
+  ~ZListNode();
 
-  ~ZListNode() {
-    set_unused();
-  }
-
-  bool is_unused() const {
-    return _next == NULL && _prev == NULL;
-  }
+  bool is_unused() const;
 };
 
 // Doubly linked list
@@ -72,139 +59,34 @@
   ZList(const ZList<T>& list);
   ZList<T>& operator=(const ZList<T>& list);
 
-  void verify() const {
-    assert(_head._next->_prev == &_head, "List corrupt");
-    assert(_head._prev->_next == &_head, "List corrupt");
-  }
-
-  void insert(ZListNode<T>* before, ZListNode<T>* node) {
-    verify();
+  void verify() const;
 
-    assert(node->is_unused(), "Already in a list");
-    node->_prev = before;
-    node->_next = before->_next;
-    before->_next = node;
-    node->_next->_prev = node;
+  void insert(ZListNode<T>* before, ZListNode<T>* node);
 
-    _size++;
-  }
-
-  ZListNode<T>* cast_to_inner(T* elem) const {
-    return &elem->_node;
-  }
-
-  T* cast_to_outer(ZListNode<T>* node) const {
-    return (T*)((uintptr_t)node - offset_of(T, _node));
-  }
+  ZListNode<T>* cast_to_inner(T* elem) const;
+  T* cast_to_outer(ZListNode<T>* node) const;
 
 public:
-  ZList() :
-      _head(&_head, &_head),
-      _size(0) {
-    verify();
-  }
-
-  size_t size() const {
-    verify();
-    return _size;
-  }
+  ZList();
 
-  bool is_empty() const {
-    return _size == 0;
-  }
-
-  T* first() const {
-    return is_empty() ? NULL : cast_to_outer(_head._next);
-  }
-
-  T* last() const {
-    return is_empty() ? NULL : cast_to_outer(_head._prev);
-  }
+  size_t size() const;
+  bool is_empty() const;
 
-  T* next(T* elem) const {
-    verify();
-    ZListNode<T>* next = cast_to_inner(elem)->_next;
-    return (next == &_head) ? NULL : cast_to_outer(next);
-  }
-
-  T* prev(T* elem) const {
-    verify();
-    ZListNode<T>* prev = cast_to_inner(elem)->_prev;
-    return (prev == &_head) ? NULL : cast_to_outer(prev);
-  }
-
-  void insert_first(T* elem) {
-    insert(&_head, cast_to_inner(elem));
-  }
-
-  void insert_last(T* elem) {
-    insert(_head._prev, cast_to_inner(elem));
-  }
-
-  void insert_before(T* before, T* elem) {
-    insert(cast_to_inner(before)->_prev, cast_to_inner(elem));
-  }
-
-  void insert_after(T* after, T* elem) {
-    insert(cast_to_inner(after), cast_to_inner(elem));
-  }
-
-  void remove(T* elem) {
-    verify();
+  T* first() const;
+  T* last() const;
+  T* next(T* elem) const;
+  T* prev(T* elem) const;
 
-    ZListNode<T>* const node = cast_to_inner(elem);
-    assert(!node->is_unused(), "Not in a list");
-
-    ZListNode<T>* const next = node->_next;
-    ZListNode<T>* const prev = node->_prev;
-    assert(next->_prev == node, "List corrupt");
-    assert(prev->_next == node, "List corrupt");
-
-    prev->_next = next;
-    next->_prev = prev;
-    node->set_unused();
-
-    _size--;
-  }
-
-  T* remove_first() {
-    T* elem = first();
-    if (elem != NULL) {
-      remove(elem);
-    }
-
-    return elem;
-  }
+  void insert_first(T* elem);
+  void insert_last(T* elem);
+  void insert_before(T* before, T* elem);
+  void insert_after(T* after, T* elem);
 
-  T* remove_last() {
-    T* elem = last();
-    if (elem != NULL) {
-      remove(elem);
-    }
-
-    return elem;
-  }
-
-  void transfer(ZList<T>* list) {
-    verify();
+  void remove(T* elem);
+  T* remove_first();
+  T* remove_last();
 
-    if (!list->is_empty()) {
-      list->_head._next->_prev = _head._prev;
-      list->_head._prev->_next = _head._prev->_next;
-
-      _head._prev->_next = list->_head._next;
-      _head._prev = list->_head._prev;
-
-      list->_head._next = &list->_head;
-      list->_head._prev = &list->_head;
-
-      _size += list->_size;
-      list->_size = 0;
-
-      list->verify();
-      verify();
-    }
-  }
+  void transfer(ZList<T>* list);
 };
 
 template <typename T, bool forward>
@@ -226,15 +108,13 @@
 template <typename T>
 class ZListIterator : public ZListIteratorImpl<T, ZLIST_FORWARD> {
 public:
-  ZListIterator(const ZList<T>* list) :
-      ZListIteratorImpl<T, ZLIST_FORWARD>(list) {}
+  ZListIterator(const ZList<T>* list);
 };
 
 template <typename T>
 class ZListReverseIterator : public ZListIteratorImpl<T, ZLIST_REVERSE> {
 public:
-  ZListReverseIterator(const ZList<T>* list) :
-      ZListIteratorImpl<T, ZLIST_REVERSE>(list) {}
+  ZListReverseIterator(const ZList<T>* list);
 };
 
 #endif // SHARE_GC_Z_ZLIST_HPP