[thirdparty/gcc.git] / gcc / ggc-tests.c

/* Unit tests for GCC's garbage collector (and gengtype etc).
   Copyright (C) 2015-2019 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC 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
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tree-core.h"
#include "tree.h"
#include "ggc-internal.h" /* (for ggc_force_collect).  */
#include "selftest.h"

#if CHECKING_P

/* A helper function for writing ggc tests.  */

void
selftest::forcibly_ggc_collect ()
{
  ggc_force_collect = true;
  ggc_collect ();
  ggc_force_collect = false;
}

/* The various GTY markers must be outside of a namespace to be seen by
   gengtype, so we don't put this file within the selftest namespace.  */

\f

/* Verify that a simple struct works, and that it can
   own references to non-roots, and have them be marked.  */

struct GTY(()) test_struct
{
  struct test_struct *other;
};

static GTY(()) test_struct *root_test_struct;

static void
test_basic_struct ()
{
  root_test_struct = ggc_cleared_alloc <test_struct> ();
  root_test_struct->other = ggc_cleared_alloc <test_struct> ();

  selftest::forcibly_ggc_collect ();

  ASSERT_TRUE (ggc_marked_p (root_test_struct));
  ASSERT_TRUE (ggc_marked_p (root_test_struct->other));
}

\f

/* Selftest for GTY((length)).  */

/* A test struct using GTY((length)).  */

struct GTY(()) test_of_length
{
  int num_elem;
  struct test_of_length * GTY ((length ("%h.num_elem"))) elem[1];
};

static GTY(()) test_of_length *root_test_of_length;

static void
test_length ()
{
  const int count = 5;
  size_t sz = sizeof (test_of_length) + (count- 1) * sizeof (test_of_length *);
  root_test_of_length = (test_of_length *)ggc_internal_cleared_alloc (sz);
  root_test_of_length->num_elem = count;
  for (int i = 0; i < count; i++)
    root_test_of_length->elem[i] = ggc_cleared_alloc <test_of_length> ();

  selftest::forcibly_ggc_collect ();

  ASSERT_TRUE (ggc_marked_p (root_test_of_length));
  for (int i = 0; i < count; i++)
    ASSERT_TRUE (ggc_marked_p (root_test_of_length->elem[i]));
}

\f

/* Selftest for unions, GTY((tag)), and GTY((desc)).  */

/* A struct with a reference that's an a different offset to test_struct,
   to ensure that we're using the correct types.  */

struct GTY(()) test_other
{
  char dummy[256];
  test_struct *m_ptr;
};

enum which_field
{
  WHICH_FIELD_USE_TEST_STRUCT,
  WHICH_FIELD_USE_TEST_OTHER
};

/* An example function for use by a GTY((desc)) marker.  */

static enum which_field
calc_desc (int kind)
{
  switch (kind)
    {
    case 0: return WHICH_FIELD_USE_TEST_STRUCT;
    case 1: return WHICH_FIELD_USE_TEST_OTHER;
    default:
      gcc_unreachable ();
    }
}

/* A struct containing an example of a union, showing the "tag" and
   "desc" markers.  */

struct GTY(()) test_of_union
{
  int m_kind;
  union u {
    test_struct * GTY ((tag ("WHICH_FIELD_USE_TEST_STRUCT") )) u_test_struct;
    test_other * GTY ((tag ("WHICH_FIELD_USE_TEST_OTHER") )) u_test_other;
  } GTY ((desc ("calc_desc (%0.m_kind)"))) m_u;
};

/* Example roots.  */

static GTY(()) test_of_union *root_test_of_union_1;
static GTY(()) test_of_union *root_test_of_union_2;

/* Verify that the above work correctly.  */

static void
test_union ()
{
  root_test_of_union_1 = ggc_cleared_alloc <test_of_union> ();
  root_test_of_union_1->m_kind = 0;
  test_struct *ts = ggc_cleared_alloc <test_struct> ();
  root_test_of_union_1->m_u.u_test_struct = ts;

  root_test_of_union_2 = ggc_cleared_alloc <test_of_union> ();
  root_test_of_union_2->m_kind = 1;
  test_other *other = ggc_cleared_alloc <test_other> ();
  root_test_of_union_2->m_u.u_test_other = other;
  test_struct *referenced_by_other = ggc_cleared_alloc <test_struct> ();
  other->m_ptr = referenced_by_other;

  selftest::forcibly_ggc_collect ();

  ASSERT_TRUE (ggc_marked_p (root_test_of_union_1));
  ASSERT_TRUE (ggc_marked_p (ts));

  ASSERT_TRUE (ggc_marked_p (root_test_of_union_2));
  ASSERT_TRUE (ggc_marked_p (other));
  ASSERT_TRUE (ggc_marked_p (referenced_by_other));
}

