Commit | Line | Data |
---|---|---|
7d30c22d | 1 | /* Prologue value handling for GDB. |
e2882c85 | 2 | Copyright (C) 2003-2018 Free Software Foundation, Inc. |
7d30c22d JB |
3 | |
4 | This file is part of GDB. | |
5 | ||
6 | This program is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
a9762ec7 | 8 | the Free Software Foundation; either version 3 of the License, or |
7d30c22d JB |
9 | (at your option) any later version. |
10 | ||
11 | This program is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
0df8b418 | 17 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
7d30c22d JB |
18 | |
19 | #include "defs.h" | |
7d30c22d JB |
20 | #include "prologue-value.h" |
21 | #include "regcache.h" | |
22 | ||
23 | \f | |
24 | /* Constructors. */ | |
25 | ||
26 | pv_t | |
27 | pv_unknown (void) | |
28 | { | |
29 | pv_t v = { pvk_unknown, 0, 0 }; | |
30 | ||
31 | return v; | |
32 | } | |
33 | ||
34 | ||
35 | pv_t | |
36 | pv_constant (CORE_ADDR k) | |
37 | { | |
38 | pv_t v; | |
39 | ||
40 | v.kind = pvk_constant; | |
41 | v.reg = -1; /* for debugging */ | |
42 | v.k = k; | |
43 | ||
44 | return v; | |
45 | } | |
46 | ||
47 | ||
48 | pv_t | |
49 | pv_register (int reg, CORE_ADDR k) | |
50 | { | |
51 | pv_t v; | |
52 | ||
53 | v.kind = pvk_register; | |
54 | v.reg = reg; | |
55 | v.k = k; | |
56 | ||
57 | return v; | |
58 | } | |
59 | ||
60 | ||
61 | \f | |
62 | /* Arithmetic operations. */ | |
63 | ||
64 | /* If one of *A and *B is a constant, and the other isn't, swap the | |
65 | values as necessary to ensure that *B is the constant. This can | |
66 | reduce the number of cases we need to analyze in the functions | |
67 | below. */ | |
68 | static void | |
69 | constant_last (pv_t *a, pv_t *b) | |
70 | { | |
71 | if (a->kind == pvk_constant | |
72 | && b->kind != pvk_constant) | |
73 | { | |
74 | pv_t temp = *a; | |
75 | *a = *b; | |
76 | *b = temp; | |
77 | } | |
78 | } | |
79 | ||
80 | ||
81 | pv_t | |
82 | pv_add (pv_t a, pv_t b) | |
83 | { | |
84 | constant_last (&a, &b); | |
85 | ||
86 | /* We can add a constant to a register. */ | |
87 | if (a.kind == pvk_register | |
88 | && b.kind == pvk_constant) | |
89 | return pv_register (a.reg, a.k + b.k); | |
90 | ||
91 | /* We can add a constant to another constant. */ | |
92 | else if (a.kind == pvk_constant | |
93 | && b.kind == pvk_constant) | |
94 | return pv_constant (a.k + b.k); | |
95 | ||
96 | /* Anything else we don't know how to add. We don't have a | |
97 | representation for, say, the sum of two registers, or a multiple | |
98 | of a register's value (adding a register to itself). */ | |
99 | else | |
100 | return pv_unknown (); | |
101 | } | |
102 | ||
103 | ||
104 | pv_t | |
105 | pv_add_constant (pv_t v, CORE_ADDR k) | |
106 | { | |
107 | /* Rather than thinking of all the cases we can and can't handle, | |
108 | we'll just let pv_add take care of that for us. */ | |
109 | return pv_add (v, pv_constant (k)); | |
110 | } | |
111 | ||
112 | ||
113 | pv_t | |
114 | pv_subtract (pv_t a, pv_t b) | |
115 | { | |
116 | /* This isn't quite the same as negating B and adding it to A, since | |
117 | we don't have a representation for the negation of anything but a | |
118 | constant. For example, we can't negate { pvk_register, R1, 10 }, | |
119 | but we do know that { pvk_register, R1, 10 } minus { pvk_register, | |
120 | R1, 5 } is { pvk_constant, <ignored>, 5 }. | |
121 | ||
122 | This means, for example, that we could subtract two stack | |
123 | addresses; they're both relative to the original SP. Since the | |
124 | frame pointer is set based on the SP, its value will be the | |
125 | original SP plus some constant (probably zero), so we can use its | |
126 | value just fine, too. */ | |
127 | ||
128 | constant_last (&a, &b); | |
129 | ||
130 | /* We can subtract two constants. */ | |
131 | if (a.kind == pvk_constant | |
132 | && b.kind == pvk_constant) | |
133 | return pv_constant (a.k - b.k); | |
134 | ||
135 | /* We can subtract a constant from a register. */ | |
136 | else if (a.kind == pvk_register | |
137 | && b.kind == pvk_constant) | |
138 | return pv_register (a.reg, a.k - b.k); | |
139 | ||
140 | /* We can subtract a register from itself, yielding a constant. */ | |
141 | else if (a.kind == pvk_register | |
142 | && b.kind == pvk_register | |
143 | && a.reg == b.reg) | |
144 | return pv_constant (a.k - b.k); | |
145 | ||
146 | /* We don't know how to subtract anything else. */ | |
147 | else | |
148 | return pv_unknown (); | |
149 | } | |
150 | ||
151 | ||
152 | pv_t | |
153 | pv_logical_and (pv_t a, pv_t b) | |
154 | { | |
155 | constant_last (&a, &b); | |
156 | ||
157 | /* We can 'and' two constants. */ | |
158 | if (a.kind == pvk_constant | |
159 | && b.kind == pvk_constant) | |
160 | return pv_constant (a.k & b.k); | |
161 | ||
162 | /* We can 'and' anything with the constant zero. */ | |
163 | else if (b.kind == pvk_constant | |
164 | && b.k == 0) | |
165 | return pv_constant (0); | |
166 | ||
167 | /* We can 'and' anything with ~0. */ | |
168 | else if (b.kind == pvk_constant | |
169 | && b.k == ~ (CORE_ADDR) 0) | |
170 | return a; | |
171 | ||
172 | /* We can 'and' a register with itself. */ | |
173 | else if (a.kind == pvk_register | |
174 | && b.kind == pvk_register | |
175 | && a.reg == b.reg | |
176 | && a.k == b.k) | |
177 | return a; | |
178 | ||
179 | /* Otherwise, we don't know. */ | |
180 | else | |
181 | return pv_unknown (); | |
182 | } | |
183 | ||
184 | ||
185 | \f | |
186 | /* Examining prologue values. */ | |
187 | ||
188 | int | |
189 | pv_is_identical (pv_t a, pv_t b) | |
190 | { | |
191 | if (a.kind != b.kind) | |
192 | return 0; | |
193 | ||
194 | switch (a.kind) | |
195 | { | |
196 | case pvk_unknown: | |
197 | return 1; | |
198 | case pvk_constant: | |
199 | return (a.k == b.k); | |
200 | case pvk_register: | |
201 | return (a.reg == b.reg && a.k == b.k); | |
202 | default: | |
f3574227 | 203 | gdb_assert_not_reached ("unexpected prologue value kind"); |
7d30c22d JB |
204 | } |
205 | } | |
206 | ||
207 | ||
208 | int | |
209 | pv_is_constant (pv_t a) | |
210 | { | |
211 | return (a.kind == pvk_constant); | |
212 | } | |
213 | ||
214 | ||
215 | int | |
216 | pv_is_register (pv_t a, int r) | |
217 | { | |
218 | return (a.kind == pvk_register | |
219 | && a.reg == r); | |
220 | } | |
221 | ||
222 | ||
223 | int | |
224 | pv_is_register_k (pv_t a, int r, CORE_ADDR k) | |
225 | { | |
226 | return (a.kind == pvk_register | |
227 | && a.reg == r | |
228 | && a.k == k); | |
229 | } | |
230 | ||
231 | ||
232 | enum pv_boolean | |
233 | pv_is_array_ref (pv_t addr, CORE_ADDR size, | |
234 | pv_t array_addr, CORE_ADDR array_len, | |
235 | CORE_ADDR elt_size, | |
236 | int *i) | |
237 | { | |
238 | /* Note that, since .k is a CORE_ADDR, and CORE_ADDR is unsigned, if | |
239 | addr is *before* the start of the array, then this isn't going to | |
240 | be negative... */ | |
241 | pv_t offset = pv_subtract (addr, array_addr); | |
242 | ||
243 | if (offset.kind == pvk_constant) | |
244 | { | |
245 | /* This is a rather odd test. We want to know if the SIZE bytes | |
246 | at ADDR don't overlap the array at all, so you'd expect it to | |
247 | be an || expression: "if we're completely before || we're | |
248 | completely after". But with unsigned arithmetic, things are | |
249 | different: since it's a number circle, not a number line, the | |
250 | right values for offset.k are actually one contiguous range. */ | |
251 | if (offset.k <= -size | |
252 | && offset.k >= array_len * elt_size) | |
253 | return pv_definite_no; | |
254 | else if (offset.k % elt_size != 0 | |
255 | || size != elt_size) | |
256 | return pv_maybe; | |
257 | else | |
258 | { | |
259 | *i = offset.k / elt_size; | |
260 | return pv_definite_yes; | |
261 | } | |
262 | } | |
263 | else | |
264 | return pv_maybe; | |
265 | } | |
266 | ||
267 | ||
268 | \f | |
269 | /* Areas. */ | |
270 | ||
271 | ||
272 | /* A particular value known to be stored in an area. | |
273 | ||
274 | Entries form a ring, sorted by unsigned offset from the area's base | |
275 | register's value. Since entries can straddle the wrap-around point, | |
276 | unsigned offsets form a circle, not a number line, so the list | |
277 | itself is structured the same way --- there is no inherent head. | |
278 | The entry with the lowest offset simply follows the entry with the | |
279 | highest offset. Entries may abut, but never overlap. The area's | |
280 | 'entry' pointer points to an arbitrary node in the ring. */ | |
f7b7ed97 | 281 | struct pv_area::area_entry |
7d30c22d JB |
282 | { |
283 | /* Links in the doubly-linked ring. */ | |
284 | struct area_entry *prev, *next; | |
285 | ||
286 | /* Offset of this entry's address from the value of the base | |
287 | register. */ | |
288 | CORE_ADDR offset; | |
289 | ||
290 | /* The size of this entry. Note that an entry may wrap around from | |
291 | the end of the address space to the beginning. */ | |
292 | CORE_ADDR size; | |
293 | ||
294 | /* The value stored here. */ | |
295 | pv_t value; | |
296 | }; | |
297 | ||
298 | ||
f7b7ed97 | 299 | /* See prologue-value.h. */ |
7d30c22d | 300 | |
f7b7ed97 TT |
301 | pv_area::pv_area (int base_reg, int addr_bit) |
302 | : m_base_reg (base_reg), | |
303 | /* Remember that shift amounts equal to the type's width are | |
304 | undefined. */ | |
305 | m_addr_mask (((((CORE_ADDR) 1 << (addr_bit - 1)) - 1) << 1) | 1), | |
306 | m_entry (nullptr) | |
7d30c22d | 307 | { |
7d30c22d JB |
308 | } |
309 | ||
f7b7ed97 | 310 | /* See prologue-value.h. */ |
7d30c22d | 311 | |
f7b7ed97 TT |
312 | void |
313 | pv_area::clear_entries () | |
7d30c22d | 314 | { |
f7b7ed97 | 315 | struct area_entry *e = m_entry; |
7d30c22d JB |
316 | |
317 | if (e) | |
318 | { | |
319 | /* This needs to be a do-while loop, in order to actually | |
320 | process the node being checked for in the terminating | |
321 | condition. */ | |
322 | do | |
323 | { | |
324 | struct area_entry *next = e->next; | |
ad3bbd48 | 325 | |
7d30c22d | 326 | xfree (e); |
08f08ce6 | 327 | e = next; |
7d30c22d | 328 | } |
f7b7ed97 | 329 | while (e != m_entry); |
7d30c22d | 330 | |
f7b7ed97 | 331 | m_entry = 0; |
7d30c22d JB |
332 | } |
333 | } | |
334 | ||
335 | ||
f7b7ed97 | 336 | pv_area::~pv_area () |
7d30c22d | 337 | { |
f7b7ed97 | 338 | clear_entries (); |
7d30c22d JB |
339 | } |
340 | ||
341 | ||
f7b7ed97 | 342 | /* See prologue-value.h. */ |
7d30c22d | 343 | |
a900ff72 | 344 | bool |
f7b7ed97 | 345 | pv_area::store_would_trash (pv_t addr) |
7d30c22d JB |
346 | { |
347 | /* It may seem odd that pvk_constant appears here --- after all, | |
348 | that's the case where we know the most about the address! But | |
349 | pv_areas are always relative to a register, and we don't know the | |
350 | value of the register, so we can't compare entry addresses to | |
351 | constants. */ | |
352 | return (addr.kind == pvk_unknown | |
353 | || addr.kind == pvk_constant | |
f7b7ed97 | 354 | || (addr.kind == pvk_register && addr.reg != m_base_reg)); |
7d30c22d JB |
355 | } |
356 | ||
357 | ||
f7b7ed97 | 358 | /* See prologue-value.h. */ |
7d30c22d | 359 | |
f7b7ed97 TT |
360 | struct pv_area::area_entry * |
361 | pv_area::find_entry (CORE_ADDR offset) | |
7d30c22d | 362 | { |
f7b7ed97 | 363 | struct area_entry *e = m_entry; |
7d30c22d JB |
364 | |
365 | if (! e) | |
366 | return 0; | |
367 | ||
368 | /* If the next entry would be better than the current one, then scan | |
369 | forward. Since we use '<' in this loop, it always terminates. | |
370 | ||
371 | Note that, even setting aside the addr_mask stuff, we must not | |
372 | simplify this, in high school algebra fashion, to | |
373 | (e->next->offset < e->offset), because of the way < interacts | |
374 | with wrap-around. We have to subtract offset from both sides to | |
375 | make sure both things we're comparing are on the same side of the | |
376 | discontinuity. */ | |
f7b7ed97 TT |
377 | while (((e->next->offset - offset) & m_addr_mask) |
378 | < ((e->offset - offset) & m_addr_mask)) | |
7d30c22d JB |
379 | e = e->next; |
380 | ||
381 | /* If the previous entry would be better than the current one, then | |
382 | scan backwards. */ | |
f7b7ed97 TT |
383 | while (((e->prev->offset - offset) & m_addr_mask) |
384 | < ((e->offset - offset) & m_addr_mask)) | |
7d30c22d JB |
385 | e = e->prev; |
386 | ||
387 | /* In case there's some locality to the searches, set the area's | |
388 | pointer to the entry we've found. */ | |
f7b7ed97 | 389 | m_entry = e; |
7d30c22d JB |
390 | |
391 | return e; | |
392 | } | |
393 | ||
394 | ||
f7b7ed97 TT |
395 | /* See prologue-value.h. */ |
396 | ||
397 | int | |
398 | pv_area::overlaps (struct area_entry *entry, CORE_ADDR offset, CORE_ADDR size) | |
7d30c22d JB |
399 | { |
400 | /* Think carefully about wrap-around before simplifying this. */ | |
f7b7ed97 TT |
401 | return (((entry->offset - offset) & m_addr_mask) < size |
402 | || ((offset - entry->offset) & m_addr_mask) < entry->size); | |
7d30c22d JB |
403 | } |
404 | ||
405 | ||
f7b7ed97 TT |
406 | /* See prologue-value.h. */ |
407 | ||
7d30c22d | 408 | void |
f7b7ed97 | 409 | pv_area::store (pv_t addr, CORE_ADDR size, pv_t value) |
7d30c22d JB |
410 | { |
411 | /* Remove any (potentially) overlapping entries. */ | |
f7b7ed97 TT |
412 | if (store_would_trash (addr)) |
413 | clear_entries (); | |
7d30c22d JB |
414 | else |
415 | { | |
416 | CORE_ADDR offset = addr.k; | |
f7b7ed97 | 417 | struct area_entry *e = find_entry (offset); |
7d30c22d JB |
418 | |
419 | /* Delete all entries that we would overlap. */ | |
f7b7ed97 | 420 | while (e && overlaps (e, offset, size)) |
7d30c22d JB |
421 | { |
422 | struct area_entry *next = (e->next == e) ? 0 : e->next; | |
ad3bbd48 | 423 | |
7d30c22d JB |
424 | e->prev->next = e->next; |
425 | e->next->prev = e->prev; | |
426 | ||
427 | xfree (e); | |
428 | e = next; | |
429 | } | |
430 | ||
431 | /* Move the area's pointer to the next remaining entry. This | |
432 | will also zero the pointer if we've deleted all the entries. */ | |
f7b7ed97 | 433 | m_entry = e; |
7d30c22d JB |
434 | } |
435 | ||
f7b7ed97 | 436 | /* Now, there are no entries overlapping us, and m_entry is |
7d30c22d JB |
437 | either zero or pointing at the closest entry after us. We can |
438 | just insert ourselves before that. | |
439 | ||
440 | But if we're storing an unknown value, don't bother --- that's | |
441 | the default. */ | |
442 | if (value.kind == pvk_unknown) | |
443 | return; | |
444 | else | |
445 | { | |
446 | CORE_ADDR offset = addr.k; | |
8d749320 | 447 | struct area_entry *e = XNEW (struct area_entry); |
ad3bbd48 | 448 | |
7d30c22d JB |
449 | e->offset = offset; |
450 | e->size = size; | |
451 | e->value = value; | |
452 | ||
f7b7ed97 | 453 | if (m_entry) |
7d30c22d | 454 | { |
f7b7ed97 TT |
455 | e->prev = m_entry->prev; |
456 | e->next = m_entry; | |
7d30c22d JB |
457 | e->prev->next = e->next->prev = e; |
458 | } | |
459 | else | |
460 | { | |
461 | e->prev = e->next = e; | |
f7b7ed97 | 462 | m_entry = e; |
7d30c22d JB |
463 | } |
464 | } | |
465 | } | |
466 | ||
467 | ||
f7b7ed97 TT |
468 | /* See prologue-value.h. */ |
469 | ||
7d30c22d | 470 | pv_t |
f7b7ed97 | 471 | pv_area::fetch (pv_t addr, CORE_ADDR size) |
7d30c22d JB |
472 | { |
473 | /* If we have no entries, or we can't decide how ADDR relates to the | |
474 | entries we do have, then the value is unknown. */ | |
f7b7ed97 TT |
475 | if (! m_entry |
476 | || store_would_trash (addr)) | |
7d30c22d JB |
477 | return pv_unknown (); |
478 | else | |
479 | { | |
480 | CORE_ADDR offset = addr.k; | |
f7b7ed97 | 481 | struct area_entry *e = find_entry (offset); |
7d30c22d JB |
482 | |
483 | /* If this entry exactly matches what we're looking for, then | |
484 | we're set. Otherwise, say it's unknown. */ | |
485 | if (e->offset == offset && e->size == size) | |
486 | return e->value; | |
487 | else | |
488 | return pv_unknown (); | |
489 | } | |
490 | } | |
491 | ||
492 | ||
f7b7ed97 TT |
493 | /* See prologue-value.h. */ |
494 | ||
a900ff72 | 495 | bool |
f7b7ed97 | 496 | pv_area::find_reg (struct gdbarch *gdbarch, int reg, CORE_ADDR *offset_p) |
7d30c22d | 497 | { |
f7b7ed97 | 498 | struct area_entry *e = m_entry; |
7d30c22d JB |
499 | |
500 | if (e) | |
501 | do | |
502 | { | |
503 | if (e->value.kind == pvk_register | |
504 | && e->value.reg == reg | |
505 | && e->value.k == 0 | |
506 | && e->size == register_size (gdbarch, reg)) | |
507 | { | |
508 | if (offset_p) | |
509 | *offset_p = e->offset; | |
a900ff72 | 510 | return true; |
7d30c22d JB |
511 | } |
512 | ||
513 | e = e->next; | |
514 | } | |
f7b7ed97 | 515 | while (e != m_entry); |
7d30c22d | 516 | |
a900ff72 | 517 | return false; |
7d30c22d JB |
518 | } |
519 | ||
520 | ||
f7b7ed97 TT |
521 | /* See prologue-value.h. */ |
522 | ||
7d30c22d | 523 | void |
f7b7ed97 TT |
524 | pv_area::scan (void (*func) (void *closure, |
525 | pv_t addr, | |
526 | CORE_ADDR size, | |
527 | pv_t value), | |
528 | void *closure) | |
7d30c22d | 529 | { |
f7b7ed97 | 530 | struct area_entry *e = m_entry; |
7d30c22d JB |
531 | pv_t addr; |
532 | ||
533 | addr.kind = pvk_register; | |
f7b7ed97 | 534 | addr.reg = m_base_reg; |
7d30c22d JB |
535 | |
536 | if (e) | |
537 | do | |
538 | { | |
539 | addr.k = e->offset; | |
540 | func (closure, addr, e->size, e->value); | |
541 | e = e->next; | |
542 | } | |
f7b7ed97 | 543 | while (e != m_entry); |
7d30c22d | 544 | } |