contrib/gdb-7/gdb/prologue-value.h

   1 /* Interface to prologue value handling for GDB.
   2    Copyright 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   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.
  11
  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.
  16
  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/>.  */
  19
  20 #ifndef PROLOGUE_VALUE_H
  21 #define PROLOGUE_VALUE_H
  22
  23 /* When we analyze a prologue, we're really doing 'abstract
  24    interpretation' or 'pseudo-evaluation': running the function's code
  25    in simulation, but using conservative approximations of the values
  26    it would have when it actually runs.  For example, if our function
  27    starts with the instruction:
  28
  29       addi r1, 42     # add 42 to r1
  30
  31    we don't know exactly what value will be in r1 after executing this
  32    instruction, but we do know it'll be 42 greater than its original
  33    value.
  34
  35    If we then see an instruction like:
  36
  37       addi r1, 22     # add 22 to r1
  38
  39    we still don't know what r1's value is, but again, we can say it is
  40    now 64 greater than its original value.
  41
  42    If the next instruction were:
  43
  44       mov r2, r1      # set r2 to r1's value
  45
  46    then we can say that r2's value is now the original value of r1
  47    plus 64.
  48
  49    It's common for prologues to save registers on the stack, so we'll
  50    need to track the values of stack frame slots, as well as the
  51    registers.  So after an instruction like this:
  52
  53       mov (fp+4), r2
  54
  55    then we'd know that the stack slot four bytes above the frame
  56    pointer holds the original value of r1 plus 64.
  57
  58    And so on.
  59
  60    Of course, this can only go so far before it gets unreasonable.  If
  61    we wanted to be able to say anything about the value of r1 after
  62    the instruction:
  63
  64       xor r1, r3      # exclusive-or r1 and r3, place result in r1
  65
  66    then things would get pretty complex.  But remember, we're just
  67    doing a conservative approximation; if exclusive-or instructions
  68    aren't relevant to prologues, we can just say r1's value is now
  69    'unknown'.  We can ignore things that are too complex, if that loss
  70    of information is acceptable for our application.
  71
  72    So when I say "conservative approximation" here, what I mean is an
  73    approximation that is either accurate, or marked "unknown", but
  74    never inaccurate.
  75
  76    Once you've reached the current PC, or an instruction that you
  77    don't know how to simulate, you stop.  Now you can examine the
  78    state of the registers and stack slots you've kept track of.
  79
  80    - To see how large your stack frame is, just check the value of the
  81      stack pointer register; if it's the original value of the SP
  82      minus a constant, then that constant is the stack frame's size.
  83      If the SP's value has been marked as 'unknown', then that means
  84      the prologue has done something too complex for us to track, and
  85      we don't know the frame size.
  86
  87    - To see where we've saved the previous frame's registers, we just
  88      search the values we've tracked --- stack slots, usually, but
  89      registers, too, if you want --- for something equal to the
  90      register's original value.  If the ABI suggests a standard place
  91      to save a given register, then we can check there first, but
  92      really, anything that will get us back the original value will
  93      probably work.
  94
  95    Sure, this takes some work.  But prologue analyzers aren't
  96    quick-and-simple pattern patching to recognize a few fixed prologue
  97    forms any more; they're big, hairy functions.  Along with inferior
  98    function calls, prologue analysis accounts for a substantial
  99    portion of the time needed to stabilize a GDB port.  So I think
 100    it's worthwhile to look for an approach that will be easier to
 101    understand and maintain.  In the approach used here:
 102
 103    - It's easier to see that the analyzer is correct: you just see
 104      whether the analyzer properly (albiet conservatively) simulates
 105      the effect of each instruction.
 106
 107    - It's easier to extend the analyzer: you can add support for new
 108      instructions, and know that you haven't broken anything that
 109      wasn't already broken before.
 110
 111    - It's orthogonal: to gather new information, you don't need to
 112      complicate the code for each instruction.  As long as your domain
 113      of conservative values is already detailed enough to tell you
 114      what you need, then all the existing instruction simulations are
 115      already gathering the right data for you.
 116
 117    A 'struct prologue_value' is a conservative approximation of the
 118    real value the register or stack slot will have.  */
 119
 120 struct prologue_value {
 121
 122   /* What sort of value is this?  This determines the interpretation
 123      of subsequent fields.  */
 124   enum {
 125
 126     /* We don't know anything about the value.  This is also used for
 127        values we could have kept track of, when doing so would have
 128        been too complex and we don't want to bother.  The bottom of
 129        our lattice.  */
 130     pvk_unknown,
 131
 132     /* A known constant.  K is its value.  */
 133     pvk_constant,
 134
 135     /* The value that register REG originally had *UPON ENTRY TO THE
 136        FUNCTION*, plus K.  If K is zero, this means, obviously, just
 137        the value REG had upon entry to the function.  REG is a GDB
 138        register number.  Before we start interpreting, we initialize
 139        every register R to { pvk_register, R, 0 }.  */
 140     pvk_register,
 141
 142   } kind;
 143
 144   /* The meanings of the following fields depend on 'kind'; see the
 145      comments for the specific 'kind' values.  */
 146   int reg;
 147   CORE_ADDR k;
 148 };
 149
 150 typedef struct prologue_value pv_t;
 151
 152
 153 /* Return the unknown prologue value --- { pvk_unknown, ?, ? }.  */
 154 pv_t pv_unknown (void);
 155
 156 /* Return the prologue value representing the constant K.  */
 157 pv_t pv_constant (CORE_ADDR k);
 158
 159 /* Return the prologue value representing the original value of
 160    register REG, plus the constant K.  */
 161 pv_t pv_register (int reg, CORE_ADDR k);
 162
 163
 164 /* Return conservative approximations of the results of the following
 165    operations.  */
 166 pv_t pv_add (pv_t a, pv_t b);               /* a + b */
 167 pv_t pv_add_constant (pv_t v, CORE_ADDR k); /* a + k */
 168 pv_t pv_subtract (pv_t a, pv_t b);          /* a - b */
 169 pv_t pv_logical_and (pv_t a, pv_t b);       /* a & b */
 170
 171
 172 /* Return non-zero iff A and B are identical expressions.
 173
 174    This is not the same as asking if the two values are equal; the
 175    result of such a comparison would have to be a pv_boolean, and
 176    asking whether two 'unknown' values were equal would give you
 177    pv_maybe.  Same for comparing, say, { pvk_register, R1, 0 } and {
 178    pvk_register, R2, 0}.
 179
 180    Instead, this function asks whether the two representations are the
 181    same.  */
 182 int pv_is_identical (pv_t a, pv_t b);
 183
 184
 185 /* Return non-zero if A is known to be a constant.  */
 186 int pv_is_constant (pv_t a);
 187
 188 /* Return non-zero if A is the original value of register number R
 189    plus some constant, zero otherwise.  */
 190 int pv_is_register (pv_t a, int r);
 191
 192
 193 /* Return non-zero if A is the original value of register R plus the
 194    constant K.  */
 195 int pv_is_register_k (pv_t a, int r, CORE_ADDR k);
 196
 197 /* A conservative boolean type, including "maybe", when we can't
 198    figure out whether something is true or not.  */
 199 enum pv_boolean {
 200   pv_maybe,
 201   pv_definite_yes,
 202   pv_definite_no,
 203 };
 204
 205
 206 /* Decide whether a reference to SIZE bytes at ADDR refers exactly to
 207    an element of an array.  The array starts at ARRAY_ADDR, and has
 208    ARRAY_LEN values of ELT_SIZE bytes each.  If ADDR definitely does
 209    refer to an array element, set *I to the index of the referenced
 210    element in the array, and return pv_definite_yes.  If it definitely
 211    doesn't, return pv_definite_no.  If we can't tell, return pv_maybe.
 212
 213    If the reference does touch the array, but doesn't fall exactly on
 214    an element boundary, or doesn't refer to the whole element, return
 215    pv_maybe.  */
 216 enum pv_boolean pv_is_array_ref (pv_t addr, CORE_ADDR size,
 217                                  pv_t array_addr, CORE_ADDR array_len,
 218                                  CORE_ADDR elt_size,
 219                                  int *i);
 220
 221
 222 /* A 'struct pv_area' keeps track of values stored in a particular
 223    region of memory.  */
 224 struct pv_area;
 225
 226 /* Create a new area, tracking stores relative to the original value
 227    of BASE_REG.  If BASE_REG is SP, then this effectively records the
 228    contents of the stack frame: the original value of the SP is the
 229    frame's CFA, or some constant offset from it.
 230
 231    Stores to constant addresses, unknown addresses, or to addresses
 232    relative to registers other than BASE_REG will trash this area; see
 233    pv_area_store_would_trash.
 234
 235    To check whether a pointer refers to this area, only the low
 236    ADDR_BIT bits will be compared.  */
 237 struct pv_area *make_pv_area (int base_reg, int addr_bit);
 238
 239 /* Free AREA.  */
 240 void free_pv_area (struct pv_area *area);
 241
 242
 243 /* Register a cleanup to free AREA.  */
 244 struct cleanup *make_cleanup_free_pv_area (struct pv_area *area);
 245
 246
 247 /* Store the SIZE-byte value VALUE at ADDR in AREA.
 248
 249    If ADDR is not relative to the same base register we used in
 250    creating AREA, then we can't tell which values here the stored
 251    value might overlap, and we'll have to mark everything as
 252    unknown.  */
 253 void pv_area_store (struct pv_area *area,
 254                     pv_t addr,
 255                     CORE_ADDR size,
 256                     pv_t value);
 257
 258 /* Return the SIZE-byte value at ADDR in AREA.  This may return
 259    pv_unknown ().  */
 260 pv_t pv_area_fetch (struct pv_area *area, pv_t addr, CORE_ADDR size);
 261
 262 /* Return true if storing to address ADDR in AREA would force us to
 263    mark the contents of the entire area as unknown.  This could happen
 264    if, say, ADDR is unknown, since we could be storing anywhere.  Or,
 265    it could happen if ADDR is relative to a different register than
 266    the other stores base register, since we don't know the relative
 267    values of the two registers.
 268
 269    If you've reached such a store, it may be better to simply stop the
 270    prologue analysis, and return the information you've gathered,
 271    instead of losing all that information, most of which is probably
 272    okay.  */
 273 int pv_area_store_would_trash (struct pv_area *area, pv_t addr);
 274
 275
 276 /* Search AREA for the original value of REGISTER.  If we can't find
 277    it, return zero; if we can find it, return a non-zero value, and if
 278    OFFSET_P is non-zero, set *OFFSET_P to the register's offset within
 279    AREA.  GDBARCH is the architecture of which REGISTER is a member.
 280
 281    In the worst case, this takes time proportional to the number of
 282    items stored in AREA.  If you plan to gather a lot of information
 283    about registers saved in AREA, consider calling pv_area_scan
 284    instead, and collecting all your information in one pass.  */
 285 int pv_area_find_reg (struct pv_area *area,
 286                       struct gdbarch *gdbarch,
 287                       int reg,
 288                       CORE_ADDR *offset_p);
 289
 290
 291 /* For every part of AREA whose value we know, apply FUNC to CLOSURE,
 292    the value's address, its size, and the value itself.  */
 293 void pv_area_scan (struct pv_area *area,
 294                    void (*func) (void *closure,
 295                                  pv_t addr,
 296                                  CORE_ADDR size,
 297                                  pv_t value),
 298                    void *closure);
 299
 300
 301 #endif /* PROLOGUE_VALUE_H */