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