\f

/* Verify that destructors get run when instances are collected.  */

struct GTY(()) test_struct_with_dtor
{
  /* This struct has a destructor; it *ought* to be called
     by the ggc machinery when instances are collected.  */
  ~test_struct_with_dtor () { dtor_call_count++; }

  static int dtor_call_count;
};

int test_struct_with_dtor::dtor_call_count;

static void
test_finalization ()
{
#if GCC_VERSION >= 4003
  ASSERT_FALSE (need_finalization_p <test_struct> ());
  ASSERT_TRUE (need_finalization_p <test_struct_with_dtor> ());
#endif

  /* Create some garbage.  */
  const int count = 10;
  for (int i = 0; i < count; i++)
    ggc_cleared_alloc <test_struct_with_dtor> ();

  test_struct_with_dtor::dtor_call_count = 0;

  selftest::forcibly_ggc_collect ();

  /* Verify that the destructor was run for each instance.  */
  ASSERT_EQ (count, test_struct_with_dtor::dtor_call_count);
}

\f

/* Verify that a global can be marked as "deletable".  */

static GTY((deletable)) test_struct *test_of_deletable;

static void
test_deletable_global ()
{
  test_of_deletable = ggc_cleared_alloc <test_struct> ();
  ASSERT_TRUE (test_of_deletable != NULL);

  selftest::forcibly_ggc_collect ();

  ASSERT_EQ (NULL, test_of_deletable);
}

\f

/* Verify that gengtype etc can cope with inheritance.  */

class GTY((desc("%h.m_kind"), tag("0"))) example_base
{
 public:
  example_base ()
    : m_kind (0),
      m_a (ggc_cleared_alloc <test_struct> ())
  {}

  void *
  operator new (size_t sz)
  {
    return ggc_internal_cleared_alloc (sz);
  }

 protected:
  example_base (int kind)
    : m_kind (kind),
      m_a (ggc_cleared_alloc <test_struct> ())
  {}

 public:
  int m_kind;
  test_struct *m_a;
};

class GTY((tag("1"))) some_subclass : public example_base
{
 public:
  some_subclass ()
    : example_base (1),
      m_b (ggc_cleared_alloc <test_struct> ())
  {}

  test_struct *m_b;
};

class GTY((tag("2"))) some_other_subclass : public example_base
{
 public:
  some_other_subclass ()
    : example_base (2),
      m_c (ggc_cleared_alloc <test_struct> ())
  {}

  test_struct *m_c;
};

/* Various test roots, both expressed as a ptr to the actual class, and
   as a ptr to the base class.  */
static GTY(()) example_base *test_example_base;
static GTY(()) some_subclass *test_some_subclass;
static GTY(()) some_other_subclass *test_some_other_subclass;
static GTY(()) example_base *test_some_subclass_as_base_ptr;
static GTY(()) example_base *test_some_other_subclass_as_base_ptr;

static void
test_inheritance ()
{
  test_example_base = new example_base ();
  test_some_subclass = new some_subclass ();
  test_some_other_subclass = new some_other_subclass ();
  test_some_subclass_as_base_ptr = new some_subclass ();
  test_some_other_subclass_as_base_ptr = new some_other_subclass ();

  selftest::forcibly_ggc_collect ();

  /* Verify that the roots and everything referenced by them got marked
     (both for fields in the base class and those in subclasses).  */
  ASSERT_TRUE (ggc_marked_p (test_example_base));
  ASSERT_TRUE (ggc_marked_p (test_example_base->m_a));

  ASSERT_TRUE (ggc_marked_p (test_some_subclass));
  ASSERT_TRUE (ggc_marked_p (test_some_subclass->m_a));
  ASSERT_TRUE (ggc_marked_p (test_some_subclass->m_b));

  ASSERT_TRUE (ggc_marked_p (test_some_other_subclass));
  ASSERT_TRUE (ggc_marked_p (test_some_other_subclass->m_a));
  ASSERT_TRUE (ggc_marked_p (test_some_other_subclass->m_c));

  ASSERT_TRUE (ggc_marked_p (test_some_subclass_as_base_ptr));
  ASSERT_TRUE (ggc_marked_p (test_some_subclass_as_base_ptr->m_a));
  ASSERT_TRUE (ggc_marked_p (((some_subclass *)
			      test_some_subclass_as_base_ptr)->m_b));

  ASSERT_TRUE (ggc_marked_p (test_some_other_subclass_as_base_ptr));
  ASSERT_TRUE (ggc_marked_p (test_some_other_subclass_as_base_ptr->m_a));
  ASSERT_TRUE (ggc_marked_p (((some_other_subclass *)
			      test_some_other_subclass_as_base_ptr)->m_c));
}

