]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/prologue-value.c
Copyright updates for 2007.
[thirdparty/binutils-gdb.git] / gdb / prologue-value.c
CommitLineData
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
33pv_t
34pv_unknown (void)
35{
36 pv_t v = { pvk_unknown, 0, 0 };
37
38 return v;
39}
40
41
42pv_t
43pv_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
55pv_t
56pv_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. */
75static void
76constant_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
88pv_t
89pv_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
111pv_t
112pv_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
120pv_t
121pv_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
159pv_t
160pv_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
195int
196pv_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
215int
216pv_is_constant (pv_t a)
217{
218 return (a.kind == pvk_constant);
219}
220
221
222int
223pv_is_register (pv_t a, int r)
224{
225 return (a.kind == pvk_register
226 && a.reg == r);
227}
228
229
230int
231pv_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
239enum pv_boolean
240pv_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. */
288struct 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
306struct 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
321struct pv_area *
322make_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. */
340static void
341clear_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
363void
364free_pv_area (struct pv_area *area)
365{
366 clear_entries (area);
367 xfree (area);
368}
369
370
371static void
372do_free_pv_area_cleanup (void *arg)
373{
374 free_pv_area ((struct pv_area *) arg);
375}
376
377
378struct cleanup *
379make_cleanup_free_pv_area (struct pv_area *area)
380{
381 return make_cleanup (do_free_pv_area_cleanup, (void *) area);
382}
383
384
385int
386pv_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. */
408static struct area_entry *
409find_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. */
445static int
446overlaps (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
457void
458pv_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
518pv_t
519pv_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
541int
542pv_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
570void
571pv_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}