1/* This testcase is part of GDB, the GNU debugger.
2
3   Copyright 2008-2020 Free Software Foundation, Inc.
4
5   This program is free software; you can redistribute it and/or modify
6   it under the terms of the GNU General Public License as published by
7   the Free Software Foundation; either version 3 of the License, or
8   (at your option) any later version.
9
10   This program is distributed in the hope that it will be useful,
11   but WITHOUT ANY WARRANTY; without even the implied warranty of
12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13   GNU General Public License for more details.
14
15   You should have received a copy of the GNU General Public License
16   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
17
18#include <stdio.h>
19#include <unistd.h>
20/*
21 *	Since using watchpoints can be very slow, we have to take some pains to
22 *	ensure that we don't run too long with them enabled or we run the risk
23 *	of having the test timeout.  To help avoid this, we insert some marker
24 *	functions in the execution stream so we can set breakpoints at known
25 *	locations, without worrying about invalidating line numbers by changing
26 *	this file.  We use null bodied functions are markers since gdb does
27 *	not support breakpoints at labeled text points at this time.
28 *
29 *	One place we need is a marker for when we start executing our tests
30 *	instructions rather than any process startup code, so we insert one
31 *	right after entering main().  Another is right before we finish, before
32 *	we start executing any process termination code.
33 *
34 *	Another problem we have to guard against, at least for the test
35 *	suite, is that we need to ensure that the line that causes the
36 *	watchpoint to be hit is still the current line when gdb notices
37 *	the hit.  Depending upon the specific code generated by the compiler,
38 *	the instruction after the one that triggers the hit may be part of
39 *	the same line or part of the next line.  Thus we ensure that there
40 *	are always some instructions to execute on the same line after the
41 *	code that should trigger the hit.
42 */
43
44int count = -1;
45int ival1 = -1;
46int ival2 = -1;
47int ival3 = -1;
48int ival4 = -1;
49int ival5 = -1;
50char buf[10];
51struct foo
52{
53  int val;
54};
55struct foo struct1, struct2, *ptr1, *ptr2;
56
57int doread = 0;
58
59char *global_ptr;
60
61void marker1 ()
62{
63}
64
65void marker2 ()
66{
67}
68
69void marker4 ()
70{
71}
72
73void marker5 ()
74{
75}
76
77void marker6 ()
78{
79}
80
81void recurser (int  x)
82{
83  int  local_x;
84
85  if (x > 0)
86    recurser (x-1);
87  local_x = x;
88}
89
90void
91func2 ()
92{
93  int  local_a;
94  static int  static_b;
95
96  ival5++;
97  local_a = ival5;
98  static_b = local_a;
99}
100
101void
102func3 ()
103{
104  int x;
105  int y;
106
107  x = 0;
108  x = 1;				/* second x assignment */
109  y = 1;
110  y = 2;
111}
112
113int
114func1 ()
115{
116  /* The point of this is that we will set a breakpoint at this call.
117
118     Then, if DECR_PC_AFTER_BREAK equals the size of a function call
119     instruction (true on a sun3 if this is gcc-compiled--FIXME we
120     should use asm() to make it work for any compiler, present or
121     future), then we will end up branching to the location just after
122     the breakpoint.  And we better not confuse that with hitting the
123     breakpoint.  */
124  func2 ();
125  return 73;
126}
127
128void
129func4 ()
130{
131  buf[0] = 3;
132  global_ptr = buf;
133  buf[0] = 7;
134}
135
136int main ()
137{
138  struct1.val = 1;
139  struct2.val = 2;
140  ptr1 = &struct1;
141  ptr2 = &struct2;
142  marker1 ();
143  func1 ();
144  for (count = 0; count < 4; count++) {
145    ival1 = count;
146    ival3 = count; ival4 = count;
147  }
148  ival1 = count; /* Outside loop */
149  ival2 = count;
150  ival3 = count; ival4 = count;
151  marker2 ();
152  if (doread)
153    {
154      static char msg[] = "type stuff for buf now:";
155      write (1, msg, sizeof (msg) - 1);
156      read (0, &buf[0], 5);
157    }
158  marker4 ();
159
160  /* We have a watchpoint on ptr1->val.  It should be triggered if
161     ptr1's value changes.  */
162  ptr1 = ptr2;
163
164  /* This should not trigger the watchpoint.  If it does, then we
165     used the wrong value chain to re-insert the watchpoints or we
166     are not evaluating the watchpoint expression correctly.  */
167  struct1.val = 5;
168  marker5 ();
169
170  /* We have a watchpoint on ptr1->val.  It should be triggered if
171     ptr1's value changes.  */
172  ptr1 = ptr2;
173
174  /* This should not trigger the watchpoint.  If it does, then we
175     used the wrong value chain to re-insert the watchpoints or we
176     are not evaluating the watchpoint expression correctly.  */
177  struct1.val = 5;
178  marker5 ();
179
180  /* We're going to watch locals of func2, to see that out-of-scope
181     watchpoints are detected and properly deleted.
182     */
183  marker6 ();
184
185  /* This invocation is used for watches of a single
186     local variable. */
187  func2 ();
188
189  /* This invocation is used for watches of an expression
190     involving a local variable. */
191  func2 ();
192
193  /* This invocation is used for watches of a static
194     (non-stack-based) local variable. */
195  func2 ();
196
197  /* This invocation is used for watches of a local variable
198     when recursion happens.
199     */
200  marker6 ();
201  recurser (2);
202
203  marker6 ();
204
205  func3 ();
206
207  func4 ();
208
209  return 0;
210} /* end of main */
211
212