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

/* Copyright 2006-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/>.  */

void reference_update_tests ()
{
  /*: BEGIN: reference_update :*/
  int x = 167;
  /*: mi_create_varobj "RX" "rx" "create varobj for rx" :*/
  int& rx = x;
  /*: mi_varobj_update RX {RX} "update RX (1)"
      mi_check_varobj_value RX 167 "check RX: expect 167"
      :*/
  x = 567;
  /*: mi_varobj_update RX {RX} "update RX (2)"
      mi_check_varobj_value RX 567 "check RX: expect 567"
      :*/  
  x = 567;
  /*: mi_varobj_update RX {} "update RX (3)"
      mi_delete_varobj RX "delete RX"
    :*/
  /* Dummy assignment to keep 'x' in scope.  */
  x = 444;    

  /*: END: reference_update :*/
}

struct S { int i; int j; };
struct S2 : S {};
        
int base_in_reference_test (S2& s2)
{
  /*: BEGIN: base_in_reference :*/
  return s2.i;
  /*: 
    mi_create_varobj "S2" "s2" "create varobj for s2"
    mi_list_varobj_children "S2" {
       {"S2.S" "S" "1" "S"}
    } "list children of s2"
    mi_list_varobj_children "S2.S" {
       {"S2.S.public" "public" "2"}
    } "list children of s2.s"
    mi_list_varobj_children "S2.S.public" {
       {"S2.S.public.i" "i" "0" "int"}
       {"S2.S.public.j" "j" "0" "int"}
    } "list children of s2.s.public"

    mi_check_varobj_value "S2.S.public.i" "67" "check S2.S.public.i"
    mi_check_varobj_value "S2.S.public.j" "89" "check S2.S.public.j"
    mi_delete_varobj S2 "delete S2"
    
  :*/
  /*: END: base_in_reference :*/
}
        
void base_in_reference_test_main ()
{
  S2 s;
  s.i = 67;
  s.j = 89;
  base_in_reference_test (s);
}

int reference_to_pointer ()
{
  /*: BEGIN: reference_to_pointer :*/  
  S s, *ptr_s, *& rptr_s = ptr_s;
  s.i = 67;
  s.j = 89;
  ptr_s = &s;
  /*: 
    mi_create_varobj RPTR rptr_s "create varobj for rptr_s"

    mi_list_varobj_children RPTR {{RPTR.public public 2}}	\
    "list public child of RPTR"

    mi_list_varobj_children  RPTR.public	\
    {{RPTR.public.i i 0 int}
    {RPTR.public.j j 0 int}} "list children of reference to pointer"

    mi_check_varobj_value RPTR.public.i 67 "check i member"
    mi_check_varobj_value RPTR.public.j 89 "check j member"
    mi_delete_varobj RPTR "delete RPTR"
  :*/
  return 99;
  /*: END: reference_to_pointer :*/
}

int reference_to_struct ()
{
  /*: BEGIN: reference_to_struct :*/
  S s = {7, 8};
  S& r = s;
  /*:
    mi_create_varobj S s "create varobj for s"
    mi_create_varobj R r "create varobj for r"
    mi_gdb_test "-var-show-attributes S" \
	"\\^done,attr=\"noneditable\"" \
	"check attributes of S"
    mi_gdb_test "-var-show-attributes R" \
	"\\^done,attr=\"noneditable\"" \
	"check attributes of R"
    :*/
  s.i = 56;
  /*: mi_varobj_update * [] "-var-update should not list structure varobjs"
    :*/
  return 99;
  /*: END: reference_to_struct :*/
}

struct Base1
{
  int i;
};

struct Base2
{
  int i;
};

struct Derived : public Base1, public Base2
{
  int i;
};

/* Test for the -var-info-path-expression command.  Although
   said command is not specific to C++, it's of more importance
   to C++ than to C, so we test it in mi-var-cp test.  */