\f

/* Test of chain_next/chain_prev

   Construct a very long linked list, so that without
   the chain_next/chain_prev optimization we'd have
   a stack overflow when gt_ggc_mx_test_node recurses.  */

struct GTY(( chain_next ("%h.m_next"),
	     chain_prev ("%h.m_prev") )) test_node
{
  test_node *m_prev;
  test_node *m_next;
  int m_idx;
};

static GTY(()) test_node *root_test_node;

static void
test_chain_next ()
{
  /* Ideally we would construct a long list so that the number of
     stack frames would be deep enough to crash if gengtype has created
     something that recurses.

     However, as the list is lengthened to increase the chance of
     overflowing the stack, the test will require more time and memory
     to run.  On a Fedora 20 x86_64 box with 128GB of RAM, count=2000000
     without the chain_next optimization reliably overflowed the stack,
     but the test took 0.5s to run.

     For now this test runs with a low value for "count", which defeats
     the main purpose of the test - though it at least gives us coverage
     for walking a GTY((chain_next)) list.

     We could potentially increase this value once we have a better sense
     of the time and space requirements of the test on different hosts,
     or perhaps find a way to reduce the stack size when running this
     testcase.  */
  const int count = 10;

  /* Build the linked list.  */
  root_test_node = ggc_cleared_alloc <test_node> ();
  test_node *tail_node = root_test_node;
  for (int i = 0; i < count; i++)
    {
      test_node *new_node = ggc_cleared_alloc <test_node> ();
      tail_node->m_next = new_node;
      new_node->m_prev = tail_node;
      new_node->m_idx = i;
      tail_node = new_node;
    }

  selftest::forcibly_ggc_collect ();

  /* If we got here, we survived.  */

  /* Verify that all nodes in the list were marked.  */
  ASSERT_TRUE (ggc_marked_p (root_test_node));
  test_node *iter_node = root_test_node->m_next;
  for (int i = 0; i < count; i++)
    {
      ASSERT_TRUE (ggc_marked_p (iter_node));
      ASSERT_EQ (i, iter_node->m_idx);
      iter_node = iter_node->m_next;
    }
}

\f

/* Test for GTY((user)).  */

struct GTY((user)) user_struct
{
  char dummy[16];
  test_struct *m_ptr;
};

static GTY(()) user_struct *root_user_struct_ptr;

/* A global for verifying that the user-provided gt_ggc_mx gets
   called.  */
static int num_calls_to_user_gt_ggc_mx;

/* User-provided implementation of gt_ggc_mx.  */

static void
gt_ggc_mx (user_struct *p)
{
  num_calls_to_user_gt_ggc_mx++;
  gt_ggc_mx_test_struct (p->m_ptr);
}

/* User-provided implementation of gt_pch_nx.  */

static void
gt_pch_nx (user_struct *p)
{
  gt_pch_nx_test_struct (p->m_ptr);
}

/* User-provided implementation of gt_pch_nx.  */

static void
gt_pch_nx (user_struct *p, gt_pointer_operator op, void *cookie)
{
  op (&(p->m_ptr), cookie);
}

/* Verify that GTY((user)) works.  */

static void
test_user_struct ()
{
  root_user_struct_ptr = ggc_cleared_alloc <user_struct> ();
  test_struct *referenced = ggc_cleared_alloc <test_struct> ();
  root_user_struct_ptr->m_ptr = referenced;

  num_calls_to_user_gt_ggc_mx = 0;

  selftest::forcibly_ggc_collect ();

  ASSERT_TRUE (ggc_marked_p (root_user_struct_ptr));
  ASSERT_TRUE (ggc_marked_p (referenced));
  ASSERT_TRUE (num_calls_to_user_gt_ggc_mx > 0);
}

