[thirdparty/binutils-gdb.git] / gdb / testsuite / gdb.mi / mi-var-rtti.cc

/* Copyright 2012-2024 Free Software Foundation, Inc.

   This program 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 of the License, or
   (at your option) any later version.

   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.  */

struct Base {
    Base() : A(1) {}
    virtual ~Base() {}  // Enforce type to have vtable
    int A;
};

struct Derived : public Base {
    Derived() : B(2), C(3) {}
    int B;
    int C;
};


void use_rtti_for_ptr_test ()
{
  /*: BEGIN: use_rtti_for_ptr :*/
	Derived d;
	Base* ptr = &d;
	const Base* constPtr = &d;
	Base* const ptrConst = &d;
	Base const* const constPtrConst = &d;
  /*:
	set testname use_rtti_for_ptr
	set_print_object off $testname
	check_new_derived_without_rtti ptr {Base \*} $testname
	check_new_derived_without_rtti constPtr {const Base \*} $testname
	check_new_derived_without_rtti ptrConst {Base \* const} $testname
	check_new_derived_without_rtti constPtrConst {const Base \* const} \
		$testname

	set_print_object on $testname
	check_new_derived_with_rtti ptr {Derived \*} $testname
	check_new_derived_with_rtti constPtr {const Derived \*} $testname
	check_new_derived_with_rtti ptrConst {Derived \* const} $testname
	check_new_derived_with_rtti constPtrConst {const Derived \* const} \
		$testname
  :*/
	return;
  /*: END: use_rtti_for_ptr :*/
}


void use_rtti_for_ref_test ()
{
  /*: BEGIN: use_rtti_for_ref :*/
	Derived d;
	Base& ref = d;
	const Base& constRef = d;
  /*: 
	set testname use_rtti_for_ref
	set_print_object off $testname
	check_new_derived_without_rtti ref {Base \&} $testname
	check_new_derived_without_rtti constRef {const Base \&} $testname

	set_print_object on $testname
	check_new_derived_with_rtti ref {Derived \&} $testname
	check_new_derived_with_rtti constRef {const Derived \&} $testname
  :*/
	return;
  /*: END: use_rtti_for_ref :*/
}


void use_rtti_for_ptr_child_test ()
{
  /*: BEGIN: use_rtti_for_ptr_child :*/
	Derived d;
	struct S {	
		Base* ptr;
		const Base* constPtr;
		Base* const ptrConst;
		Base const* const constPtrConst;
		S ( Base* v ) :
			ptr ( v ),
			constPtr ( v ),
			ptrConst ( v ),
			constPtrConst ( v ) {}
	} s ( &d );
  /*: 
	set testname use_rtti_for_ptr_child

	set_print_object off $testname
	mi_create_varobj VAR s "create varobj for s (without RTTI) in $testname"
	mi_list_varobj_children VAR {
	    { VAR.public public 4 }
	} "list children of s (without RTTI) in $testname"
	mi_list_varobj_children VAR.public {
	    { VAR.public.ptr ptr 1 {Base \*} }
	    { VAR.public.constPtr constPtr 1 {const Base \*} }
	    { VAR.public.ptrConst ptrConst 1 {Base \* const} }
	    { VAR.public.constPtrConst constPtrConst 1 {const Base \* const} }
	} "list children of s.public (without RTTI) in $testname"
	check_derived_without_rtti VAR.public.ptr s.ptr $testname
	check_derived_without_rtti VAR.public.constPtr s.constPtr $testname
	check_derived_without_rtti VAR.public.ptrConst s.ptrConst $testname
	check_derived_without_rtti VAR.public.constPtrConst s.constPtrConst \
		$testname
	mi_delete_varobj VAR "delete varobj for s (without RTTI) in $testname"

	set_print_object on $testname
	mi_create_varobj VAR s "create varobj for s (with RTTI) in $testname"
	mi_list_varobj_children VAR {
	    { VAR.public public 4 }
	} "list children of s (with RTTI) in $testname"
	mi_list_varobj_children VAR.public {
	    { VAR.public.ptr ptr 2 {Derived \*} }
	    { VAR.public.constPtr constPtr 2 {const Derived \*} }
	    { VAR.public.ptrConst ptrConst 2 {Derived \* const} }
	    { VAR.public.constPtrConst constPtrConst 2 {const Derived \* const}}
	} "list children of s.public (with RTTI) in $testname"
	check_derived_with_rtti VAR.public.ptr s.ptr $testname
	check_derived_with_rtti VAR.public.constPtr s.constPtr $testname
	check_derived_with_rtti VAR.public.ptrConst s.ptrConst $testname
	check_derived_with_rtti VAR.public.constPtrConst s.constPtrConst \
		$testname
	mi_delete_varobj VAR "delete varobj for s (with RTTI) in $testname"
  :*/
	return;
  /*: END: use_rtti_for_ptr_child :*/
}


