1 /* Prologue value handling for GDB.
2 Copyright 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdb_string.h"
22 #include "gdb_assert.h"
23 #include "prologue-value.h"
32 pv_t v
= { pvk_unknown
, 0, 0 };
39 pv_constant (CORE_ADDR k
)
43 v
.kind
= pvk_constant
;
44 v
.reg
= -1; /* for debugging */
52 pv_register (int reg
, CORE_ADDR k
)
56 v
.kind
= pvk_register
;
65 /* Arithmetic operations. */
67 /* If one of *A and *B is a constant, and the other isn't, swap the
68 values as necessary to ensure that *B is the constant. This can
69 reduce the number of cases we need to analyze in the functions
72 constant_last (pv_t
*a
, pv_t
*b
)
74 if (a
->kind
== pvk_constant
75 && b
->kind
!= pvk_constant
)
85 pv_add (pv_t a
, pv_t b
)
87 constant_last (&a
, &b
);
89 /* We can add a constant to a register. */
90 if (a
.kind
== pvk_register
91 && b
.kind
== pvk_constant
)
92 return pv_register (a
.reg
, a
.k
+ b
.k
);
94 /* We can add a constant to another constant. */
95 else if (a
.kind
== pvk_constant
96 && b
.kind
== pvk_constant
)
97 return pv_constant (a
.k
+ b
.k
);
99 /* Anything else we don't know how to add. We don't have a
100 representation for, say, the sum of two registers, or a multiple
101 of a register's value (adding a register to itself). */
103 return pv_unknown ();
108 pv_add_constant (pv_t v
, CORE_ADDR k
)
110 /* Rather than thinking of all the cases we can and can't handle,
111 we'll just let pv_add take care of that for us. */
112 return pv_add (v
, pv_constant (k
));
117 pv_subtract (pv_t a
, pv_t b
)
119 /* This isn't quite the same as negating B and adding it to A, since
120 we don't have a representation for the negation of anything but a
121 constant. For example, we can't negate { pvk_register, R1, 10 },
122 but we do know that { pvk_register, R1, 10 } minus { pvk_register,
123 R1, 5 } is { pvk_constant, <ignored>, 5 }.
125 This means, for example, that we could subtract two stack
126 addresses; they're both relative to the original SP. Since the
127 frame pointer is set based on the SP, its value will be the
128 original SP plus some constant (probably zero), so we can use its
129 value just fine, too. */
131 constant_last (&a
, &b
);
133 /* We can subtract two constants. */
134 if (a
.kind
== pvk_constant
135 && b
.kind
== pvk_constant
)
136 return pv_constant (a
.k
- b
.k
);
138 /* We can subtract a constant from a register. */
139 else if (a
.kind
== pvk_register
140 && b
.kind
== pvk_constant
)
141 return pv_register (a
.reg
, a
.k
- b
.k
);
143 /* We can subtract a register from itself, yielding a constant. */
144 else if (a
.kind
== pvk_register
145 && b
.kind
== pvk_register
147 return pv_constant (a
.k
- b
.k
);
149 /* We don't know how to subtract anything else. */
151 return pv_unknown ();
156 pv_logical_and (pv_t a
, pv_t b
)
158 constant_last (&a
, &b
);
160 /* We can 'and' two constants. */
161 if (a
.kind
== pvk_constant
162 && b
.kind
== pvk_constant
)
163 return pv_constant (a
.k
& b
.k
);
165 /* We can 'and' anything with the constant zero. */
166 else if (b
.kind
== pvk_constant
168 return pv_constant (0);
170 /* We can 'and' anything with ~0. */
171 else if (b
.kind
== pvk_constant
172 && b
.k
== ~ (CORE_ADDR
) 0)
175 /* We can 'and' a register with itself. */
176 else if (a
.kind
== pvk_register
177 && b
.kind
== pvk_register
182 /* Otherwise, we don't know. */
184 return pv_unknown ();
189 /* Examining prologue values. */
192 pv_is_identical (pv_t a
, pv_t b
)
194 if (a
.kind
!= b
.kind
)
204 return (a
.reg
== b
.reg
&& a
.k
== b
.k
);
206 gdb_assert_not_reached ("unexpected prologue value kind");
212 pv_is_constant (pv_t a
)
214 return (a
.kind
== pvk_constant
);
219 pv_is_register (pv_t a
, int r
)
221 return (a
.kind
== pvk_register
227 pv_is_register_k (pv_t a
, int r
, CORE_ADDR k
)
229 return (a
.kind
== pvk_register
236 pv_is_array_ref (pv_t addr
, CORE_ADDR size
,
237 pv_t array_addr
, CORE_ADDR array_len
,
241 /* Note that, since .k is a CORE_ADDR, and CORE_ADDR is unsigned, if
242 addr is *before* the start of the array, then this isn't going to
244 pv_t offset
= pv_subtract (addr
, array_addr
);
246 if (offset
.kind
== pvk_constant
)
248 /* This is a rather odd test. We want to know if the SIZE bytes
249 at ADDR don't overlap the array at all, so you'd expect it to
250 be an || expression: "if we're completely before || we're
251 completely after". But with unsigned arithmetic, things are
252 different: since it's a number circle, not a number line, the
253 right values for offset.k are actually one contiguous range. */
254 if (offset
.k
<= -size
255 && offset
.k
>= array_len
* elt_size
)
256 return pv_definite_no
;
257 else if (offset
.k
% elt_size
!= 0
262 *i
= offset
.k
/ elt_size
;
263 return pv_definite_yes
;
275 /* A particular value known to be stored in an area.
277 Entries form a ring, sorted by unsigned offset from the area's base
278 register's value. Since entries can straddle the wrap-around point,
279 unsigned offsets form a circle, not a number line, so the list
280 itself is structured the same way --- there is no inherent head.
281 The entry with the lowest offset simply follows the entry with the
282 highest offset. Entries may abut, but never overlap. The area's
283 'entry' pointer points to an arbitrary node in the ring. */
286 /* Links in the doubly-linked ring. */
287 struct area_entry
*prev
, *next
;
289 /* Offset of this entry's address from the value of the base
293 /* The size of this entry. Note that an entry may wrap around from
294 the end of the address space to the beginning. */
297 /* The value stored here. */
304 /* This area's base register. */
307 /* The mask to apply to addresses, to make the wrap-around happen at
311 /* An element of the doubly-linked ring of entries, or zero if we
313 struct area_entry
*entry
;
318 make_pv_area (int base_reg
, int addr_bit
)
320 struct pv_area
*a
= (struct pv_area
*) xmalloc (sizeof (*a
));
322 memset (a
, 0, sizeof (*a
));
324 a
->base_reg
= base_reg
;
327 /* Remember that shift amounts equal to the type's width are
329 a
->addr_mask
= ((((CORE_ADDR
) 1 << (addr_bit
- 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
;
353 while (e
!= area
->entry
);
361 free_pv_area (struct pv_area
*area
)
363 clear_entries (area
);
369 do_free_pv_area_cleanup (void *arg
)
371 free_pv_area ((struct pv_area
*) arg
);
376 make_cleanup_free_pv_area (struct pv_area
*area
)
378 return make_cleanup (do_free_pv_area_cleanup
, (void *) area
);
383 pv_area_store_would_trash (struct pv_area
*area
, pv_t addr
)
385 /* It may seem odd that pvk_constant appears here --- after all,
386 that's the case where we know the most about the address! But
387 pv_areas are always relative to a register, and we don't know the
388 value of the register, so we can't compare entry addresses to
390 return (addr
.kind
== pvk_unknown
391 || addr
.kind
== pvk_constant
392 || (addr
.kind
== pvk_register
&& addr
.reg
!= area
->base_reg
));
396 /* Return a pointer to the first entry we hit in AREA starting at
397 OFFSET and going forward.
399 This may return zero, if AREA has no entries.
401 And since the entries are a ring, this may return an entry that
402 entirely preceeds OFFSET. This is the correct behavior: depending
403 on the sizes involved, we could still overlap such an area, with
405 static struct area_entry
*
406 find_entry (struct pv_area
*area
, CORE_ADDR offset
)
408 struct area_entry
*e
= area
->entry
;
413 /* If the next entry would be better than the current one, then scan
414 forward. Since we use '<' in this loop, it always terminates.
416 Note that, even setting aside the addr_mask stuff, we must not
417 simplify this, in high school algebra fashion, to
418 (e->next->offset < e->offset), because of the way < interacts
419 with wrap-around. We have to subtract offset from both sides to
420 make sure both things we're comparing are on the same side of the
422 while (((e
->next
->offset
- offset
) & area
->addr_mask
)
423 < ((e
->offset
- offset
) & area
->addr_mask
))
426 /* If the previous entry would be better than the current one, then
428 while (((e
->prev
->offset
- offset
) & area
->addr_mask
)
429 < ((e
->offset
- offset
) & area
->addr_mask
))
432 /* In case there's some locality to the searches, set the area's
433 pointer to the entry we've found. */
440 /* Return non-zero if the SIZE bytes at OFFSET would overlap ENTRY;
441 return zero otherwise. AREA is the area to which ENTRY belongs. */
443 overlaps (struct pv_area
*area
,
444 struct area_entry
*entry
,
448 /* Think carefully about wrap-around before simplifying this. */
449 return (((entry
->offset
- offset
) & area
->addr_mask
) < size
450 || ((offset
- entry
->offset
) & area
->addr_mask
) < entry
->size
);
455 pv_area_store (struct pv_area
*area
,
460 /* Remove any (potentially) overlapping entries. */
461 if (pv_area_store_would_trash (area
, addr
))
462 clear_entries (area
);
465 CORE_ADDR offset
= addr
.k
;
466 struct area_entry
*e
= find_entry (area
, offset
);
468 /* Delete all entries that we would overlap. */
469 while (e
&& overlaps (area
, e
, offset
, size
))
471 struct area_entry
*next
= (e
->next
== e
) ? 0 : e
->next
;
473 e
->prev
->next
= e
->next
;
474 e
->next
->prev
= e
->prev
;
480 /* Move the area's pointer to the next remaining entry. This
481 will also zero the pointer if we've deleted all the entries. */
485 /* Now, there are no entries overlapping us, and area->entry is
486 either zero or pointing at the closest entry after us. We can
487 just insert ourselves before that.
489 But if we're storing an unknown value, don't bother --- that's
491 if (value
.kind
== pvk_unknown
)
495 CORE_ADDR offset
= addr
.k
;
496 struct area_entry
*e
= (struct area_entry
*) xmalloc (sizeof (*e
));
504 e
->prev
= area
->entry
->prev
;
505 e
->next
= area
->entry
;
506 e
->prev
->next
= e
->next
->prev
= e
;
510 e
->prev
= e
->next
= e
;
518 pv_area_fetch (struct pv_area
*area
, pv_t addr
, CORE_ADDR size
)
520 /* If we have no entries, or we can't decide how ADDR relates to the
521 entries we do have, then the value is unknown. */
523 || pv_area_store_would_trash (area
, addr
))
524 return pv_unknown ();
527 CORE_ADDR offset
= addr
.k
;
528 struct area_entry
*e
= find_entry (area
, offset
);
530 /* If this entry exactly matches what we're looking for, then
531 we're set. Otherwise, say it's unknown. */
532 if (e
->offset
== offset
&& e
->size
== size
)
535 return pv_unknown ();
541 pv_area_find_reg (struct pv_area
*area
,
542 struct gdbarch
*gdbarch
,
546 struct area_entry
*e
= area
->entry
;
551 if (e
->value
.kind
== pvk_register
552 && e
->value
.reg
== reg
554 && e
->size
== register_size (gdbarch
, reg
))
557 *offset_p
= e
->offset
;
563 while (e
!= area
->entry
);
570 pv_area_scan (struct pv_area
*area
,
571 void (*func
) (void *closure
,
577 struct area_entry
*e
= area
->entry
;
580 addr
.kind
= pvk_register
;
581 addr
.reg
= area
->base_reg
;
587 func (closure
, addr
, e
->size
, e
->value
);
590 while (e
!= area
->entry
);
This page took 0.040659 seconds and 4 git commands to generate.