\f

/* Smoketest to ensure that the tree type is marked.  */

static GTY(()) tree dummy_unittesting_tree;

static void
test_tree_marking ()
{
  dummy_unittesting_tree = build_int_cst (integer_type_node, 1066);

  selftest::forcibly_ggc_collect ();

  ASSERT_TRUE (ggc_marked_p (dummy_unittesting_tree));
}

\f

/* Ideas for other tests:
   - pch-handling  */

namespace selftest {

/* Run all of the selftests within this file.  */

void
ggc_tests_c_tests ()
{
  test_basic_struct ();
  test_length ();
  test_union ();
  test_finalization ();
  test_deletable_global ();
  test_inheritance ();
  test_chain_next ();
  test_user_struct ();
  test_tree_marking ();
}

} // namespace selftest

#include "gt-ggc-tests.h"

#else /* #if CHECKING_P */

/* The #if CHECKING_P code above has various GTY-marked roots.
   gengtype has no knowledge of the preprocessor, and so detects
   these roots and writes them out to gt-ggc-tests.h.
   In a !CHECKING_P build we can ignore gt-ggc-tests.h, but the
   root tables are referenced in the various generated gtype-*.c
   files like this:

      ...snip...
      extern const struct ggc_root_tab gt_ggc_r_gt_ggc_tests_h[];
      ...snip...

      EXPORTED_CONST struct ggc_root_tab * const gt_ggc_rtab[] = {
        ...snip...
        gt_ggc_r_gt_ggc_tests_h,
        ...snip...
      };

    Hence to avoid a link failure, we provide dummy implementations
    of these root tables in an unchecked build.

    Note that these conditional roots imply that PCH files are
    incompatible between checked and unchecked builds.  */

EXPORTED_CONST struct ggc_root_tab gt_ggc_r_gt_ggc_tests_h[] = {
  LAST_GGC_ROOT_TAB
};

EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_gt_ggc_tests_h[] = {
  LAST_GGC_ROOT_TAB
};

#endif /* #else clause of #if CHECKING_P */
Commit	Line	Data
f61d7248	1	/* Unit tests for GCC's garbage collector (and gengtype etc).
fbd26352	2	Copyright (C) 2015-2019 Free Software Foundation, Inc.
f61d7248	3
	4	This file is part of GCC.
	5
	6	GCC is free software; you can redistribute it and/or modify it under
	7	the terms of the GNU General Public License as published by the Free
	8	Software Foundation; either version 3, or (at your option) any later
	9	version.
	10
	11	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	12	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GCC; see the file COPYING3. If not see
	18	<http://www.gnu.org/licenses/>. */
	19
	20	#include "config.h"
	21	#include "system.h"
	22	#include "coretypes.h"
	23	#include "tree-core.h"
	24	#include "tree.h"
	25	#include "ggc-internal.h" /* (for ggc_force_collect). */
	26	#include "selftest.h"
	27
	28	#if CHECKING_P
	29
f61d7248	30	/* A helper function for writing ggc tests. */
f61d7248	31
09c2dc4c	32	void
09c2dc4c	33	selftest::forcibly_ggc_collect ()
f61d7248	34	{
	35	ggc_force_collect = true;
	36	ggc_collect ();
	37	ggc_force_collect = false;
	38	}
	39
09c2dc4c	40	/* The various GTY markers must be outside of a namespace to be seen by
	41	gengtype, so we don't put this file within the selftest namespace. */
	42
