[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.  */

class GTY(()) test_struct_with_dtor
{
public:
  /* 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
251317e4	179	class GTY(()) test_struct_with_dtor
f61d7248	180	{
251317e4	181	public:
f61d7248	182	/* This struct has a destructor; it ought to be called
	183	by the ggc machinery when instances are collected. */
	184	~test_struct_with_dtor () { dtor_call_count++; }
	185
	186	static int dtor_call_count;
	187	};
	188
	189	int test_struct_with_dtor::dtor_call_count;
	190
	191	static void
	192	test_finalization ()
	193	{
60c6a5a6	194	#if GCC_VERSION >= 4003
f61d7248	195	ASSERT_FALSE (need_finalization_p <test_struct> ());
f61d7248	196	ASSERT_TRUE (need_finalization_p <test_struct_with_dtor> ());
60c6a5a6	197	#endif
f61d7248	198
	199	/* Create some garbage. */
	200	const int count = 10;
	201	for (int i = 0; i < count; i++)
	202	ggc_cleared_alloc <test_struct_with_dtor> ();
	203
	204	test_struct_with_dtor::dtor_call_count = 0;
	205
09c2dc4c	206	selftest::forcibly_ggc_collect ();
f61d7248	207
	208	/* Verify that the destructor was run for each instance. */
	209	ASSERT_EQ (count, test_struct_with_dtor::dtor_call_count);
	210	}
	211
	212	\f
	213
	214	/* Verify that a global can be marked as "deletable". */
	215
	216	static GTY((deletable)) test_struct *test_of_deletable;
	217
	218	static void
	219	test_deletable_global ()
	220	{
	221	test_of_deletable = ggc_cleared_alloc <test_struct> ();
	222	ASSERT_TRUE (test_of_deletable != NULL);
	223
09c2dc4c	224	selftest::forcibly_ggc_collect ();
f61d7248	225
	226	ASSERT_EQ (NULL, test_of_deletable);
	227	}
	228
	229	\f
	230
	231	/* Verify that gengtype etc can cope with inheritance. */
	232
	233	class GTY((desc("%h.m_kind"), tag("0"))) example_base
	234	{
	235	public:
	236	example_base ()
	237	: m_kind (0),
	238	m_a (ggc_cleared_alloc <test_struct> ())
	239	{}
	240
	241	void *
	242	operator new (size_t sz)
	243	{
	244	return ggc_internal_cleared_alloc (sz);
	245	}
	246
	247	protected:
	248	example_base (int kind)
	249	: m_kind (kind),
	250	m_a (ggc_cleared_alloc <test_struct> ())
	251	{}
	252
	253	public:
	254	int m_kind;
	255	test_struct *m_a;
	256	};
	257
	258	class GTY((tag("1"))) some_subclass : public example_base
	259	{
	260	public:
	261	some_subclass ()
	262	: example_base (1),
	263	m_b (ggc_cleared_alloc <test_struct> ())
	264	{}
	265
	266	test_struct *m_b;
	267	};
	268
	269	class GTY((tag("2"))) some_other_subclass : public example_base
	270	{
	271	public:
	272	some_other_subclass ()
	273	: example_base (2),
	274	m_c (ggc_cleared_alloc <test_struct> ())
	275	{}
	276
	277	test_struct *m_c;
	278	};
	279
	280	/* Various test roots, both expressed as a ptr to the actual class, and
	281	as a ptr to the base class. */
	282	static GTY(()) example_base *test_example_base;
	283	static GTY(()) some_subclass *test_some_subclass;
	284	static GTY(()) some_other_subclass *test_some_other_subclass;
	285	static GTY(()) example_base *test_some_subclass_as_base_ptr;
	286	static GTY(()) example_base *test_some_other_subclass_as_base_ptr;
	287
	288	static void
289	test_inheritance ()
290	{
291	test_example_base = new example_base ();
292	test_some_subclass = new some_subclass ();
293	test_some_other_subclass = new some_other_subclass ();
294	test_some_subclass_as_base_ptr = new some_subclass ();
295	test_some_other_subclass_as_base_ptr = new some_other_subclass ();
296
09c2dc4c	297	selftest::forcibly_ggc_collect ();
f61d7248	298
	299	/* Verify that the roots and everything referenced by them got marked
	300	(both for fields in the base class and those in subclasses). */
	301	ASSERT_TRUE (ggc_marked_p (test_example_base));
	302	ASSERT_TRUE (ggc_marked_p (test_example_base->m_a));
	303
	304	ASSERT_TRUE (ggc_marked_p (test_some_subclass));
	305	ASSERT_TRUE (ggc_marked_p (test_some_subclass->m_a));
	306	ASSERT_TRUE (ggc_marked_p (test_some_subclass->m_b));
	307
	308	ASSERT_TRUE (ggc_marked_p (test_some_other_subclass));
	309	ASSERT_TRUE (ggc_marked_p (test_some_other_subclass->m_a));
	310	ASSERT_TRUE (ggc_marked_p (test_some_other_subclass->m_c));
	311
	312	ASSERT_TRUE (ggc_marked_p (test_some_subclass_as_base_ptr));
	313	ASSERT_TRUE (ggc_marked_p (test_some_subclass_as_base_ptr->m_a));
	314	ASSERT_TRUE (ggc_marked_p (((some_subclass *)
	315	test_some_subclass_as_base_ptr)->m_b));
	316
	317	ASSERT_TRUE (ggc_marked_p (test_some_other_subclass_as_base_ptr));
	318	ASSERT_TRUE (ggc_marked_p (test_some_other_subclass_as_base_ptr->m_a));
	319	ASSERT_TRUE (ggc_marked_p (((some_other_subclass *)
	320	test_some_other_subclass_as_base_ptr)->m_c));
	321	}
	322
	323	\f
	324
	325	/* Test of chain_next/chain_prev
	326
	327	Construct a very long linked list, so that without
	328	the chain_next/chain_prev optimization we'd have
	329	a stack overflow when gt_ggc_mx_test_node recurses. */
	330
	331	struct GTY(( chain_next ("%h.m_next"),
	332	chain_prev ("%h.m_prev") )) test_node
	333	{
	334	test_node *m_prev;
	335	test_node *m_next;
	336	int m_idx;
	337	};
	338
	339	static GTY(()) test_node *root_test_node;
	340
	341	static void
	342	test_chain_next ()
	343	{
	344	/* Ideally we would construct a long list so that the number of
	345	stack frames would be deep enough to crash if gengtype has created
	346	something that recurses.
	347
	348	However, as the list is lengthened to increase the chance of
	349	overflowing the stack, the test will require more time and memory
	350	to run. On a Fedora 20 x86_64 box with 128GB of RAM, count=2000000
	351	without the chain_next optimization reliably overflowed the stack,
	352	but the test took 0.5s to run.
	353
	354	For now this test runs with a low value for "count", which defeats
	355	the main purpose of the test - though it at least gives us coverage
	356	for walking a GTY((chain_next)) list.
	357
	358	We could potentially increase this value once we have a better sense
	359	of the time and space requirements of the test on different hosts,
	360	or perhaps find a way to reduce the stack size when running this
	361	testcase. */
362	const int count = 10;
363
364	/* Build the linked list. */
365	root_test_node = ggc_cleared_alloc <test_node> ();
366	test_node *tail_node = root_test_node;
367	for (int i = 0; i < count; i++)
368	{
369	test_node *new_node = ggc_cleared_alloc <test_node> ();
370	tail_node->m_next = new_node;
371	new_node->m_prev = tail_node;
372	new_node->m_idx = i;
373	tail_node = new_node;
374	}
375
09c2dc4c	376	selftest::forcibly_ggc_collect ();
f61d7248	377
	378	/* If we got here, we survived. */
	379
	380	/* Verify that all nodes in the list were marked. */
	381	ASSERT_TRUE (ggc_marked_p (root_test_node));
	382	test_node *iter_node = root_test_node->m_next;
	383	for (int i = 0; i < count; i++)
	384	{
	385	ASSERT_TRUE (ggc_marked_p (iter_node));
	386	ASSERT_EQ (i, iter_node->m_idx);
	387	iter_node = iter_node->m_next;
	388	}
	389	}
	390
	391	\f
	392
	393	/* Test for GTY((user)). */
	394
	395	struct GTY((user)) user_struct
	396	{
	397	char dummy[16];
	398	test_struct *m_ptr;
	399	};
	400
	401	static GTY(()) user_struct *root_user_struct_ptr;
	402
	403	/* A global for verifying that the user-provided gt_ggc_mx gets
	404	called. */
	405	static int num_calls_to_user_gt_ggc_mx;
	406
	407	/* User-provided implementation of gt_ggc_mx. */
	408
	409	static void
	410	gt_ggc_mx (user_struct *p)
	411	{
	412	num_calls_to_user_gt_ggc_mx++;
	413	gt_ggc_mx_test_struct (p->m_ptr);
	414	}
	415
	416	/* User-provided implementation of gt_pch_nx. */
	417
	418	static void
	419	gt_pch_nx (user_struct *p)
	420	{
	421	gt_pch_nx_test_struct (p->m_ptr);
	422	}
	423
	424	/* User-provided implementation of gt_pch_nx. */
	425
	426	static void
	427	gt_pch_nx (user_struct p, gt_pointer_operator op, void cookie)
	428	{
	429	op (&(p->m_ptr), cookie);
	430	}
	431
	432	/* Verify that GTY((user)) works. */
	433
	434	static void
	435	test_user_struct ()
	436	{
	437	root_user_struct_ptr = ggc_cleared_alloc <user_struct> ();
	438	test_struct *referenced = ggc_cleared_alloc <test_struct> ();
	439	root_user_struct_ptr->m_ptr = referenced;
	440
441	num_calls_to_user_gt_ggc_mx = 0;
442
09c2dc4c	443	selftest::forcibly_ggc_collect ();
f61d7248	444
	445	ASSERT_TRUE (ggc_marked_p (root_user_struct_ptr));
	446	ASSERT_TRUE (ggc_marked_p (referenced));
	447	ASSERT_TRUE (num_calls_to_user_gt_ggc_mx > 0);
	448	}
	449
	450	\f
	451
	452	/* Smoketest to ensure that the tree type is marked. */
	453
	454	static GTY(()) tree dummy_unittesting_tree;
	455
	456	static void
	457	test_tree_marking ()
	458	{
	459	dummy_unittesting_tree = build_int_cst (integer_type_node, 1066);
	460
09c2dc4c	461	selftest::forcibly_ggc_collect ();
f61d7248	462
	463	ASSERT_TRUE (ggc_marked_p (dummy_unittesting_tree));
	464	}
	465
	466	\f
	467
	468	/* Ideas for other tests:
	469	- pch-handling */
	470
	471	namespace selftest {
	472
	473	/* Run all of the selftests within this file. */
	474
	475	void
	476	ggc_tests_c_tests ()
	477	{
	478	test_basic_struct ();
	479	test_length ();
	480	test_union ();
	481	test_finalization ();
	482	test_deletable_global ();
	483	test_inheritance ();
	484	test_chain_next ();
	485	test_user_struct ();
	486	test_tree_marking ();
	487	}
	488
	489	} // namespace selftest
	490
	491	#include "gt-ggc-tests.h"
	492
	493	#else /* #if CHECKING_P */
	494
	495	/* The #if CHECKING_P code above has various GTY-marked roots.
	496	gengtype has no knowledge of the preprocessor, and so detects
	497	these roots and writes them out to gt-ggc-tests.h.
	498	In a !CHECKING_P build we can ignore gt-ggc-tests.h, but the
	499	root tables are referenced in the various generated gtype-*.c
	500	files like this:
	501
	502	...snip...
	503	extern const struct ggc_root_tab gt_ggc_r_gt_ggc_tests_h[];
	504	...snip...
	505
	506	EXPORTED_CONST struct ggc_root_tab * const gt_ggc_rtab[] = {
	507	...snip...
	508	gt_ggc_r_gt_ggc_tests_h,
	509	...snip...
	510	};
	511
	512	Hence to avoid a link failure, we provide dummy implementations
	513	of these root tables in an unchecked build.
	514
	515	Note that these conditional roots imply that PCH files are
	516	incompatible between checked and unchecked builds. */
	517
	518	EXPORTED_CONST struct ggc_root_tab gt_ggc_r_gt_ggc_tests_h[] = {
	519	LAST_GGC_ROOT_TAB
	520	};
	521
	522	EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_gt_ggc_tests_h[] = {
	523	LAST_GGC_ROOT_TAB
	524	};
	525
526	#endif /* #else clause of #if CHECKING_P */