int path_expression ()
{
  /*: BEGIN: path_expression :*/
  int i = 10;
  int *ip = &i;
  /*: mi_create_varobj IP ip "create varobj for ip"
      mi_list_varobj_children IP {{IP.\\*ip \\*ip 0 int}} "list children of IP"
      mi_gdb_test "-var-info-path-expression IP.*ip" \
          "\\^done,path_expr=\"\\*\\(ip\\)\"" \
	  "-var-info-path-expression IP.*ip"
    :*/
  Derived d;
  Derived *dp = &d;
  /*: mi_create_varobj DP dp "create varobj for dp"
      mi_list_varobj_children DP                        \
      {{DP.Base1 Base1 1 Base1}                         \
       {DP.Base2 Base2 1 Base2}                         \
       {DP.public public 1}} "list children of DP"
      mi_gdb_test "-var-info-path-expression DP.Base1" \
          "\\^done,path_expr=\"\\(\\*\\(class Base1\\*\\) dp\\)\"" \
	  "-var-info-path-expression DP.Base1"       
      mi_list_varobj_children DP.public {               \
        {DP.public.i i 0 int}                           \
      } "list children of DP.public"
      mi_gdb_test "-var-info-path-expression DP.public.i" \
          "\\^done,path_expr=\"\\(\\(dp\\)->i\\)\"" \
	  "-var-info-path-expression DP.public.i"
      mi_list_varobj_children DP.Base1 {                 \
        {DP.Base1.public public 1}                             \
      } "list children of DP.Base1"
      mi_list_varobj_children DP.Base1.public {               \
        {DP.Base1.public.i i 0 int}                           \
      } "list children of DP.Base1.public"
      mi_gdb_test "-var-info-path-expression DP.Base1.public.i" \
          "\\^done,path_expr=\"\\(\\(\\(\\*\\(class Base1\\*\\) dp\\)\\).i\\)\"" \
	  "-var-info-path-expression DP.Base1.public.i"

      mi_gdb_test "-var-info-path-expression DP.public" \
          "\\^done,path_expr=\"\"" \
	  "-var-info-path-expression DP.public"

      mi_create_varobj D d "create varobj for d"
      mi_list_varobj_children D                        \
      {{D.Base1 Base1 1 Base1}                         \
       {D.Base2 Base2 1 Base2}                         \
       {D.public public 1}} "list children of D"
      mi_gdb_test "-var-info-path-expression D.Base1" \
          "\\^done,path_expr=\"\\(\\(class Base1\\) d\\)\"" \
	  "-var-info-path-expression D.Base1"
  :*/
  int array[4] = {1,2,3};
  array[3] = 10;
  /*: mi_create_varobj A array "create varobj for array"
      mi_list_varobj_children A { \
          {A.0 0 0 int}
          {A.1 1 0 int}
          {A.2 2 0 int}
          {A.3 3 0 int}} "list children of A"
      mi_gdb_test "-var-info-path-expression A.2" \
          "\\^done,path_expr=\"\\(array\\)\\\[2\\\]\"" \
	  "-var-info-path-expression A.2"
    :*/

  return 99;
  /*: END: path_expression :*/
}

class Anonymous
{
public:
  struct { /* index: 0 */
    int b;
  };
  struct { /* index: 1 */
    int c;
  };
  struct { /* index: 2 */
    int d;
    struct { /* index: 1 */
      int e;
      struct { /* index: 0 */
        int f;
        union { /* index: 0 */
          int g;
          char h;
        };
      };
      union { /* index: 0 */
        int i;
        char j;
      };
    };
  };
};

/* Test anonymous structs and unions.  */
int
anonymous_structs_and_unions (void)
{
  Anonymous a;
  a.b = 1;
  a.c = 2;
  a.d = 3;
  a.e = 4;
  a.f = 5;
  a.g = 6;
  a.h = '7';
  a.i = 8;
  a.j = '8';
  return 0;  /* anonymous_structs_and_unions */
}

