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