mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-30 21:44:19 +08:00
262 lines
7.1 KiB
C++
262 lines
7.1 KiB
C++
/* Copyright 2006-2016 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 s"
|
|
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;
|
|
}
|