void use_rtti_for_ref_child_test ()
{
  /*: BEGIN: use_rtti_for_ref_child :*/
	Derived d;
	struct S {	
		Base& ref;
		const Base& constRef;
		S ( Base& v ) :
			ref ( v ),
			constRef ( v ) {}
	} s ( d );
  /*: 
	set testname use_rtti_for_ref_child

	set_print_object off $testname
	mi_create_varobj VAR s "create varobj for s (without RTTI) in $testname"
	mi_list_varobj_children VAR {
	    { VAR.public public 2 }
	} "list children of s (without RTTI) in $testname"
	mi_list_varobj_children VAR.public {
	    { VAR.public.ref ref 1 {Base \&} }
	    { VAR.public.constRef constRef 1 {const Base \&} }
	} "list children of s.public (without RTTI) in $testname"
	check_derived_without_rtti VAR.public.ref s.ref $testname
	check_derived_without_rtti VAR.public.constRef s.constRef  $testname
	mi_delete_varobj VAR "delete varobj for s (without RTTI) in $testname"

	set_print_object on $testname
	mi_create_varobj VAR s "create varobj for s (with RTTI) in $testname"
	mi_list_varobj_children VAR {
	    { VAR.public public 2 }
	} "list children of s (with RTTI) in $testname"
	mi_list_varobj_children VAR.public {
	    { VAR.public.ref ref 2 {Derived \&} }
	    { VAR.public.constRef constRef 2 {const Derived \&} }
	} "list children of s.public (with RTTI) in $testname"
	check_derived_with_rtti VAR.public.ref s.ref $testname
	check_derived_with_rtti VAR.public.constRef s.constRef $testname
	mi_delete_varobj VAR "delete varobj for s (with RTTI) in $testname"
  :*/
	return;
  /*: END: use_rtti_for_ref_child :*/
}


struct First {
    First() : F(-1) {}
    int F;
};


struct MultipleDerived : public First, Base {
    MultipleDerived() : B(2), C(3) {}
    int B;
    int C;
};


void use_rtti_with_multiple_inheritence_test ()
{
  /*: BEGIN: use_rtti_with_multiple_inheritence :*/
	MultipleDerived d;
	Base* ptr = &d;
	Base& ref = d;
  /*:
	set testname use_rtti_with_multiple_inheritence
	set_print_object off $testname
	check_new_derived_without_rtti ptr {Base \*} $testname
	check_new_derived_without_rtti ref {Base \&} $testname

	set_print_object on $testname
	mi_create_varobj_checked VAR ptr {MultipleDerived \*} \
	    "create varobj for ptr (with RTTI) in $testname"
	mi_list_varobj_children VAR {
	    { VAR.First First 1 First }
	    { VAR.Base Base 1 Base }
	    { VAR.public public 2 }
	} "list children of ptr (with RTTI) in $testname"
	mi_list_varobj_children "VAR.First" {
	    { VAR.First.public public 1 }
	} "list children of ptr.First (with RTTI) in $testname"
	mi_list_varobj_children "VAR.First.public" {
	    { VAR.First.public.F F 0 int }
	} "list children of ptr.First.public (with RTTI) in $testname"
	mi_list_varobj_children "VAR.Base" {
	    { VAR.Base.public public 1 }
	} "list children of ptr.Base (with RTTI) in $testname"
	mi_list_varobj_children "VAR.Base.public" {
	    { VAR.Base.public.A A 0 int }
	} "list children of ptr.Base.public (with RTTI) in $testname"
	mi_list_varobj_children "VAR.public" {
	    { VAR.public.B B 0 int }
	    { VAR.public.C C 0 int }
	} "list children of ptr.public (with RTTI) in $testname"

	mi_delete_varobj VAR \
	    "delete varobj for ptr (with RTTI) in $testname"
  :*/
	return;
  /*: END: use_rtti_with_multiple_inheritence :*/
}


