GDB (xrefs)

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