f61d7248	43	\f
	44
	45	/* Verify that a simple struct works, and that it can
	46	own references to non-roots, and have them be marked. */
	47
	48	struct GTY(()) test_struct
	49	{
	50	struct test_struct *other;
	51	};
	52
	53	static GTY(()) test_struct *root_test_struct;
	54
	55	static void
	56	test_basic_struct ()
	57	{
	58	root_test_struct = ggc_cleared_alloc <test_struct> ();
	59	root_test_struct->other = ggc_cleared_alloc <test_struct> ();
	60
09c2dc4c	61	selftest::forcibly_ggc_collect ();
f61d7248	62
	63	ASSERT_TRUE (ggc_marked_p (root_test_struct));
	64	ASSERT_TRUE (ggc_marked_p (root_test_struct->other));
	65	}
	66
	67	\f
	68
	69	/* Selftest for GTY((length)). */
	70
	71	/* A test struct using GTY((length)). */
	72
	73	struct GTY(()) test_of_length
	74	{
	75	int num_elem;
	76	struct test_of_length * GTY ((length ("%h.num_elem"))) elem[1];
	77	};
	78
	79	static GTY(()) test_of_length *root_test_of_length;
	80
	81	static void
	82	test_length ()
	83	{
	84	const int count = 5;
	85	size_t sz = sizeof (test_of_length) + (count- 1) * sizeof (test_of_length *);
	86	root_test_of_length = (test_of_length *)ggc_internal_cleared_alloc (sz);
	87	root_test_of_length->num_elem = count;
	88	for (int i = 0; i < count; i++)
	89	root_test_of_length->elem[i] = ggc_cleared_alloc <test_of_length> ();
	90
09c2dc4c	91	selftest::forcibly_ggc_collect ();
f61d7248	92
	93	ASSERT_TRUE (ggc_marked_p (root_test_of_length));
	94	for (int i = 0; i < count; i++)
	95	ASSERT_TRUE (ggc_marked_p (root_test_of_length->elem[i]));
	96	}
	97
	98	\f
	99
	100	/* Selftest for unions, GTY((tag)), and GTY((desc)). */
	101
	102	/* A struct with a reference that's an a different offset to test_struct,
	103	to ensure that we're using the correct types. */
	104
	105	struct GTY(()) test_other
	106	{
	107	char dummy[256];
	108	test_struct *m_ptr;
	109	};
	110
	111	enum which_field
	112	{
	113	WHICH_FIELD_USE_TEST_STRUCT,
	114	WHICH_FIELD_USE_TEST_OTHER
	115	};
	116
	117	/* An example function for use by a GTY((desc)) marker. */
	118
	119	static enum which_field
	120	calc_desc (int kind)
	121	{
	122	switch (kind)
	123	{
	124	case 0: return WHICH_FIELD_USE_TEST_STRUCT;
	125	case 1: return WHICH_FIELD_USE_TEST_OTHER;
	126	default:
	127	gcc_unreachable ();
	128	}
	129	}
	130
	131	/* A struct containing an example of a union, showing the "tag" and
	132	"desc" markers. */
	133
	134	struct GTY(()) test_of_union
	135	{
	136	int m_kind;
	137	union u {
	138	test_struct * GTY ((tag ("WHICH_FIELD_USE_TEST_STRUCT") )) u_test_struct;
	139	test_other * GTY ((tag ("WHICH_FIELD_USE_TEST_OTHER") )) u_test_other;
	140	} GTY ((desc ("calc_desc (%0.m_kind)"))) m_u;
	141	};
	142
	143	/* Example roots. */
	144
	145	static GTY(()) test_of_union *root_test_of_union_1;
	146	static GTY(()) test_of_union *root_test_of_union_2;
	147
	148	/* Verify that the above work correctly. */
	149
	150	static void
	151	test_union ()
	152	{
	153	root_test_of_union_1 = ggc_cleared_alloc <test_of_union> ();
	154	root_test_of_union_1->m_kind = 0;
	155	test_struct *ts = ggc_cleared_alloc <test_struct> ();
156	root_test_of_union_1->m_u.u_test_struct = ts;
157
158	root_test_of_union_2 = ggc_cleared_alloc <test_of_union> ();
159	root_test_of_union_2->m_kind = 1;
160	test_other *other = ggc_cleared_alloc <test_other> ();
161	root_test_of_union_2->m_u.u_test_other = other;
162	test_struct *referenced_by_other = ggc_cleared_alloc <test_struct> ();
163	other->m_ptr = referenced_by_other;
164
09c2dc4c	165	selftest::forcibly_ggc_collect ();
f61d7248	166
	167	ASSERT_TRUE (ggc_marked_p (root_test_of_union_1));
	168	ASSERT_TRUE (ggc_marked_p (ts));
	169
	170	ASSERT_TRUE (ggc_marked_p (root_test_of_union_2));
	171	ASSERT_TRUE (ggc_marked_p (other));
	172	ASSERT_TRUE (ggc_marked_p (referenced_by_other));
	173	}
	174
	175	\f
	176
	177	/* Verify that destructors get run when instances are collected. */
	178
	179	struct GTY(()) test_struct_with_dtor
	180	{
	181	/* This struct has a destructor; it ought to be called
	182	by the ggc machinery when instances are collected. */
	183	~test_struct_with_dtor () { dtor_call_count++; }
	184
	185	static int dtor_call_count;
	186	};
	187
	188	int test_struct_with_dtor::dtor_call_count;
	189
	190	static void
	191	test_finalization ()
	192	{
60c6a5a6	193	#if GCC_VERSION >= 4003
f61d7248	194	ASSERT_FALSE (need_finalization_p <test_struct> ());
f61d7248	195	ASSERT_TRUE (need_finalization_p <test_struct_with_dtor> ());
60c6a5a6	196	#endif
f61d7248	197
	198	/* Create some garbage. */
	199	const int count = 10;
	200	for (int i = 0; i < count; i++)
	201	ggc_cleared_alloc <test_struct_with_dtor> ();
	202
	203	test_struct_with_dtor::dtor_call_count = 0;
	204
09c2dc4c	205	selftest::forcibly_ggc_collect ();
f61d7248	206
	207	/* Verify that the destructor was run for each instance. */
	208	ASSERT_EQ (count, test_struct_with_dtor::dtor_call_count);
	209	}
	210
	211	\f
	212
	213	/* Verify that a global can be marked as "deletable". */
	214
	215	static GTY((deletable)) test_struct *test_of_deletable;
	216
	217	static void
	218	test_deletable_global ()
	219	{
	220	test_of_deletable = ggc_cleared_alloc <test_struct> ();
	221	ASSERT_TRUE (test_of_deletable != NULL);
	222
09c2dc4c	223	selftest::forcibly_ggc_collect ();
f61d7248	224
	225	ASSERT_EQ (NULL, test_of_deletable);
	226	}
	227
	228	\f
	229
	230	/* Verify that gengtype etc can cope with inheritance. */
	231
	232	class GTY((desc("%h.m_kind"), tag("0"))) example_base
	233	{
	234	public:
	235	example_base ()
	236	: m_kind (0),
	237	m_a (ggc_cleared_alloc <test_struct> ())
	238	{}
	239
	240	void *
	241	operator new (size_t sz)
	242	{
	243	return ggc_internal_cleared_alloc (sz);
	244	}
	245
	246	protected:
	247	example_base (int kind)
	248	: m_kind (kind),
	249	m_a (ggc_cleared_alloc <test_struct> ())
	250	{}
	251
	252	public:
	253	int m_kind;
	254	test_struct *m_a;
	255	};
	256
	257	class GTY((tag("1"))) some_subclass : public example_base
	258	{
	259	public:
	260	some_subclass ()
	261	: example_base (1),
	262	m_b (ggc_cleared_alloc <test_struct> ())
	263	{}
	264
	265	test_struct *m_b;
	266	};
	267
	268	class GTY((tag("2"))) some_other_subclass : public example_base
	269	{
	270	public:
	271	some_other_subclass ()
	272	: example_base (2),
	273	m_c (ggc_cleared_alloc <test_struct> ())
	274	{}
	275
	276	test_struct *m_c;
	277	};
	278
	279	/* Various test roots, both expressed as a ptr to the actual class, and
	280	as a ptr to the base class. */
	281	static GTY(()) example_base *test_example_base;
	282	static GTY(()) some_subclass *test_some_subclass;
	283	static GTY(()) some_other_subclass *test_some_other_subclass;
	284	static GTY(()) example_base *test_some_subclass_as_base_ptr;
	285	static GTY(()) example_base *test_some_other_subclass_as_base_ptr;
	286
	287	static void