void type_update_when_use_rtti_test ()
{
  /*: BEGIN: type_update_when_use_rtti :*/
	Base *ptr = 0;
	struct S {
		Base* ptr;
		S ( Base* v ) :
			ptr ( v ) {}
	} s ( ptr );
	Derived d;
  /*: 
	set testname type_update_when_use_rtti

	set_print_object on $testname
	mi_create_varobj_checked PTR ptr {Base \*} \
		"create varobj for ptr in $testname"
	check_derived_children_without_rtti PTR ptr $testname

	mi_create_varobj S s "create varobj for S in $testname"
	mi_list_varobj_children S {
	    { S.public public 1 }
	} "list children of s in $testname"
	mi_list_varobj_children S.public {
	    { S.public.ptr ptr 1 {Base \*} }
	} "list children of s.public in $testname"
	check_derived_children_without_rtti S.public.ptr s.ptr $testname
  :*/

	ptr = &d;
	s.ptr = &d;
  /*:
	mi_varobj_update_with_type_change PTR {Derived \*} 2 \
		"update ptr to derived in $testname"
	check_derived_with_rtti PTR ptr $testname

	mi_varobj_update_with_child_type_change S S.public.ptr {Derived \*} 2 \
		"update s.ptr to derived in $testname"
	check_derived_with_rtti S.public.ptr s.ptr $testname
  :*/

	ptr = 0;
	s.ptr = 0;
  /*:
	mi_varobj_update_with_type_change PTR {Base \*} 1 \
		"update ptr back to base type in $testname"
	mi_delete_varobj PTR "delete varobj for ptr in $testname"

	mi_varobj_update_with_child_type_change S S.public.ptr {Base \*} 1 \
		"update s.ptr back to base type in $testname"
	mi_delete_varobj S "delete varobj for s in $testname"
  :*/
	return;
  /*: END: type_update_when_use_rtti :*/
}


void skip_type_update_when_not_use_rtti_test ()
{
  /*: BEGIN: skip_type_update_when_not_use_rtti :*/
	Base *ptr = 0;
	struct S {
		Base* ptr;
		S ( Base* v ) :
			ptr ( v ) {}
	} s ( ptr );
	Derived d;
  /*: 
	set testname skip_type_update_when_not_use_rtti

	with_test_prefix "ptr is nullptr" {
	  set_print_object off $testname
	  mi_create_varobj_checked PTR ptr {Base \*} \
		"create varobj for ptr in $testname"
	  check_derived_children_without_rtti PTR ptr $testname

	  mi_create_varobj S s "create varobj for S in $testname"
	  mi_list_varobj_children S {
	      { S.public public 1 }
	  } "list children of s in $testname"
	  mi_list_varobj_children S.public {
	      { S.public.ptr ptr 1 {Base \*} }
	  } "list children of s.public in $testname"
	  check_derived_children_without_rtti S.public.ptr s.ptr $testname
	}
  :*/

	ptr = &d;
	s.ptr = &d;
  /*: 
        with_test_prefix "ptr points at d" {
	  mi_varobj_update PTR {PTR PTR.public.A} \
		"update ptr to derived type in $testname"
	  check_derived_without_rtti PTR ptr $testname

	  mi_varobj_update S {S.public.ptr S.public.ptr.public.A} \
		"update s to derived type in $testname"
	  check_derived_without_rtti S.public.ptr s.ptr $testname
	}
  :*/

	ptr = 0;
	s.ptr = 0;
  /*:
        with_test_prefix "ptr is nullptr again" {
	  mi_varobj_update PTR {PTR  PTR.public.A} \
		"update ptr back to base type in $testname"
	  mi_delete_varobj PTR "delete varobj for ptr in $testname"

	  mi_varobj_update S {S.public.ptr S.public.ptr.public.A} \
		"update s back to base type in $testname"
	  mi_delete_varobj S "delete varobj for s in $testname"
	}
  :*/
	return;
  /*: END: skip_type_update_when_not_use_rtti :*/
}


