Make stap-probe.c:stap_parse_register_operand's "regname" an std::string
[external/binutils.git] / gdb / trad-frame.c
1 /* Traditional frame unwind support, for GDB the GNU Debugger.
2
3    Copyright (C) 2003-2019 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 #include "defs.h"
21 #include "frame.h"
22 #include "trad-frame.h"
23 #include "regcache.h"
24 #include "frame-unwind.h"
25 #include "target.h"
26 #include "value.h"
27
28 struct trad_frame_cache
29 {
30   struct frame_info *this_frame;
31   CORE_ADDR this_base;
32   struct trad_frame_saved_reg *prev_regs;
33   struct frame_id this_id;
34 };
35
36 struct trad_frame_cache *
37 trad_frame_cache_zalloc (struct frame_info *this_frame)
38 {
39   struct trad_frame_cache *this_trad_cache;
40
41   this_trad_cache = FRAME_OBSTACK_ZALLOC (struct trad_frame_cache);
42   this_trad_cache->prev_regs = trad_frame_alloc_saved_regs (this_frame);
43   this_trad_cache->this_frame = this_frame;
44   return this_trad_cache;
45 }
46
47 struct trad_frame_saved_reg *
48 trad_frame_alloc_saved_regs (struct gdbarch *gdbarch)
49 {
50   int regnum;
51   int numregs = gdbarch_num_cooked_regs (gdbarch);
52   struct trad_frame_saved_reg *this_saved_regs
53     = FRAME_OBSTACK_CALLOC (numregs, struct trad_frame_saved_reg);
54
55   for (regnum = 0; regnum < numregs; regnum++)
56     {
57       this_saved_regs[regnum].realreg = regnum;
58       this_saved_regs[regnum].addr = -1;
59     }      
60   return this_saved_regs;
61 }
62
63 /* A traditional frame is unwound by analysing the function prologue
64    and using the information gathered to track registers.  For
65    non-optimized frames, the technique is reliable (just need to check
66    for all potential instruction sequences).  */
67
68 struct trad_frame_saved_reg *
69 trad_frame_alloc_saved_regs (struct frame_info *this_frame)
70 {
71   struct gdbarch *gdbarch = get_frame_arch (this_frame);
72
73   return trad_frame_alloc_saved_regs (gdbarch);
74 }
75
76 enum { TF_REG_VALUE = -1, TF_REG_UNKNOWN = -2 };
77
78 int
79 trad_frame_value_p (struct trad_frame_saved_reg this_saved_regs[], int regnum)
80 {
81   return (this_saved_regs[regnum].realreg == TF_REG_VALUE);
82 }
83
84 int
85 trad_frame_addr_p (struct trad_frame_saved_reg this_saved_regs[], int regnum)
86 {
87   return (this_saved_regs[regnum].realreg >= 0
88           && this_saved_regs[regnum].addr != -1);
89 }
90
91 int
92 trad_frame_realreg_p (struct trad_frame_saved_reg this_saved_regs[],
93                       int regnum)
94 {
95   return (this_saved_regs[regnum].realreg >= 0
96           && this_saved_regs[regnum].addr == -1);
97 }
98
99 void
100 trad_frame_set_value (struct trad_frame_saved_reg this_saved_regs[],
101                       int regnum, LONGEST val)
102 {
103   /* Make the REALREG invalid, indicating that the ADDR contains the
104      register's value.  */
105   this_saved_regs[regnum].realreg = TF_REG_VALUE;
106   this_saved_regs[regnum].addr = val;
107 }
108
109 /* See trad-frame.h.  */
110
111 void
112 trad_frame_set_realreg (struct trad_frame_saved_reg this_saved_regs[],
113                         int regnum, int realreg)
114 {
115   this_saved_regs[regnum].realreg = realreg;
116   this_saved_regs[regnum].addr = -1;
117 }
118
119 /* See trad-frame.h.  */
120
121 void
122 trad_frame_set_addr (struct trad_frame_saved_reg this_saved_regs[],
123                      int regnum, CORE_ADDR addr)
124 {
125   this_saved_regs[regnum].realreg = regnum;
126   this_saved_regs[regnum].addr = addr;
127 }
128
129 void
130 trad_frame_set_reg_value (struct trad_frame_cache *this_trad_cache,
131                           int regnum, LONGEST val)
132 {
133   /* External interface for users of trad_frame_cache
134      (who cannot access the prev_regs object directly).  */
135   trad_frame_set_value (this_trad_cache->prev_regs, regnum, val);
136 }
137
138 void
139 trad_frame_set_reg_realreg (struct trad_frame_cache *this_trad_cache,
140                             int regnum, int realreg)
141 {
142   trad_frame_set_realreg (this_trad_cache->prev_regs, regnum, realreg);
143 }
144
145 void
146 trad_frame_set_reg_addr (struct trad_frame_cache *this_trad_cache,
147                          int regnum, CORE_ADDR addr)
148 {
149   trad_frame_set_addr (this_trad_cache->prev_regs, regnum, addr);
150 }
151
152 void
153 trad_frame_set_reg_regmap (struct trad_frame_cache *this_trad_cache,
154                            const struct regcache_map_entry *regmap,
155                            CORE_ADDR addr, size_t size)
156 {
157   struct gdbarch *gdbarch = get_frame_arch (this_trad_cache->this_frame);
158   int offs = 0, count;
159
160   for (; (count = regmap->count) != 0; regmap++)
161     {
162       int regno = regmap->regno;
163       int slot_size = regmap->size;
164
165       if (slot_size == 0 && regno != REGCACHE_MAP_SKIP)
166         slot_size = register_size (gdbarch, regno);
167
168       if (offs + slot_size > size)
169         break;
170
171       if (regno == REGCACHE_MAP_SKIP)
172         offs += count * slot_size;
173       else
174         for (; count--; regno++, offs += slot_size)
175           {
176             /* Mimic the semantics of regcache::transfer_regset if a
177                register slot's size does not match the size of a
178                register.
179
180                If a register slot is larger than a register, assume
181                the register's value is stored in the first N bytes of
182                the slot and ignore the remaining bytes.
183
184                If the register slot is smaller than the register,
185                assume that the slot contains the low N bytes of the
186                register's value.  Since trad_frame assumes that
187                registers stored by address are sized according to the
188                register, read the low N bytes and zero-extend them to
189                generate a register value.  */
190             if (slot_size >= register_size (gdbarch, regno))
191               trad_frame_set_reg_addr (this_trad_cache, regno, addr + offs);
192             else
193               {
194                 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
195                 gdb_byte buf[slot_size];
196
197                 if (target_read_memory (addr + offs, buf, sizeof buf) == 0)
198                   {
199                     LONGEST val
200                       = extract_unsigned_integer (buf, sizeof buf, byte_order);
201                     trad_frame_set_reg_value (this_trad_cache, regno, val);
202                   }
203               }
204           }
205     }
206 }
207
208 void
209 trad_frame_set_unknown (struct trad_frame_saved_reg this_saved_regs[],
210                         int regnum)
211 {
212   /* Make the REALREG invalid, indicating that the value is not known.  */
213   this_saved_regs[regnum].realreg = TF_REG_UNKNOWN;
214   this_saved_regs[regnum].addr = -1;
215 }
216
217 struct value *
218 trad_frame_get_prev_register (struct frame_info *this_frame,
219                               struct trad_frame_saved_reg this_saved_regs[],
220                               int regnum)
221 {
222   if (trad_frame_addr_p (this_saved_regs, regnum))
223     /* The register was saved in memory.  */
224     return frame_unwind_got_memory (this_frame, regnum,
225                                     this_saved_regs[regnum].addr);
226   else if (trad_frame_realreg_p (this_saved_regs, regnum))
227     return frame_unwind_got_register (this_frame, regnum,
228                                       this_saved_regs[regnum].realreg);
229   else if (trad_frame_value_p (this_saved_regs, regnum))
230     /* The register's value is available.  */
231     return frame_unwind_got_constant (this_frame, regnum,
232                                       this_saved_regs[regnum].addr);
233   else
234     return frame_unwind_got_optimized (this_frame, regnum);
235 }
236
237 struct value *
238 trad_frame_get_register (struct trad_frame_cache *this_trad_cache,
239                          struct frame_info *this_frame,
240                          int regnum)
241 {
242   return trad_frame_get_prev_register (this_frame, this_trad_cache->prev_regs,
243                                        regnum);
244 }
245
246 void
247 trad_frame_set_id (struct trad_frame_cache *this_trad_cache,
248                    struct frame_id this_id)
249 {
250   this_trad_cache->this_id = this_id;
251 }
252
253 void
254 trad_frame_get_id (struct trad_frame_cache *this_trad_cache,
255                    struct frame_id *this_id)
256 {
257   (*this_id) = this_trad_cache->this_id;
258 }
259
260 void
261 trad_frame_set_this_base (struct trad_frame_cache *this_trad_cache,
262                           CORE_ADDR this_base)
263 {
264   this_trad_cache->this_base = this_base;
265 }
266
267 CORE_ADDR
268 trad_frame_get_this_base (struct trad_frame_cache *this_trad_cache)
269 {
270   return this_trad_cache->this_base;
271 }