288	test_inheritance ()
289	{
290	test_example_base = new example_base ();
291	test_some_subclass = new some_subclass ();
292	test_some_other_subclass = new some_other_subclass ();
293	test_some_subclass_as_base_ptr = new some_subclass ();
294	test_some_other_subclass_as_base_ptr = new some_other_subclass ();
295
09c2dc4c	296	selftest::forcibly_ggc_collect ();
f61d7248	297
	298	/* Verify that the roots and everything referenced by them got marked
	299	(both for fields in the base class and those in subclasses). */
	300	ASSERT_TRUE (ggc_marked_p (test_example_base));
	301	ASSERT_TRUE (ggc_marked_p (test_example_base->m_a));
	302
	303	ASSERT_TRUE (ggc_marked_p (test_some_subclass));
	304	ASSERT_TRUE (ggc_marked_p (test_some_subclass->m_a));
	305	ASSERT_TRUE (ggc_marked_p (test_some_subclass->m_b));
	306
	307	ASSERT_TRUE (ggc_marked_p (test_some_other_subclass));
	308	ASSERT_TRUE (ggc_marked_p (test_some_other_subclass->m_a));
	309	ASSERT_TRUE (ggc_marked_p (test_some_other_subclass->m_c));
	310
	311	ASSERT_TRUE (ggc_marked_p (test_some_subclass_as_base_ptr));
	312	ASSERT_TRUE (ggc_marked_p (test_some_subclass_as_base_ptr->m_a));
	313	ASSERT_TRUE (ggc_marked_p (((some_subclass *)
	314	test_some_subclass_as_base_ptr)->m_b));
	315
	316	ASSERT_TRUE (ggc_marked_p (test_some_other_subclass_as_base_ptr));
	317	ASSERT_TRUE (ggc_marked_p (test_some_other_subclass_as_base_ptr->m_a));
	318	ASSERT_TRUE (ggc_marked_p (((some_other_subclass *)
	319	test_some_other_subclass_as_base_ptr)->m_c));
	320	}
	321
	322	\f
	323
	324	/* Test of chain_next/chain_prev
	325
	326	Construct a very long linked list, so that without
	327	the chain_next/chain_prev optimization we'd have
	328	a stack overflow when gt_ggc_mx_test_node recurses. */
	329
	330	struct GTY(( chain_next ("%h.m_next"),
	331	chain_prev ("%h.m_prev") )) test_node
	332	{
	333	test_node *m_prev;
	334	test_node *m_next;
	335	int m_idx;
	336	};
	337
	338	static GTY(()) test_node *root_test_node;
	339
	340	static void
	341	test_chain_next ()
	342	{
	343	/* Ideally we would construct a long list so that the number of
	344	stack frames would be deep enough to crash if gengtype has created
	345	something that recurses.
	346
	347	However, as the list is lengthened to increase the chance of
	348	overflowing the stack, the test will require more time and memory
	349	to run. On a Fedora 20 x86_64 box with 128GB of RAM, count=2000000
	350	without the chain_next optimization reliably overflowed the stack,
	351	but the test took 0.5s to run.
	352
	353	For now this test runs with a low value for "count", which defeats
	354	the main purpose of the test - though it at least gives us coverage
	355	for walking a GTY((chain_next)) list.
	356
	357	We could potentially increase this value once we have a better sense
	358	of the time and space requirements of the test on different hosts,
	359	or perhaps find a way to reduce the stack size when running this
	360	testcase. */
361	const int count = 10;
362
363	/* Build the linked list. */
364	root_test_node = ggc_cleared_alloc <test_node> ();
365	test_node *tail_node = root_test_node;
366	for (int i = 0; i < count; i++)
367	{
368	test_node *new_node = ggc_cleared_alloc <test_node> ();
369	tail_node->m_next = new_node;
370	new_node->m_prev = tail_node;
371	new_node->m_idx = i;
372	tail_node = new_node;
373	}
374
09c2dc4c	375	selftest::forcibly_ggc_collect ();
f61d7248	376
	377	/* If we got here, we survived. */
	378
	379	/* Verify that all nodes in the list were marked. */
	380	ASSERT_TRUE (ggc_marked_p (root_test_node));
	381	test_node *iter_node = root_test_node->m_next;
	382	for (int i = 0; i < count; i++)
	383	{
	384	ASSERT_TRUE (ggc_marked_p (iter_node));
	385	ASSERT_EQ (i, iter_node->m_idx);
	386	iter_node = iter_node->m_next;
	387	}
	388	}
	389
	390	\f
	391
	392	/* Test for GTY((user)). */
	393
	394	struct GTY((user)) user_struct
	395	{
	396	char dummy[16];
	397	test_struct *m_ptr;
	398	};
	399
	400	static GTY(()) user_struct *root_user_struct_ptr;
	401
	402	/* A global for verifying that the user-provided gt_ggc_mx gets
	403	called. */
	404	static int num_calls_to_user_gt_ggc_mx;
	405
	406	/* User-provided implementation of gt_ggc_mx. */
	407
	408	static void
	409	gt_ggc_mx (user_struct *p)
	410	{
	411	num_calls_to_user_gt_ggc_mx++;
	412	gt_ggc_mx_test_struct (p->m_ptr);
	413	}
	414
	415	/* User-provided implementation of gt_pch_nx. */
	416
	417	static void
	418	gt_pch_nx (user_struct *p)
	419	{
	420	gt_pch_nx_test_struct (p->m_ptr);
	421	}
	422
	423	/* User-provided implementation of gt_pch_nx. */
	424
	425	static void
	426	gt_pch_nx (user_struct p, gt_pointer_operator op, void cookie)
	427	{
	428	op (&(p->m_ptr), cookie);
	429	}
	430
	431	/* Verify that GTY((user)) works. */
	432
	433	static void
	434	test_user_struct ()
	435	{
	436	root_user_struct_ptr = ggc_cleared_alloc <user_struct> ();
	437	test_struct *referenced = ggc_cleared_alloc <test_struct> ();
	438	root_user_struct_ptr->m_ptr = referenced;
	439
440	num_calls_to_user_gt_ggc_mx = 0;
441
09c2dc4c	442	selftest::forcibly_ggc_collect ();
f61d7248	443
	444	ASSERT_TRUE (ggc_marked_p (root_user_struct_ptr));
	445	ASSERT_TRUE (ggc_marked_p (referenced));
	446	ASSERT_TRUE (num_calls_to_user_gt_ggc_mx > 0);
	447	}
	448
	449	\f
	450
	451	/* Smoketest to ensure that the tree type is marked. */
	452
	453	static GTY(()) tree dummy_unittesting_tree;
	454
	455	static void
	456	test_tree_marking ()
	457	{
	458	dummy_unittesting_tree = build_int_cst (integer_type_node, 1066);
	459
09c2dc4c	460	selftest::forcibly_ggc_collect ();
f61d7248	461
	462	ASSERT_TRUE (ggc_marked_p (dummy_unittesting_tree));
	463	}
	464
	465	\f
	466
	467	/* Ideas for other tests:
	468	- pch-handling */
	469
	470	namespace selftest {
	471
	472	/* Run all of the selftests within this file. */
	473
	474	void
	475	ggc_tests_c_tests ()
	476	{
	477	test_basic_struct ();
	478	test_length ();
	479	test_union ();
	480	test_finalization ();
	481	test_deletable_global ();
	482	test_inheritance ();
	483	test_chain_next ();
	484	test_user_struct ();
	485	test_tree_marking ();
	486	}
	487
	488	} // namespace selftest
	489
	490	#include "gt-ggc-tests.h"
	491
	492	#else /* #if CHECKING_P */
	493
	494	/* The #if CHECKING_P code above has various GTY-marked roots.
	495	gengtype has no knowledge of the preprocessor, and so detects
	496	these roots and writes them out to gt-ggc-tests.h.
	497	In a !CHECKING_P build we can ignore gt-ggc-tests.h, but the
	498	root tables are referenced in the various generated gtype-*.c
	499	files like this:
	500
	501	...snip...
	502	extern const struct ggc_root_tab gt_ggc_r_gt_ggc_tests_h[];
	503	...snip...
	504
	505	EXPORTED_CONST struct ggc_root_tab * const gt_ggc_rtab[] = {
	506	...snip...
	507	gt_ggc_r_gt_ggc_tests_h,
	508	...snip...
	509	};
	510
	511	Hence to avoid a link failure, we provide dummy implementations
	512	of these root tables in an unchecked build.
	513
	514	Note that these conditional roots imply that PCH files are
	515	incompatible between checked and unchecked builds. */
	516
	517	EXPORTED_CONST struct ggc_root_tab gt_ggc_r_gt_ggc_tests_h[] = {
	518	LAST_GGC_ROOT_TAB
	519	};
	520
	521	EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_gt_ggc_tests_h[] = {
	522	LAST_GGC_ROOT_TAB
	523	};
	524
525	#endif /* #else clause of #if CHECKING_P */