int main ()
{
	use_rtti_for_ptr_test();
	use_rtti_for_ref_test();
	use_rtti_for_ptr_child_test();
	use_rtti_for_ref_child_test();
	use_rtti_with_multiple_inheritence_test();
	type_update_when_use_rtti_test();
	skip_type_update_when_not_use_rtti_test();
	return 0;
}
Commit	Line	Data
1d506c26	1	/* Copyright 2012-2024 Free Software Foundation, Inc.
8264ba82 AG	2
	3	This program is free software; you can redistribute it and/or modify
	4	it under the terms of the GNU General Public License as published by
	5	the Free Software Foundation; either version 3 of the License, or
	6	(at your option) any later version.
	7
	8	This program is distributed in the hope that it will be useful,
	9	but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	GNU General Public License for more details.
	12
	13	You should have received a copy of the GNU General Public License
47d48711	14	along with this program. If not, see <http://www.gnu.org/licenses/>. */
8264ba82 AG	15
	16	struct Base {
	17	Base() : A(1) {}
	18	virtual ~Base() {} // Enforce type to have vtable
	19	int A;
	20	};
	21
	22	struct Derived : public Base {
	23	Derived() : B(2), C(3) {}
	24	int B;
	25	int C;
	26	};
	27
	28
	29	void use_rtti_for_ptr_test ()
	30	{
	31	/: BEGIN: use_rtti_for_ptr :/
	32	Derived d;
	33	Base* ptr = &d;
	34	const Base* constPtr = &d;
	35	Base* const ptrConst = &d;
	36	Base const* const constPtrConst = &d;
	37	/*:
	38	set testname use_rtti_for_ptr
	39	set_print_object off $testname
	40	check_new_derived_without_rtti ptr {Base \*} $testname
	41	check_new_derived_without_rtti constPtr {const Base \*} $testname
	42	check_new_derived_without_rtti ptrConst {Base \* const} $testname
	43	check_new_derived_without_rtti constPtrConst {const Base \* const} \
	44	$testname
	45
	46	set_print_object on $testname
	47	check_new_derived_with_rtti ptr {Derived \*} $testname
	48	check_new_derived_with_rtti constPtr {const Derived \*} $testname
	49	check_new_derived_with_rtti ptrConst {Derived \* const} $testname
	50	check_new_derived_with_rtti constPtrConst {const Derived \* const} \
	51	$testname
	52	:*/
	53	return;
	54	/: END: use_rtti_for_ptr :/
	55	}
	56
	57
	58	void use_rtti_for_ref_test ()
	59	{
	60	/: BEGIN: use_rtti_for_ref :/
	61	Derived d;
	62	Base& ref = d;
	63	const Base& constRef = d;
	64	/*:
	65	set testname use_rtti_for_ref
	66	set_print_object off $testname
	67	check_new_derived_without_rtti ref {Base \&} $testname
	68	check_new_derived_without_rtti constRef {const Base \&} $testname
	69
	70	set_print_object on $testname
	71	check_new_derived_with_rtti ref {Derived \&} $testname
	72	check_new_derived_with_rtti constRef {const Derived \&} $testname
	73	:*/
	74	return;
	75	/: END: use_rtti_for_ref :/
	76	}
	77
	78
