1 /* Prologue value handling for GDB.
2 Copyright 2003, 2004, 2005, 2007 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 2 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, write to:
19 Free Software Foundation, Inc.
20 51 Franklin St - Fifth Floor
25 #include "gdb_string.h"
26 #include "gdb_assert.h"
27 #include "prologue-value.h"
36 pv_t v
= { pvk_unknown
, 0, 0 };
43 pv_constant (CORE_ADDR k
)
47 v
.kind
= pvk_constant
;
48 v
.reg
= -1; /* for debugging */
56 pv_register (int reg
, CORE_ADDR k
)
60 v
.kind
= pvk_register
;
69 /* Arithmetic operations. */
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
76 constant_last (pv_t
*a
, pv_t
*b
)
78 if (a
->kind
== pvk_constant
79 && b
->kind
!= pvk_constant
)
89 pv_add (pv_t a
, pv_t b
)
91 constant_last (&a
, &b
);
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
);
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
);
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). */
107 return pv_unknown ();
112 pv_add_constant (pv_t v
, CORE_ADDR k
)
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
));
121 pv_subtract (pv_t a
, pv_t b
)
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 }.
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. */
135 constant_last (&a
, &b
);
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
);
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
);
147 /* We can subtract a register from itself, yielding a constant. */
148 else if (a
.kind
== pvk_register
149 && b
.kind
== pvk_register
151 return pv_constant (a
.k
- b
.k
);
153 /* We don't know how to subtract anything else. */
155 return pv_unknown ();
160 pv_logical_and (pv_t a
, pv_t b
)
162 constant_last (&a
, &b
);
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
);
169 /* We can 'and' anything with the constant zero. */
170 else if (b
.kind
== pvk_constant
172 return pv_constant (0);
174 /* We can 'and' anything with ~0. */
175 else if (b
.kind
== pvk_constant
176 && b
.k
== ~ (CORE_ADDR
) 0)
179 /* We can 'and' a register with itself. */
180 else if (a
.kind
== pvk_register
181 && b
.kind
== pvk_register
186 /* Otherwise, we don't know. */
188 return pv_unknown ();
193 /* Examining prologue values. */
196 pv_is_identical (pv_t a
, pv_t b
)
198 if (a
.kind
!= b
.kind
)
208 return (a
.reg
== b
.reg
&& a
.k
== b
.k
);
216 pv_is_constant (pv_t a
)
218 return (a
.kind
== pvk_constant
);
223 pv_is_register (pv_t a
, int r
)
225 return (a
.kind
== pvk_register
231 pv_is_register_k (pv_t a
, int r
, CORE_ADDR k
)
233 return (a
.kind
== pvk_register
240 pv_is_array_ref (pv_t addr
, CORE_ADDR size
,
241 pv_t array_addr
, CORE_ADDR array_len
,
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
248 pv_t offset
= pv_subtract (addr
, array_addr
);
250 if (offset
.kind
== pvk_constant
)
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
266 *i
= offset
.k
/ elt_size
;
267 return pv_definite_yes
;
279 /* A particular value known to be stored in an area.
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. */
290 /* Links in the doubly-linked ring. */
291 struct area_entry
*prev
, *next
;
293 /* Offset of this entry's address from the value of the base
297 /* The size of this entry. Note that an entry may wrap around from
298 the end of the address space to the beginning. */
301 /* The value stored here. */
308 /* This area's base register. */
311 /* The mask to apply to addresses, to make the wrap-around happen at
315 /* An element of the doubly-linked ring of entries, or zero if we
317 struct area_entry
*entry
;
322 make_pv_area (int base_reg
)
324 struct pv_area
*a
= (struct pv_area
*) xmalloc (sizeof (*a
));
326 memset (a
, 0, sizeof (*a
));
328 a
->base_reg
= base_reg
;
331 /* Remember that shift amounts equal to the type's width are
333 a
->addr_mask
= ((((CORE_ADDR
) 1 << (TARGET_ADDR_BIT
- 1)) - 1) << 1) | 1;
339 /* Delete all entries from AREA. */
341 clear_entries (struct pv_area
*area
)
343 struct area_entry
*e
= area
->entry
;
347 /* This needs to be a do-while loop, in order to actually
348 process the node being checked for in the terminating
352 struct area_entry
*next
= e
->next
;
356 while (e
!= area
->entry
);
364 free_pv_area (struct pv_area
*area
)
366 clear_entries (area
);
372 do_free_pv_area_cleanup (void *arg
)
374 free_pv_area ((struct pv_area
*) arg
);
379 make_cleanup_free_pv_area (struct pv_area
*area
)
381 return make_cleanup (do_free_pv_area_cleanup
, (void *) area
);
386 pv_area_store_would_trash (struct pv_area
*area
, pv_t addr
)
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
393 return (addr
.kind
== pvk_unknown
394 || addr
.kind
== pvk_constant
395 || (addr
.kind
== pvk_register
&& addr
.reg
!= area
->base_reg
));
399 /* Return a pointer to the first entry we hit in AREA starting at
400 OFFSET and going forward.
402 This may return zero, if AREA has no entries.
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
408 static struct area_entry
*
409 find_entry (struct pv_area
*area
, CORE_ADDR offset
)
411 struct area_entry
*e
= area
->entry
;
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.
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
425 while (((e
->next
->offset
- offset
) & area
->addr_mask
)
426 < ((e
->offset
- offset
) & area
->addr_mask
))
429 /* If the previous entry would be better than the current one, then
431 while (((e
->prev
->offset
- offset
) & area
->addr_mask
)
432 < ((e
->offset
- offset
) & area
->addr_mask
))
435 /* In case there's some locality to the searches, set the area's
436 pointer to the entry we've found. */
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. */
446 overlaps (struct pv_area
*area
,
447 struct area_entry
*entry
,
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
);
458 pv_area_store (struct pv_area
*area
,
463 /* Remove any (potentially) overlapping entries. */
464 if (pv_area_store_would_trash (area
, addr
))
465 clear_entries (area
);
468 CORE_ADDR offset
= addr
.k
;
469 struct area_entry
*e
= find_entry (area
, offset
);
471 /* Delete all entries that we would overlap. */
472 while (e
&& overlaps (area
, e
, offset
, size
))
474 struct area_entry
*next
= (e
->next
== e
) ? 0 : e
->next
;
475 e
->prev
->next
= e
->next
;
476 e
->next
->prev
= e
->prev
;
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. */
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.
491 But if we're storing an unknown value, don't bother --- that's
493 if (value
.kind
== pvk_unknown
)
497 CORE_ADDR offset
= addr
.k
;
498 struct area_entry
*e
= (struct area_entry
*) xmalloc (sizeof (*e
));
505 e
->prev
= area
->entry
->prev
;
506 e
->next
= area
->entry
;
507 e
->prev
->next
= e
->next
->prev
= e
;
511 e
->prev
= e
->next
= e
;
519 pv_area_fetch (struct pv_area
*area
, pv_t addr
, CORE_ADDR size
)
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. */
524 || pv_area_store_would_trash (area
, addr
))
525 return pv_unknown ();
528 CORE_ADDR offset
= addr
.k
;
529 struct area_entry
*e
= find_entry (area
, offset
);
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
)
536 return pv_unknown ();
542 pv_area_find_reg (struct pv_area
*area
,
543 struct gdbarch
*gdbarch
,
547 struct area_entry
*e
= area
->entry
;
552 if (e
->value
.kind
== pvk_register
553 && e
->value
.reg
== reg
555 && e
->size
== register_size (gdbarch
, reg
))
558 *offset_p
= e
->offset
;
564 while (e
!= area
->entry
);
571 pv_area_scan (struct pv_area
*area
,
572 void (*func
) (void *closure
,
578 struct area_entry
*e
= area
->entry
;
581 addr
.kind
= pvk_register
;
582 addr
.reg
= area
->base_reg
;
588 func (closure
, addr
, e
->size
, e
->value
);
591 while (e
!= area
->entry
);
This page took 0.039965 seconds and 4 git commands to generate.