1 /* Prologue value handling for GDB.
2 Copyright 2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
4 This file is part of GDB.
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 3 of the License, or
9 (at your option) any later version.
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.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdb_string.h"
21 #include "gdb_assert.h"
22 #include "prologue-value.h"
31 pv_t v
= { pvk_unknown
, 0, 0 };
38 pv_constant (CORE_ADDR k
)
42 v
.kind
= pvk_constant
;
43 v
.reg
= -1; /* for debugging */
51 pv_register (int reg
, CORE_ADDR k
)
55 v
.kind
= pvk_register
;
64 /* Arithmetic operations. */
66 /* If one of *A and *B is a constant, and the other isn't, swap the
67 values as necessary to ensure that *B is the constant. This can
68 reduce the number of cases we need to analyze in the functions
71 constant_last (pv_t
*a
, pv_t
*b
)
73 if (a
->kind
== pvk_constant
74 && b
->kind
!= pvk_constant
)
84 pv_add (pv_t a
, pv_t b
)
86 constant_last (&a
, &b
);
88 /* We can add a constant to a register. */
89 if (a
.kind
== pvk_register
90 && b
.kind
== pvk_constant
)
91 return pv_register (a
.reg
, a
.k
+ b
.k
);
93 /* We can add a constant to another constant. */
94 else if (a
.kind
== pvk_constant
95 && b
.kind
== pvk_constant
)
96 return pv_constant (a
.k
+ b
.k
);
98 /* Anything else we don't know how to add. We don't have a
99 representation for, say, the sum of two registers, or a multiple
100 of a register's value (adding a register to itself). */
102 return pv_unknown ();
107 pv_add_constant (pv_t v
, CORE_ADDR k
)
109 /* Rather than thinking of all the cases we can and can't handle,
110 we'll just let pv_add take care of that for us. */
111 return pv_add (v
, pv_constant (k
));
116 pv_subtract (pv_t a
, pv_t b
)
118 /* This isn't quite the same as negating B and adding it to A, since
119 we don't have a representation for the negation of anything but a
120 constant. For example, we can't negate { pvk_register, R1, 10 },
121 but we do know that { pvk_register, R1, 10 } minus { pvk_register,
122 R1, 5 } is { pvk_constant, <ignored>, 5 }.
124 This means, for example, that we could subtract two stack
125 addresses; they're both relative to the original SP. Since the
126 frame pointer is set based on the SP, its value will be the
127 original SP plus some constant (probably zero), so we can use its
128 value just fine, too. */
130 constant_last (&a
, &b
);
132 /* We can subtract two constants. */
133 if (a
.kind
== pvk_constant
134 && b
.kind
== pvk_constant
)
135 return pv_constant (a
.k
- b
.k
);
137 /* We can subtract a constant from a register. */
138 else if (a
.kind
== pvk_register
139 && b
.kind
== pvk_constant
)
140 return pv_register (a
.reg
, a
.k
- b
.k
);
142 /* We can subtract a register from itself, yielding a constant. */
143 else if (a
.kind
== pvk_register
144 && b
.kind
== pvk_register
146 return pv_constant (a
.k
- b
.k
);
148 /* We don't know how to subtract anything else. */
150 return pv_unknown ();
155 pv_logical_and (pv_t a
, pv_t b
)
157 constant_last (&a
, &b
);
159 /* We can 'and' two constants. */
160 if (a
.kind
== pvk_constant
161 && b
.kind
== pvk_constant
)
162 return pv_constant (a
.k
& b
.k
);
164 /* We can 'and' anything with the constant zero. */
165 else if (b
.kind
== pvk_constant
167 return pv_constant (0);
169 /* We can 'and' anything with ~0. */
170 else if (b
.kind
== pvk_constant
171 && b
.k
== ~ (CORE_ADDR
) 0)
174 /* We can 'and' a register with itself. */
175 else if (a
.kind
== pvk_register
176 && b
.kind
== pvk_register
181 /* Otherwise, we don't know. */
183 return pv_unknown ();
188 /* Examining prologue values. */
191 pv_is_identical (pv_t a
, pv_t b
)
193 if (a
.kind
!= b
.kind
)
203 return (a
.reg
== b
.reg
&& a
.k
== b
.k
);
211 pv_is_constant (pv_t a
)
213 return (a
.kind
== pvk_constant
);
218 pv_is_register (pv_t a
, int r
)
220 return (a
.kind
== pvk_register
226 pv_is_register_k (pv_t a
, int r
, CORE_ADDR k
)
228 return (a
.kind
== pvk_register
235 pv_is_array_ref (pv_t addr
, CORE_ADDR size
,
236 pv_t array_addr
, CORE_ADDR array_len
,
240 /* Note that, since .k is a CORE_ADDR, and CORE_ADDR is unsigned, if
241 addr is *before* the start of the array, then this isn't going to
243 pv_t offset
= pv_subtract (addr
, array_addr
);
245 if (offset
.kind
== pvk_constant
)
247 /* This is a rather odd test. We want to know if the SIZE bytes
248 at ADDR don't overlap the array at all, so you'd expect it to
249 be an || expression: "if we're completely before || we're
250 completely after". But with unsigned arithmetic, things are
251 different: since it's a number circle, not a number line, the
252 right values for offset.k are actually one contiguous range. */
253 if (offset
.k
<= -size
254 && offset
.k
>= array_len
* elt_size
)
255 return pv_definite_no
;
256 else if (offset
.k
% elt_size
!= 0
261 *i
= offset
.k
/ elt_size
;
262 return pv_definite_yes
;
274 /* A particular value known to be stored in an area.
276 Entries form a ring, sorted by unsigned offset from the area's base
277 register's value. Since entries can straddle the wrap-around point,
278 unsigned offsets form a circle, not a number line, so the list
279 itself is structured the same way --- there is no inherent head.
280 The entry with the lowest offset simply follows the entry with the
281 highest offset. Entries may abut, but never overlap. The area's
282 'entry' pointer points to an arbitrary node in the ring. */
285 /* Links in the doubly-linked ring. */
286 struct area_entry
*prev
, *next
;
288 /* Offset of this entry's address from the value of the base
292 /* The size of this entry. Note that an entry may wrap around from
293 the end of the address space to the beginning. */
296 /* The value stored here. */
303 /* This area's base register. */
306 /* The mask to apply to addresses, to make the wrap-around happen at
310 /* An element of the doubly-linked ring of entries, or zero if we
312 struct area_entry
*entry
;
317 make_pv_area (int base_reg
)
319 struct pv_area
*a
= (struct pv_area
*) xmalloc (sizeof (*a
));
321 memset (a
, 0, sizeof (*a
));
323 a
->base_reg
= base_reg
;
326 /* Remember that shift amounts equal to the type's width are
328 a
->addr_mask
= ((((CORE_ADDR
) 1
329 << (gdbarch_addr_bit (current_gdbarch
) - 1)) - 1) << 1) | 1;
335 /* Delete all entries from AREA. */
337 clear_entries (struct pv_area
*area
)
339 struct area_entry
*e
= area
->entry
;
343 /* This needs to be a do-while loop, in order to actually
344 process the node being checked for in the terminating
348 struct area_entry
*next
= e
->next
;
352 while (e
!= area
->entry
);
360 free_pv_area (struct pv_area
*area
)
362 clear_entries (area
);
368 do_free_pv_area_cleanup (void *arg
)
370 free_pv_area ((struct pv_area
*) arg
);
375 make_cleanup_free_pv_area (struct pv_area
*area
)
377 return make_cleanup (do_free_pv_area_cleanup
, (void *) area
);
382 pv_area_store_would_trash (struct pv_area
*area
, pv_t addr
)
384 /* It may seem odd that pvk_constant appears here --- after all,
385 that's the case where we know the most about the address! But
386 pv_areas are always relative to a register, and we don't know the
387 value of the register, so we can't compare entry addresses to
389 return (addr
.kind
== pvk_unknown
390 || addr
.kind
== pvk_constant
391 || (addr
.kind
== pvk_register
&& addr
.reg
!= area
->base_reg
));
395 /* Return a pointer to the first entry we hit in AREA starting at
396 OFFSET and going forward.
398 This may return zero, if AREA has no entries.
400 And since the entries are a ring, this may return an entry that
401 entirely preceeds OFFSET. This is the correct behavior: depending
402 on the sizes involved, we could still overlap such an area, with
404 static struct area_entry
*
405 find_entry (struct pv_area
*area
, CORE_ADDR offset
)
407 struct area_entry
*e
= area
->entry
;
412 /* If the next entry would be better than the current one, then scan
413 forward. Since we use '<' in this loop, it always terminates.
415 Note that, even setting aside the addr_mask stuff, we must not
416 simplify this, in high school algebra fashion, to
417 (e->next->offset < e->offset), because of the way < interacts
418 with wrap-around. We have to subtract offset from both sides to
419 make sure both things we're comparing are on the same side of the
421 while (((e
->next
->offset
- offset
) & area
->addr_mask
)
422 < ((e
->offset
- offset
) & area
->addr_mask
))
425 /* If the previous entry would be better than the current one, then
427 while (((e
->prev
->offset
- offset
) & area
->addr_mask
)
428 < ((e
->offset
- offset
) & area
->addr_mask
))
431 /* In case there's some locality to the searches, set the area's
432 pointer to the entry we've found. */
439 /* Return non-zero if the SIZE bytes at OFFSET would overlap ENTRY;
440 return zero otherwise. AREA is the area to which ENTRY belongs. */
442 overlaps (struct pv_area
*area
,
443 struct area_entry
*entry
,
447 /* Think carefully about wrap-around before simplifying this. */
448 return (((entry
->offset
- offset
) & area
->addr_mask
) < size
449 || ((offset
- entry
->offset
) & area
->addr_mask
) < entry
->size
);
454 pv_area_store (struct pv_area
*area
,
459 /* Remove any (potentially) overlapping entries. */
460 if (pv_area_store_would_trash (area
, addr
))
461 clear_entries (area
);
464 CORE_ADDR offset
= addr
.k
;
465 struct area_entry
*e
= find_entry (area
, offset
);
467 /* Delete all entries that we would overlap. */
468 while (e
&& overlaps (area
, e
, offset
, size
))
470 struct area_entry
*next
= (e
->next
== e
) ? 0 : e
->next
;
471 e
->prev
->next
= e
->next
;
472 e
->next
->prev
= e
->prev
;
478 /* Move the area's pointer to the next remaining entry. This
479 will also zero the pointer if we've deleted all the entries. */
483 /* Now, there are no entries overlapping us, and area->entry is
484 either zero or pointing at the closest entry after us. We can
485 just insert ourselves before that.
487 But if we're storing an unknown value, don't bother --- that's
489 if (value
.kind
== pvk_unknown
)
493 CORE_ADDR offset
= addr
.k
;
494 struct area_entry
*e
= (struct area_entry
*) xmalloc (sizeof (*e
));
501 e
->prev
= area
->entry
->prev
;
502 e
->next
= area
->entry
;
503 e
->prev
->next
= e
->next
->prev
= e
;
507 e
->prev
= e
->next
= e
;
515 pv_area_fetch (struct pv_area
*area
, pv_t addr
, CORE_ADDR size
)
517 /* If we have no entries, or we can't decide how ADDR relates to the
518 entries we do have, then the value is unknown. */
520 || pv_area_store_would_trash (area
, addr
))
521 return pv_unknown ();
524 CORE_ADDR offset
= addr
.k
;
525 struct area_entry
*e
= find_entry (area
, offset
);
527 /* If this entry exactly matches what we're looking for, then
528 we're set. Otherwise, say it's unknown. */
529 if (e
->offset
== offset
&& e
->size
== size
)
532 return pv_unknown ();
538 pv_area_find_reg (struct pv_area
*area
,
539 struct gdbarch
*gdbarch
,
543 struct area_entry
*e
= area
->entry
;
548 if (e
->value
.kind
== pvk_register
549 && e
->value
.reg
== reg
551 && e
->size
== register_size (gdbarch
, reg
))
554 *offset_p
= e
->offset
;
560 while (e
!= area
->entry
);
567 pv_area_scan (struct pv_area
*area
,
568 void (*func
) (void *closure
,
574 struct area_entry
*e
= area
->entry
;
577 addr
.kind
= pvk_register
;
578 addr
.reg
= area
->base_reg
;
584 func (closure
, addr
, e
->size
, e
->value
);
587 while (e
!= area
->entry
);
This page took 0.046353 seconds and 4 git commands to generate.