79	void use_rtti_for_ptr_child_test ()
80	{
81	/: BEGIN: use_rtti_for_ptr_child :/
82	Derived d;
83	struct S {
84	Base* ptr;
85	const Base* constPtr;
86	Base* const ptrConst;
87	Base const* const constPtrConst;
88	S ( Base* v ) :
89	ptr ( v ),
90	constPtr ( v ),
91	ptrConst ( v ),
92	constPtrConst ( v ) {}
93	} s ( &d );
94	/*:
95	set testname use_rtti_for_ptr_child
96
97	set_print_object off $testname
98	mi_create_varobj VAR s "create varobj for s (without RTTI) in $testname"
99	mi_list_varobj_children VAR {
100	{ VAR.public public 4 }
101	} "list children of s (without RTTI) in $testname"
102	mi_list_varobj_children VAR.public {
103	{ VAR.public.ptr ptr 1 {Base \*} }
104	{ VAR.public.constPtr constPtr 1 {const Base \*} }
105	{ VAR.public.ptrConst ptrConst 1 {Base \* const} }
106	{ VAR.public.constPtrConst constPtrConst 1 {const Base \* const} }
107	} "list children of s.public (without RTTI) in $testname"
108	check_derived_without_rtti VAR.public.ptr s.ptr $testname
109	check_derived_without_rtti VAR.public.constPtr s.constPtr $testname
110	check_derived_without_rtti VAR.public.ptrConst s.ptrConst $testname
111	check_derived_without_rtti VAR.public.constPtrConst s.constPtrConst \
112	$testname
113	mi_delete_varobj VAR "delete varobj for s (without RTTI) in $testname"
114
115	set_print_object on $testname
116	mi_create_varobj VAR s "create varobj for s (with RTTI) in $testname"
117	mi_list_varobj_children VAR {
118	{ VAR.public public 4 }
119	} "list children of s (with RTTI) in $testname"
120	mi_list_varobj_children VAR.public {
121	{ VAR.public.ptr ptr 2 {Derived \*} }
122	{ VAR.public.constPtr constPtr 2 {const Derived \*} }
123	{ VAR.public.ptrConst ptrConst 2 {Derived \* const} }
124	{ VAR.public.constPtrConst constPtrConst 2 {const Derived \* const}}
125	} "list children of s.public (with RTTI) in $testname"
126	check_derived_with_rtti VAR.public.ptr s.ptr $testname
127	check_derived_with_rtti VAR.public.constPtr s.constPtr $testname
128	check_derived_with_rtti VAR.public.ptrConst s.ptrConst $testname
129	check_derived_with_rtti VAR.public.constPtrConst s.constPtrConst \
130	$testname
131	mi_delete_varobj VAR "delete varobj for s (with RTTI) in $testname"
132	:*/
133	return;
134	/: END: use_rtti_for_ptr_child :/
135	}
136
137
138	void use_rtti_for_ref_child_test ()
139	{
140	/: BEGIN: use_rtti_for_ref_child :/
141	Derived d;
142	struct S {
143	Base& ref;
144	const Base& constRef;
145	S ( Base& v ) :
146	ref ( v ),
147	constRef ( v ) {}
148	} s ( d );
149	/*:
150	set testname use_rtti_for_ref_child
151
152	set_print_object off $testname
153	mi_create_varobj VAR s "create varobj for s (without RTTI) in $testname"
154	mi_list_varobj_children VAR {
155	{ VAR.public public 2 }
156	} "list children of s (without RTTI) in $testname"
157	mi_list_varobj_children VAR.public {
158	{ VAR.public.ref ref 1 {Base \&} }
159	{ VAR.public.constRef constRef 1 {const Base \&} }
160	} "list children of s.public (without RTTI) in $testname"
161	check_derived_without_rtti VAR.public.ref s.ref $testname
162	check_derived_without_rtti VAR.public.constRef s.constRef $testname
163	mi_delete_varobj VAR "delete varobj for s (without RTTI) in $testname"
164
165	set_print_object on $testname
166	mi_create_varobj VAR s "create varobj for s (with RTTI) in $testname"
167	mi_list_varobj_children VAR {
168	{ VAR.public public 2 }
169	} "list children of s (with RTTI) in $testname"
170	mi_list_varobj_children VAR.public {
171	{ VAR.public.ref ref 2 {Derived \&} }
172	{ VAR.public.constRef constRef 2 {const Derived \&} }
173	} "list children of s.public (with RTTI) in $testname"
174	check_derived_with_rtti VAR.public.ref s.ref $testname
175	check_derived_with_rtti VAR.public.constRef s.constRef $testname
176	mi_delete_varobj VAR "delete varobj for s (with RTTI) in $testname"
177	:*/
178	return;
179	/: END: use_rtti_for_ref_child :/
180	}
181
182
183	struct First {
184	First() : F(-1) {}
185	int F;
186	};
187
188
189	struct MultipleDerived : public First, Base {
190	MultipleDerived() : B(2), C(3) {}
191	int B;
192	int C;
193	};
194
195
196	void use_rtti_with_multiple_inheritence_test ()
197	{
198	/: BEGIN: use_rtti_with_multiple_inheritence :/
199	MultipleDerived d;
200	Base* ptr = &d;
201	Base& ref = d;
202	/*:
203	set testname use_rtti_with_multiple_inheritence
204	set_print_object off $testname
205	check_new_derived_without_rtti ptr {Base \*} $testname
206	check_new_derived_without_rtti ref {Base \&} $testname
207
208	set_print_object on $testname
209	mi_create_varobj_checked VAR ptr {MultipleDerived \*} \
210	"create varobj for ptr (with RTTI) in $testname"
211	mi_list_varobj_children VAR {
212	{ VAR.First First 1 First }
213	{ VAR.Base Base 1 Base }
214	{ VAR.public public 2 }
215	} "list children of ptr (with RTTI) in $testname"
216	mi_list_varobj_children "VAR.First" {
217	{ VAR.First.public public 1 }
218	} "list children of ptr.First (with RTTI) in $testname"
219	mi_list_varobj_children "VAR.First.public" {
220	{ VAR.First.public.F F 0 int }
b6846ba5	221	} "list children of ptr.First.public (with RTTI) in $testname"
8264ba82 AG	222	mi_list_varobj_children "VAR.Base" {
	223	{ VAR.Base.public public 1 }
	224	} "list children of ptr.Base (with RTTI) in $testname"
	225	mi_list_varobj_children "VAR.Base.public" {
	226	{ VAR.Base.public.A A 0 int }
	227	} "list children of ptr.Base.public (with RTTI) in $testname"
	228	mi_list_varobj_children "VAR.public" {
	229	{ VAR.public.B B 0 int }
	230	{ VAR.public.C C 0 int }
	231	} "list children of ptr.public (with RTTI) in $testname"
	232
	233	mi_delete_varobj VAR \
	234	"delete varobj for ptr (with RTTI) in $testname"
	235	:*/
	236	return;
	237	/: END: use_rtti_with_multiple_inheritence :/
	238	}
	239
	240
	241	void type_update_when_use_rtti_test ()
	242	{
	243	/: BEGIN: type_update_when_use_rtti :/
70795c52 LM	244	Base *ptr = 0;
	245	struct S {
	246	Base* ptr;
	247	S ( Base* v ) :
	248	ptr ( v ) {}
	249	} s ( ptr );
8264ba82 AG	250	Derived d;
	251	/*:
	252	set testname type_update_when_use_rtti
	253
	254	set_print_object on $testname
	255	mi_create_varobj_checked PTR ptr {Base \*} \
	256	"create varobj for ptr in $testname"
	257	check_derived_children_without_rtti PTR ptr $testname
	258
	259	mi_create_varobj S s "create varobj for S in $testname"
	260	mi_list_varobj_children S {
	261	{ S.public public 1 }
	262	} "list children of s in $testname"
	263	mi_list_varobj_children S.public {
	264	{ S.public.ptr ptr 1 {Base \*} }
	265	} "list children of s.public in $testname"
	266	check_derived_children_without_rtti S.public.ptr s.ptr $testname
	267	:*/
	268
70795c52 LM	269	ptr = &d;
70795c52 LM	270	s.ptr = &d;
8264ba82 AG	271	/*:
	272	mi_varobj_update_with_type_change PTR {Derived \*} 2 \
	273	"update ptr to derived in $testname"
	274	check_derived_with_rtti PTR ptr $testname
	275
	276	mi_varobj_update_with_child_type_change S S.public.ptr {Derived \*} 2 \
	277	"update s.ptr to derived in $testname"
	278	check_derived_with_rtti S.public.ptr s.ptr $testname
	279	:*/
	280
	281	ptr = 0;
	282	s.ptr = 0;
	283	/*:
	284	mi_varobj_update_with_type_change PTR {Base \*} 1 \
	285	"update ptr back to base type in $testname"
	286	mi_delete_varobj PTR "delete varobj for ptr in $testname"
	287
	288	mi_varobj_update_with_child_type_change S S.public.ptr {Base \*} 1 \
	289	"update s.ptr back to base type in $testname"
	290	mi_delete_varobj S "delete varobj for s in $testname"
	291	:*/
	292	return;
	293	/: END: type_update_when_use_rtti :/
	294	}
	295
	296
	297	void skip_type_update_when_not_use_rtti_test ()
	298	{
	299	/: BEGIN: skip_type_update_when_not_use_rtti :/
70795c52 LM	300	Base *ptr = 0;
	301	struct S {
	302	Base* ptr;
	303	S ( Base* v ) :
	304	ptr ( v ) {}
	305	} s ( ptr );
8264ba82 AG	306	Derived d;
	307	/*:
	308	set testname skip_type_update_when_not_use_rtti
	309
b6846ba5 AB	310	with_test_prefix "ptr is nullptr" {
	311	set_print_object off $testname
	312	mi_create_varobj_checked PTR ptr {Base \*} \
8264ba82	313	"create varobj for ptr in $testname"
b6846ba5 AB	314	check_derived_children_without_rtti PTR ptr $testname
	315
	316	mi_create_varobj S s "create varobj for S in $testname"
	317	mi_list_varobj_children S {
	318	{ S.public public 1 }
	319	} "list children of s in $testname"
	320	mi_list_varobj_children S.public {
	321	{ S.public.ptr ptr 1 {Base \*} }
	322	} "list children of s.public in $testname"
	323	check_derived_children_without_rtti S.public.ptr s.ptr $testname
	324	}
8264ba82 AG	325	:*/
8264ba82 AG	326
70795c52 LM	327	ptr = &d;
70795c52 LM	328	s.ptr = &d;
8264ba82	329	/*:
b6846ba5 AB	330	with_test_prefix "ptr points at d" {
b6846ba5 AB	331	mi_varobj_update PTR {PTR PTR.public.A} \
8264ba82	332	"update ptr to derived type in $testname"
b6846ba5	333	check_derived_without_rtti PTR ptr $testname
8264ba82	334
b6846ba5	335	mi_varobj_update S {S.public.ptr S.public.ptr.public.A} \
8264ba82	336	"update s to derived type in $testname"
b6846ba5 AB	337	check_derived_without_rtti S.public.ptr s.ptr $testname
b6846ba5 AB	338	}
8264ba82 AG	339	:*/
	340
	341	ptr = 0;
	342	s.ptr = 0;
	343	/*:
b6846ba5 AB	344	with_test_prefix "ptr is nullptr again" {
b6846ba5 AB	345	mi_varobj_update PTR {PTR PTR.public.A} \
8264ba82	346	"update ptr back to base type in $testname"
b6846ba5	347	mi_delete_varobj PTR "delete varobj for ptr in $testname"
8264ba82	348
b6846ba5	349	mi_varobj_update S {S.public.ptr S.public.ptr.public.A} \
8264ba82	350	"update s back to base type in $testname"
b6846ba5 AB	351	mi_delete_varobj S "delete varobj for s in $testname"
b6846ba5 AB	352	}
8264ba82 AG	353	:*/
	354	return;
	355	/: END: skip_type_update_when_not_use_rtti :/
	356	}
	357
	358
	359	int main ()
	360	{
	361	use_rtti_for_ptr_test();
	362	use_rtti_for_ref_test();
	363	use_rtti_for_ptr_child_test();
	364	use_rtti_for_ref_child_test();
	365	use_rtti_with_multiple_inheritence_test();
	366	type_update_when_use_rtti_test();
	367	skip_type_update_when_not_use_rtti_test();
	368	return 0;
	369	}