* emultempl/elf32.em (gld${EMULATION_NAME}_get_script): Add combreloc
[deliverable/binutils-gdb.git] / gdb / dwarf2loc.c
1 /* DWARF 2 location expression support for GDB.
2 Copyright 2003 Free Software Foundation, Inc.
3 Contributed by Daniel Jacobowitz, MontaVista Software, 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 2 of the License, or (at
10 your option) any later version.
11
12 This program is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 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, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 #include "defs.h"
23 #include "ui-out.h"
24 #include "value.h"
25 #include "frame.h"
26 #include "gdbcore.h"
27 #include "target.h"
28 #include "inferior.h"
29
30 #include "elf/dwarf2.h"
31 #include "dwarf2expr.h"
32 #include "dwarf2loc.h"
33
34 #include "gdb_string.h"
35
36 #ifndef DWARF2_REG_TO_REGNUM
37 #define DWARF2_REG_TO_REGNUM(REG) (REG)
38 #endif
39
40 /* This is the baton used when performing dwarf2 expression
41 evaluation. */
42 struct dwarf_expr_baton
43 {
44 struct frame_info *frame;
45 struct objfile *objfile;
46 };
47
48 /* Helper functions for dwarf2_evaluate_loc_desc. */
49
50 /* Using the frame specified in BATON, read register REGNUM. The lval
51 type will be returned in LVALP, and for lval_memory the register
52 save address will be returned in ADDRP. */
53 static CORE_ADDR
54 dwarf_expr_read_reg (void *baton, int regnum, enum lval_type *lvalp,
55 CORE_ADDR *addrp)
56 {
57 CORE_ADDR result;
58 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
59 char *buf = (char *) alloca (MAX_REGISTER_RAW_SIZE);
60 int optimized, realnum;
61
62 frame_register (debaton->frame, DWARF2_REG_TO_REGNUM (regnum),
63 &optimized, lvalp, addrp, &realnum, buf);
64 result = extract_address (buf, REGISTER_RAW_SIZE (regnum));
65
66 return result;
67 }
68
69 /* Read memory at ADDR (length LEN) into BUF. */
70
71 static void
72 dwarf_expr_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
73 {
74 read_memory (addr, buf, len);
75 }
76
77 /* Using the frame specified in BATON, find the location expression
78 describing the frame base. Return a pointer to it in START and
79 its length in LENGTH. */
80 static void
81 dwarf_expr_frame_base (void *baton, unsigned char **start, size_t * length)
82 {
83 struct symbol *framefunc;
84 struct dwarf2_locexpr_baton *symbaton;
85 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
86 framefunc = get_frame_function (debaton->frame);
87 symbaton = SYMBOL_LOCATION_BATON (framefunc);
88 *start = symbaton->data;
89 *length = symbaton->size;
90 }
91
92 /* Using the objfile specified in BATON, find the address for the
93 current thread's thread-local storage with offset OFFSET. */
94 static CORE_ADDR
95 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
96 {
97 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
98 CORE_ADDR addr;
99
100 if (target_get_thread_local_address_p ())
101 addr = target_get_thread_local_address (inferior_ptid,
102 debaton->objfile,
103 offset);
104 else
105 error ("Cannot find thread-local variables on this target");
106
107 return addr;
108 }
109
110 /* Evaluate a location description, starting at DATA and with length
111 SIZE, to find the current location of variable VAR in the context
112 of FRAME. */
113 static struct value *
114 dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
115 unsigned char *data, unsigned short size,
116 struct objfile *objfile)
117 {
118 CORE_ADDR result;
119 struct value *retval;
120 struct dwarf_expr_baton baton;
121 struct dwarf_expr_context *ctx;
122
123 baton.frame = frame;
124 baton.objfile = objfile;
125
126 ctx = new_dwarf_expr_context ();
127 ctx->baton = &baton;
128 ctx->read_reg = dwarf_expr_read_reg;
129 ctx->read_mem = dwarf_expr_read_mem;
130 ctx->get_frame_base = dwarf_expr_frame_base;
131 ctx->get_tls_address = dwarf_expr_tls_address;
132
133 dwarf_expr_eval (ctx, data, size);
134
135 retval = allocate_value (SYMBOL_TYPE (var));
136 VALUE_BFD_SECTION (retval) = SYMBOL_BFD_SECTION (var);
137
138 if (ctx->in_reg)
139 {
140 store_unsigned_integer (VALUE_CONTENTS_RAW (retval),
141 TYPE_LENGTH (SYMBOL_TYPE (var)),
142 dwarf_expr_fetch (ctx, 0));
143 VALUE_LVAL (retval) = lval_register;
144 VALUE_REGNO (retval) = ctx->regnum;
145 }
146 else
147 {
148 result = dwarf_expr_fetch (ctx, 0);
149 VALUE_LVAL (retval) = lval_memory;
150 VALUE_LAZY (retval) = 1;
151 VALUE_ADDRESS (retval) = result;
152 }
153
154 free_dwarf_expr_context (ctx);
155
156 return retval;
157 }
158
159
160
161
162 \f
163 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
164
165 struct needs_frame_baton
166 {
167 int needs_frame;
168 };
169
170 /* Reads from registers do require a frame. */
171 static CORE_ADDR
172 needs_frame_read_reg (void *baton, int regnum, enum lval_type *lvalp,
173 CORE_ADDR *addrp)
174 {
175 struct needs_frame_baton *nf_baton = baton;
176 nf_baton->needs_frame = 1;
177 return 1;
178 }
179
180 /* Reads from memory do not require a frame. */
181 static void
182 needs_frame_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
183 {
184 memset (buf, 0, len);
185 }
186
187 /* Frame-relative accesses do require a frame. */
188 static void
189 needs_frame_frame_base (void *baton, unsigned char **start, size_t * length)
190 {
191 static char lit0 = DW_OP_lit0;
192 struct needs_frame_baton *nf_baton = baton;
193
194 *start = &lit0;
195 *length = 1;
196
197 nf_baton->needs_frame = 1;
198 }
199
200 /* Thread-local accesses do require a frame. */
201 static CORE_ADDR
202 needs_frame_tls_address (void *baton, CORE_ADDR offset)
203 {
204 struct needs_frame_baton *nf_baton = baton;
205 nf_baton->needs_frame = 1;
206 return 1;
207 }
208
209 /* Return non-zero iff the location expression at DATA (length SIZE)
210 requires a frame to evaluate. */
211
212 static int
213 dwarf2_loc_desc_needs_frame (unsigned char *data, unsigned short size)
214 {
215 struct needs_frame_baton baton;
216 struct dwarf_expr_context *ctx;
217
218 baton.needs_frame = 0;
219
220 ctx = new_dwarf_expr_context ();
221 ctx->baton = &baton;
222 ctx->read_reg = needs_frame_read_reg;
223 ctx->read_mem = needs_frame_read_mem;
224 ctx->get_frame_base = needs_frame_frame_base;
225 ctx->get_tls_address = needs_frame_tls_address;
226
227 dwarf_expr_eval (ctx, data, size);
228
229 free_dwarf_expr_context (ctx);
230
231 return baton.needs_frame;
232 }
233
234
235
236 \f
237 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
238 evaluator to calculate the location. */
239 static struct value *
240 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
241 {
242 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
243 struct value *val;
244 val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
245 dlbaton->objfile);
246
247 return val;
248 }
249
250 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
251 static int
252 locexpr_read_needs_frame (struct symbol *symbol)
253 {
254 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
255 return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size);
256 }
257
258 /* Print a natural-language description of SYMBOL to STREAM. */
259 static int
260 locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
261 {
262 /* FIXME: be more extensive. */
263 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
264
265 if (dlbaton->size == 1
266 && dlbaton->data[0] >= DW_OP_reg0
267 && dlbaton->data[0] <= DW_OP_reg31)
268 {
269 int regno = DWARF2_REG_TO_REGNUM (dlbaton->data[0] - DW_OP_reg0);
270 fprintf_filtered (stream,
271 "a variable in register %s", REGISTER_NAME (regno));
272 return 1;
273 }
274
275 fprintf_filtered (stream,
276 "a variable with complex or multiple locations (DWARF2)");
277 return 1;
278 }
279
280 /* The set of location functions used with the DWARF-2 expression
281 evaluator. */
282 struct location_funcs dwarf2_locexpr_funcs = {
283 locexpr_read_variable,
284 locexpr_read_needs_frame,
285 locexpr_describe_location,
286 NULL
287 };
This page took 0.035571 seconds and 4 git commands to generate.