int main ()
{
  reference_update_tests ();
  base_in_reference_test_main ();
  reference_to_pointer ();
  reference_to_struct ();
  path_expression ();
  anonymous_structs_and_unions ();
  return 0;
}
Commit	Line	Data
1d506c26	1	/* Copyright 2006-2024 Free Software Foundation, Inc.
b26ed50d VP	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
a9762ec7	5	the Free Software Foundation; either version 3 of the License, or
b26ed50d	6	(at your option) any later version.
a9762ec7	7
b26ed50d VP	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.
a9762ec7	12
b26ed50d	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/>. */
b26ed50d VP	15
	16	void reference_update_tests ()
	17	{
2d0720d9	18	/: BEGIN: reference_update :/
b26ed50d	19	int x = 167;
2d0720d9	20	/: mi_create_varobj "RX" "rx" "create varobj for rx" :/
b26ed50d	21	int& rx = x;
2d0720d9 VP	22	/*: mi_varobj_update RX {RX} "update RX (1)"
	23	mi_check_varobj_value RX 167 "check RX: expect 167"
	24	:*/
b26ed50d	25	x = 567;
2d0720d9 VP	26	/*: mi_varobj_update RX {RX} "update RX (2)"
	27	mi_check_varobj_value RX 567 "check RX: expect 567"
	28	:*/
b26ed50d	29	x = 567;
2d0720d9	30	/*: mi_varobj_update RX {} "update RX (3)"
6e2a9270	31	mi_delete_varobj RX "delete RX"
2d0720d9	32	:*/
81121995 VP	33	/* Dummy assignment to keep 'x' in scope. */
81121995 VP	34	x = 444;
2d0720d9 VP	35
2d0720d9 VP	36	/: END: reference_update :/
b26ed50d VP	37	}
b26ed50d VP	38
038224f6 VP	39	struct S { int i; int j; };
	40	struct S2 : S {};
	41
	42	int base_in_reference_test (S2& s2)
	43	{
2d0720d9	44	/: BEGIN: base_in_reference :/
038224f6	45	return s2.i;
2d0720d9 VP	46	/*:
	47	mi_create_varobj "S2" "s2" "create varobj for s2"
	48	mi_list_varobj_children "S2" {
	49	{"S2.S" "S" "1" "S"}
	50	} "list children of s2"
	51	mi_list_varobj_children "S2.S" {
	52	{"S2.S.public" "public" "2"}
	53	} "list children of s2.s"
	54	mi_list_varobj_children "S2.S.public" {
	55	{"S2.S.public.i" "i" "0" "int"}
	56	{"S2.S.public.j" "j" "0" "int"}
	57	} "list children of s2.s.public"
	58
	59	mi_check_varobj_value "S2.S.public.i" "67" "check S2.S.public.i"
	60	mi_check_varobj_value "S2.S.public.j" "89" "check S2.S.public.j"
6e2a9270 VP	61	mi_delete_varobj S2 "delete S2"
6e2a9270 VP	62
2d0720d9 VP	63	:*/
2d0720d9 VP	64	/: END: base_in_reference :/
038224f6 VP	65	}
	66
	67	void base_in_reference_test_main ()
	68	{
	69	S2 s;
	70	s.i = 67;
	71	s.j = 89;
	72	base_in_reference_test (s);
	73	}
	74
986d03be NR	75	int reference_to_pointer ()
986d03be NR	76	{
81121995	77	/: BEGIN: reference_to_pointer :/
986d03be NR	78	S s, ptr_s, & rptr_s = ptr_s;
	79	s.i = 67;
	80	s.j = 89;
	81	ptr_s = &s;
986d03be NR	82	/*:
	83	mi_create_varobj RPTR rptr_s "create varobj for rptr_s"
	84
	85	mi_list_varobj_children RPTR {{RPTR.public public 2}} \
	86	"list public child of RPTR"
	87
	88	mi_list_varobj_children RPTR.public \
	89	{{RPTR.public.i i 0 int}
	90	{RPTR.public.j j 0 int}} "list children of reference to pointer"
	91
	92	mi_check_varobj_value RPTR.public.i 67 "check i member"
	93	mi_check_varobj_value RPTR.public.j 89 "check j member"
6e2a9270	94	mi_delete_varobj RPTR "delete RPTR"
986d03be	95	:*/
81121995	96	return 99;
986d03be NR	97	/: END: reference_to_pointer :/
986d03be NR	98	}
038224f6	99
6e2a9270 VP	100	int reference_to_struct ()
	101	{
	102	/: BEGIN: reference_to_struct :/
	103	S s = {7, 8};
	104	S& r = s;
	105	/*:
	106	mi_create_varobj S s "create varobj for s"
9de46719	107	mi_create_varobj R r "create varobj for r"
6e2a9270 VP	108	mi_gdb_test "-var-show-attributes S" \
	109	"\\^done,attr=\"noneditable\"" \
	110	"check attributes of S"
	111	mi_gdb_test "-var-show-attributes R" \
	112	"\\^done,attr=\"noneditable\"" \
	113	"check attributes of R"
	114	:*/
	115	s.i = 56;
	116	/: mi_varobj_update [] "-var-update should not list structure varobjs"
	117	:*/
	118	return 99;
	119	/: END: reference_to_struct :/
	120	}
	121
