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