02142340 VP	122	struct Base1
	123	{
	124	int i;
	125	};
	126
	127	struct Base2
	128	{
	129	int i;
	130	};
	131
	132	struct Derived : public Base1, public Base2
	133	{
	134	int i;
	135	};
	136
	137	/* Test for the -var-info-path-expression command. Although
	138	said command is not specific to C++, it's of more importance
	139	to C++ than to C, so we test it in mi-var-cp test. */
	140	int path_expression ()
	141	{
	142	/: BEGIN: path_expression :/
	143	int i = 10;
	144	int *ip = &i;
	145	/*: mi_create_varobj IP ip "create varobj for ip"
	146	mi_list_varobj_children IP {{IP.\\ip \\ip 0 int}} "list children of IP"
	147	mi_gdb_test "-var-info-path-expression IP.*ip" \
	148	"\\^done,path_expr=\"\\*\\(ip\\)\"" \
	149	"-var-info-path-expression IP.*ip"
	150	:*/
	151	Derived d;
	152	Derived *dp = &d;
	153	/*: mi_create_varobj DP dp "create varobj for dp"
	154	mi_list_varobj_children DP \
	155	{{DP.Base1 Base1 1 Base1} \
	156	{DP.Base2 Base2 1 Base2} \
	157	{DP.public public 1}} "list children of DP"
	158	mi_gdb_test "-var-info-path-expression DP.Base1" \
0d932b2f	159	"\\^done,path_expr=\"\\(\\\\(class Base1\\\\) dp\\)\"" \
02142340 VP	160	"-var-info-path-expression DP.Base1"
	161	mi_list_varobj_children DP.public { \
	162	{DP.public.i i 0 int} \
	163	} "list children of DP.public"
	164	mi_gdb_test "-var-info-path-expression DP.public.i" \
	165	"\\^done,path_expr=\"\\(\\(dp\\)->i\\)\"" \
	166	"-var-info-path-expression DP.public.i"
	167	mi_list_varobj_children DP.Base1 { \
	168	{DP.Base1.public public 1} \
	169	} "list children of DP.Base1"
	170	mi_list_varobj_children DP.Base1.public { \
	171	{DP.Base1.public.i i 0 int} \
	172	} "list children of DP.Base1.public"
	173	mi_gdb_test "-var-info-path-expression DP.Base1.public.i" \
0d932b2f	174	"\\^done,path_expr=\"\\(\\(\\(\\\\(class Base1\\\\) dp\\)\\).i\\)\"" \
02142340 VP	175	"-var-info-path-expression DP.Base1.public.i"
	176
	177	mi_gdb_test "-var-info-path-expression DP.public" \
	178	"\\^done,path_expr=\"\"" \
	179	"-var-info-path-expression DP.public"
	180
	181	mi_create_varobj D d "create varobj for d"
	182	mi_list_varobj_children D \
	183	{{D.Base1 Base1 1 Base1} \
	184	{D.Base2 Base2 1 Base2} \
	185	{D.public public 1}} "list children of D"
	186	mi_gdb_test "-var-info-path-expression D.Base1" \
0d932b2f	187	"\\^done,path_expr=\"\\(\\(class Base1\\) d\\)\"" \
02142340 VP	188	"-var-info-path-expression D.Base1"
	189	:*/
	190	int array[4] = {1,2,3};
	191	array[3] = 10;
	192	/*: mi_create_varobj A array "create varobj for array"
	193	mi_list_varobj_children A { \
	194	{A.0 0 0 int}
	195	{A.1 1 0 int}
	196	{A.2 2 0 int}
	197	{A.3 3 0 int}} "list children of A"
	198	mi_gdb_test "-var-info-path-expression A.2" \
	199	"\\^done,path_expr=\"\\(array\\)\\\[2\\\]\"" \
	200	"-var-info-path-expression A.2"
	201	:*/
	202
	203	return 99;
	204	/: END: path_expression :/
	205	}
	206
3848a17f KS	207	class Anonymous
	208	{
	209	public:
	210	struct { /* index: 0 */
	211	int b;
	212	};
	213	struct { /* index: 1 */
	214	int c;
	215	};
	216	struct { /* index: 2 */
	217	int d;
	218	struct { /* index: 1 */
	219	int e;
	220	struct { /* index: 0 */
	221	int f;
	222	union { /* index: 0 */
	223	int g;
	224	char h;
	225	};
	226	};
	227	union { /* index: 0 */
	228	int i;
	229	char j;
	230	};
	231	};
	232	};
	233	};
	234
	235	/* Test anonymous structs and unions. */
	236	int
	237	anonymous_structs_and_unions (void)
	238	{
	239	Anonymous a;
	240	a.b = 1;
	241	a.c = 2;
	242	a.d = 3;
	243	a.e = 4;
	244	a.f = 5;
	245	a.g = 6;
	246	a.h = '7';
	247	a.i = 8;
	248	a.j = '8';
	249	return 0; /* anonymous_structs_and_unions */
	250	}
	251
b26ed50d VP	252	int main ()
	253	{
	254	reference_update_tests ();
038224f6	255	base_in_reference_test_main ();
986d03be	256	reference_to_pointer ();
6e2a9270	257	reference_to_struct ();
02142340	258	path_expression ();
3848a17f	259	anonymous_structs_and_unions ();
b26ed50d VP	260	return 0;
b26ed50d VP	261	}