projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Replace SYMBOL_*_NAME accessors with member functions
[deliverable/binutils-gdb.git] / gdb / compile / compile-loc2c.c
CommitLineData
bb2ec1b3
TT		 1/* Convert a DWARF location expression to C
2
42a4f53d 3 Copyright (C) 2014-2019 Free Software Foundation, Inc.
bb2ec1b3
TT		 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 "dwarf2.h"
22#include "dwarf2expr.h"
23#include "dwarf2loc.h"
24#include "ui-file.h"
25#include "utils.h"
26#include "compile-internal.h"
b7dc48b4 27#include "compile-c.h"
bb2ec1b3
TT		 28#include "compile.h"
29#include "block.h"
30#include "dwarf2-frame.h"
268a13a5 31#include "gdbsupport/gdb_vecs.h"
bb2ec1b3 32#include "value.h"
0d12e84c 33#include "gdbarch.h"
bb2ec1b3
TT		 34
35\f
36
37/* Information about a given instruction. */
38
39struct insn_info
40{
41 /* Stack depth at entry. */
42
43 unsigned int depth;
44
45 /* Whether this instruction has been visited. */
46
47 unsigned int visited : 1;
48
49 /* Whether this instruction needs a label. */
50
51 unsigned int label : 1;
52
4aa4e28b
TT		 53 /* Whether this instruction is DW_OP_GNU_push_tls_address or
54 DW_OP_form_tls_address. This is a hack until we can add a
55 feature to glibc to let us properly generate code for TLS. */
bb2ec1b3
TT		 56
57 unsigned int is_tls : 1;
58};
59
60/* A helper function for compute_stack_depth that does the work. This
61 examines the DWARF expression starting from START and computes
62 stack effects.
63
64 NEED_TEMPVAR is an out parameter which is set if this expression
65 needs a special temporary variable to be emitted (see the code
66 generator).
c6bcad5f 67 INFO is a vector of insn_info objects, indexed by offset from the
bb2ec1b3
TT		 68 start of the DWARF expression.
69 TO_DO is a list of bytecodes which must be examined; it may be
70 added to by this function.
71 BYTE_ORDER and ADDR_SIZE describe this bytecode in the obvious way.
72 OP_PTR and OP_END are the bounds of the DWARF expression. */
73
74static void
75compute_stack_depth_worker (int start, int *need_tempvar,
c6bcad5f 76 std::vector<struct insn_info> *info,
711799d5 77 std::vector<int> *to_do,
bb2ec1b3
TT		 78 enum bfd_endian byte_order, unsigned int addr_size,
79 const gdb_byte *op_ptr, const gdb_byte *op_end)
80{
81 const gdb_byte * const base = op_ptr;
82 int stack_depth;
83
84 op_ptr += start;
c6bcad5f
TT		 85 gdb_assert ((*info)[start].visited);
86 stack_depth = (*info)[start].depth;
bb2ec1b3
TT		 87
88 while (op_ptr < op_end)
89 {
aead7601 90 enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr;
bb2ec1b3
TT		 91 uint64_t reg;
92 int64_t offset;
93 int ndx = op_ptr - base;
94
95#define SET_CHECK_DEPTH(WHERE) \
c6bcad5f 96 if ((*info)[WHERE].visited) \
bb2ec1b3 97 { \
c6bcad5f 98 if ((*info)[WHERE].depth != stack_depth) \
bb2ec1b3
TT		 99 error (_("inconsistent stack depths")); \
100 } \
101 else \
102 { \
103 /* Stack depth not set, so set it. */ \
c6bcad5f
TT		 104 (*info)[WHERE].visited = 1; \
105 (*info)[WHERE].depth = stack_depth; \
bb2ec1b3
TT		 106 }
107
108 SET_CHECK_DEPTH (ndx);
109
110 ++op_ptr;
111
112 switch (op)
113 {
114 case DW_OP_lit0:
115 case DW_OP_lit1:
116 case DW_OP_lit2:
117 case DW_OP_lit3:
118 case DW_OP_lit4:
119 case DW_OP_lit5:
120 case DW_OP_lit6:
121 case DW_OP_lit7:
122 case DW_OP_lit8:
123 case DW_OP_lit9:
124 case DW_OP_lit10:
125 case DW_OP_lit11:
126 case DW_OP_lit12:
127 case DW_OP_lit13:
128 case DW_OP_lit14:
129 case DW_OP_lit15:
130 case DW_OP_lit16:
131 case DW_OP_lit17:
132 case DW_OP_lit18:
133 case DW_OP_lit19:
134 case DW_OP_lit20:
135 case DW_OP_lit21:
136 case DW_OP_lit22:
137 case DW_OP_lit23:
138 case DW_OP_lit24:
139 case DW_OP_lit25:
140 case DW_OP_lit26:
141 case DW_OP_lit27:
142 case DW_OP_lit28:
143 case DW_OP_lit29:
144 case DW_OP_lit30:
145 case DW_OP_lit31:
146 ++stack_depth;
147 break;
148
149 case DW_OP_addr:
150 op_ptr += addr_size;
151 ++stack_depth;
152 break;
153
154 case DW_OP_const1u:
155 case DW_OP_const1s:
156 op_ptr += 1;
157 ++stack_depth;
158 break;
159 case DW_OP_const2u:
160 case DW_OP_const2s:
161 op_ptr += 2;
162 ++stack_depth;
163 break;
164 case DW_OP_const4u:
165 case DW_OP_const4s:
166 op_ptr += 4;
167 ++stack_depth;
168 break;
169 case DW_OP_const8u:
170 case DW_OP_const8s:
171 op_ptr += 8;
172 ++stack_depth;
173 break;
174 case DW_OP_constu:
175 case DW_OP_consts:
176 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
177 ++stack_depth;
178 break;
179
180 case DW_OP_reg0:
181 case DW_OP_reg1:
182 case DW_OP_reg2:
183 case DW_OP_reg3:
184 case DW_OP_reg4:
185 case DW_OP_reg5:
186 case DW_OP_reg6:
187 case DW_OP_reg7:
188 case DW_OP_reg8:
189 case DW_OP_reg9:
190 case DW_OP_reg10:
191 case DW_OP_reg11:
192 case DW_OP_reg12:
193 case DW_OP_reg13:
194 case DW_OP_reg14:
195 case DW_OP_reg15:
196 case DW_OP_reg16:
197 case DW_OP_reg17:
198 case DW_OP_reg18:
199 case DW_OP_reg19:
200 case DW_OP_reg20:
201 case DW_OP_reg21:
202 case DW_OP_reg22:
203 case DW_OP_reg23:
204 case DW_OP_reg24:
205 case DW_OP_reg25:
206 case DW_OP_reg26:
207 case DW_OP_reg27:
208 case DW_OP_reg28:
209 case DW_OP_reg29:
210 case DW_OP_reg30:
211 case DW_OP_reg31:
212 ++stack_depth;
213 break;
214
215 case DW_OP_regx:
216 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
217 ++stack_depth;
218 break;
219
220 case DW_OP_breg0:
221 case DW_OP_breg1:
222 case DW_OP_breg2:
223 case DW_OP_breg3:
224 case DW_OP_breg4:
225 case DW_OP_breg5:
226 case DW_OP_breg6:
227 case DW_OP_breg7:
228 case DW_OP_breg8:
229 case DW_OP_breg9:
230 case DW_OP_breg10:
231 case DW_OP_breg11:
232 case DW_OP_breg12:
233 case DW_OP_breg13:
234 case DW_OP_breg14:
235 case DW_OP_breg15:
236 case DW_OP_breg16:
237 case DW_OP_breg17:
238 case DW_OP_breg18:
239 case DW_OP_breg19:
240 case DW_OP_breg20:
241 case DW_OP_breg21:
242 case DW_OP_breg22:
243 case DW_OP_breg23:
244 case DW_OP_breg24:
245 case DW_OP_breg25:
246 case DW_OP_breg26:
247 case DW_OP_breg27:
248 case DW_OP_breg28:
249 case DW_OP_breg29:
250 case DW_OP_breg30:
251 case DW_OP_breg31:
252 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
253 ++stack_depth;
254 break;
255 case DW_OP_bregx:
256 {
257 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
258 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
259 ++stack_depth;
260 }
261 break;
262 case DW_OP_fbreg:
263 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
264 ++stack_depth;
265 break;
266
267 case DW_OP_dup:
268 ++stack_depth;
269 break;
270
271 case DW_OP_drop:
272 --stack_depth;
273 break;
274
275 case DW_OP_pick:
276 ++op_ptr;
277 ++stack_depth;
278 break;
279
280 case DW_OP_rot:
281 case DW_OP_swap:
282 *need_tempvar = 1;
283 break;
284
285 case DW_OP_over:
286 ++stack_depth;
287 break;
288
289 case DW_OP_abs:
290 case DW_OP_neg:
291 case DW_OP_not:
292 case DW_OP_deref:
293 break;
294
295 case DW_OP_deref_size:
296 ++op_ptr;
297 break;
298
299 case DW_OP_plus_uconst:
300 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
301 break;
302
303 case DW_OP_div:
304 case DW_OP_shra:
305 case DW_OP_and:
306 case DW_OP_minus:
307 case DW_OP_mod:
308 case DW_OP_mul:
309 case DW_OP_or:
310 case DW_OP_plus:
311 case DW_OP_shl:
312 case DW_OP_shr:
313 case DW_OP_xor:
314 case DW_OP_le:
315 case DW_OP_ge:
316 case DW_OP_eq:
317 case DW_OP_lt:
318 case DW_OP_gt:
319 case DW_OP_ne:
320 --stack_depth;
321 break;
322
323 case DW_OP_call_frame_cfa:
324 ++stack_depth;
325 break;
326
327 case DW_OP_GNU_push_tls_address:
4aa4e28b 328 case DW_OP_form_tls_address:
c6bcad5f 329 (*info)[ndx].is_tls = 1;
bb2ec1b3
TT		 330 break;
331
332 case DW_OP_skip:
333 offset = extract_signed_integer (op_ptr, 2, byte_order);
334 op_ptr += 2;
335 offset = op_ptr + offset - base;
336 /* If the destination has not been seen yet, add it to the
337 to-do list. */
c6bcad5f 338 if (!(*info)[offset].visited)
711799d5 339 to_do->push_back (offset);
bb2ec1b3 340 SET_CHECK_DEPTH (offset);
c6bcad5f 341 (*info)[offset].label = 1;
bb2ec1b3
TT		 342 /* We're done with this line of code. */
343 return;
344
345 case DW_OP_bra:
346 offset = extract_signed_integer (op_ptr, 2, byte_order);
347 op_ptr += 2;
348 offset = op_ptr + offset - base;
349 --stack_depth;
350 /* If the destination has not been seen yet, add it to the
351 to-do list. */
c6bcad5f 352 if (!(*info)[offset].visited)
711799d5 353 to_do->push_back (offset);
bb2ec1b3 354 SET_CHECK_DEPTH (offset);
c6bcad5f 355 (*info)[offset].label = 1;
bb2ec1b3
TT		 356 break;
357
358 case DW_OP_nop:
359 break;
360
361 default:
362 error (_("unhandled DWARF op: %s"), get_DW_OP_name (op));
363 }
364 }
365
366 gdb_assert (op_ptr == op_end);
367
368#undef SET_CHECK_DEPTH
369}
370
371/* Compute the maximum needed stack depth of a DWARF expression, and
372 some other information as well.
373
374 BYTE_ORDER and ADDR_SIZE describe this bytecode in the obvious way.
375 NEED_TEMPVAR is an out parameter which is set if this expression
376 needs a special temporary variable to be emitted (see the code
377 generator).
378 IS_TLS is an out parameter which is set if this expression refers
379 to a TLS variable.
380 OP_PTR and OP_END are the bounds of the DWARF expression.
381 INITIAL_DEPTH is the initial depth of the DWARF expression stack.
382 INFO is an array of insn_info objects, indexed by offset from the
383 start of the DWARF expression.
384
385 This returns the maximum stack depth. */
386
387static int
388compute_stack_depth (enum bfd_endian byte_order, unsigned int addr_size,
389 int *need_tempvar, int *is_tls,
390 const gdb_byte *op_ptr, const gdb_byte *op_end,
391 int initial_depth,
c6bcad5f 392 std::vector<struct insn_info> *info)
bb2ec1b3 393{
711799d5 394 std::vector<int> to_do;
bb2ec1b3
TT		 395 int stack_depth, i;
396
c6bcad5f 397 info->resize (op_end - op_ptr);
bb2ec1b3 398
711799d5 399 to_do.push_back (0);
bb2ec1b3
TT		 400 (*info)[0].depth = initial_depth;
401 (*info)[0].visited = 1;
402
711799d5 403 while (!to_do.empty ())
bb2ec1b3 404 {
711799d5
TT		 405 int ndx = to_do.back ();
406 to_do.pop_back ();
bb2ec1b3 407
c6bcad5f 408 compute_stack_depth_worker (ndx, need_tempvar, info, &to_do,
bb2ec1b3
TT		 409 byte_order, addr_size,
410 op_ptr, op_end);
411 }
412
413 stack_depth = 0;
414 *is_tls = 0;
415 for (i = 0; i < op_end - op_ptr; ++i)
416 {
417 if ((*info)[i].depth > stack_depth)
418 stack_depth = (*info)[i].depth;
419 if ((*info)[i].is_tls)
420 *is_tls = 1;
421 }
422
bb2ec1b3
TT		 423 return stack_depth + 1;
424}
425
426\f
427
428#define GCC_UINTPTR "__gdb_uintptr"
429#define GCC_INTPTR "__gdb_intptr"
430
431/* Emit code to push a constant. */
432
433static void
d82b3862 434push (int indent, string_file *stream, ULONGEST l)
bb2ec1b3 435{
d82b3862 436 fprintfi_filtered (indent, stream,
3a9558c4 437 "__gdb_stack[++__gdb_tos] = (" GCC_UINTPTR ") %s;\n",
bb2ec1b3
TT		 438 hex_string (l));
439}
440
441/* Emit code to push an arbitrary expression. This works like
442 printf. */
443
d82b3862 444static void pushf (int indent, string_file *stream, const char *format, ...)
77b64a49
PA		 445 ATTRIBUTE_PRINTF (3, 4);
446
bb2ec1b3 447static void
d82b3862 448pushf (int indent, string_file *stream, const char *format, ...)
bb2ec1b3
TT		 449{
450 va_list args;
451
d82b3862 452 fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos + 1] = ");
bb2ec1b3 453 va_start (args, format);
d82b3862 454 stream->vprintf (format, args);
bb2ec1b3 455 va_end (args);
d82b3862 456 stream->puts (";\n");
bb2ec1b3 457
d82b3862 458 fprintfi_filtered (indent, stream, "++__gdb_tos;\n");
bb2ec1b3
TT		 459}
460
461/* Emit code for a unary expression -- one which operates in-place on
462 the top-of-stack. This works like printf. */
463
d82b3862 464static void unary (int indent, string_file *stream, const char *format, ...)
77b64a49
PA		 465 ATTRIBUTE_PRINTF (3, 4);
466
bb2ec1b3 467static void
d82b3862 468unary (int indent, string_file *stream, const char *format, ...)
bb2ec1b3
TT		 469{
470 va_list args;
471
d82b3862 472 fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos] = ");
bb2ec1b3 473 va_start (args, format);
d82b3862 474 stream->vprintf (format, args);
bb2ec1b3 475 va_end (args);
d82b3862 476 stream->puts (";\n");
bb2ec1b3
TT		 477}
478
479/* Emit code for a unary expression -- one which uses the top two
480 stack items, popping the topmost one. This works like printf. */
d82b3862 481static void binary (int indent, string_file *stream, const char *format, ...)
77b64a49 482 ATTRIBUTE_PRINTF (3, 4);
bb2ec1b3
TT		 483
484static void
d82b3862 485binary (int indent, string_file *stream, const char *format, ...)
bb2ec1b3
TT		 486{
487 va_list args;
488
d82b3862 489 fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos - 1] = ");
bb2ec1b3 490 va_start (args, format);
d82b3862 491 stream->vprintf (format, args);
bb2ec1b3 492 va_end (args);
d82b3862
SM		 493 stream->puts (";\n");
494 fprintfi_filtered (indent, stream, "--__gdb_tos;\n");
bb2ec1b3
TT		 495}
496
497/* Print the name of a label given its "SCOPE", an arbitrary integer
498 used for uniqueness, and its TARGET, the bytecode offset
499 corresponding to the label's point of definition. */
500
501static void
d82b3862 502print_label (string_file *stream, unsigned int scope, int target)
bb2ec1b3 503{
d82b3862 504 stream->printf ("__label_%u_%s", scope, pulongest (target));
bb2ec1b3
TT		 505}
506
507/* Emit code that pushes a register's address on the stack.
508 REGISTERS_USED is an out parameter which is updated to note which
509 register was needed by this expression. */
510
511static void
d82b3862 512pushf_register_address (int indent, string_file *stream,
bb2ec1b3
TT		 513 unsigned char *registers_used,
514 struct gdbarch *gdbarch, int regnum)
515{
8f84fb0e 516 std::string regname = compile_register_name_mangled (gdbarch, regnum);
bb2ec1b3
TT		 517
518 registers_used[regnum] = 1;
3a9558c4
JK		 519 pushf (indent, stream,
520 "(" GCC_UINTPTR ") &" COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
8f84fb0e 521 regname.c_str ());
bb2ec1b3
TT		 522}
523
524/* Emit code that pushes a register's value on the stack.
525 REGISTERS_USED is an out parameter which is updated to note which
526 register was needed by this expression. OFFSET is added to the
527 register's value before it is pushed. */
528
529static void
d82b3862 530pushf_register (int indent, string_file *stream,
bb2ec1b3
TT		 531 unsigned char *registers_used,
532 struct gdbarch *gdbarch, int regnum, uint64_t offset)
533{
8f84fb0e 534 std::string regname = compile_register_name_mangled (gdbarch, regnum);
bb2ec1b3
TT		 535
536 registers_used[regnum] = 1;
537 if (offset == 0)
538 pushf (indent, stream, COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
8f84fb0e 539 regname.c_str ());
bb2ec1b3 540 else
3a9558c4
JK		 541 pushf (indent, stream,
542 COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s + (" GCC_UINTPTR ") %s",
8f84fb0e 543 regname.c_str (), hex_string (offset));
bb2ec1b3
TT		 544}
545
546/* Compile a DWARF expression to C code.
547
548 INDENT is the indentation level to use.
549 STREAM is the stream where the code should be written.
550
551 TYPE_NAME names the type of the result of the DWARF expression.
552 For locations this is "void *" but for array bounds it will be an
553 integer type.
554
555 RESULT_NAME is the name of a variable in the resulting C code. The
556 result of the expression will be assigned to this variable.
557
558 SYM is the symbol corresponding to this expression.
559 PC is the location at which the expression is being evaluated.
560 ARCH is the architecture to use.
561
562 REGISTERS_USED is an out parameter which is updated to note which
563 registers were needed by this expression.
564
565 ADDR_SIZE is the DWARF address size to use.
566
567 OPT_PTR and OP_END are the bounds of the DWARF expression.
568
569 If non-NULL, INITIAL points to an initial value to write to the
570 stack. If NULL, no initial value is written.
571
572 PER_CU is the per-CU object used for looking up various other
573 things. */
574
575static void
d82b3862 576do_compile_dwarf_expr_to_c (int indent, string_file *stream,
bb2ec1b3
TT		 577 const char *type_name,
578 const char *result_name,
579 struct symbol *sym, CORE_ADDR pc,
580 struct gdbarch *arch,
581 unsigned char *registers_used,
582 unsigned int addr_size,
583 const gdb_byte *op_ptr, const gdb_byte *op_end,
584 CORE_ADDR *initial,
585 struct dwarf2_per_cu_data *per_cu)
586{
587 /* We keep a counter so that labels and other objects we create have
588 unique names. */
589 static unsigned int scope;
590
591 enum bfd_endian byte_order = gdbarch_byte_order (arch);
592 const gdb_byte * const base = op_ptr;
593 int need_tempvar = 0;
594 int is_tls = 0;
c6bcad5f 595 std::vector<struct insn_info> info;
bb2ec1b3
TT		 596 int stack_depth;
597
598 ++scope;
599
d82b3862 600 fprintfi_filtered (indent, stream, "__attribute__ ((unused)) %s %s;\n",
3a9558c4 601 type_name, result_name);
d82b3862 602 fprintfi_filtered (indent, stream, "{\n");
bb2ec1b3
TT		 603 indent += 2;
604
605 stack_depth = compute_stack_depth (byte_order, addr_size,
606 &need_tempvar, &is_tls,
607 op_ptr, op_end, initial != NULL,
608 &info);
bb2ec1b3
TT		 609
610 /* This is a hack until we can add a feature to glibc to let us
611 properly generate code for TLS. You might think we could emit
612 the address in the ordinary course of translating
613 DW_OP_GNU_push_tls_address, but since the operand appears on the
614 stack, it is relatively hard to find, and the idea of calling
615 target_translate_tls_address with OFFSET==0 and then adding the
616 offset by hand seemed too hackish. */
617 if (is_tls)
618 {
619 struct frame_info *frame = get_selected_frame (NULL);
620 struct value *val;
621
622 if (frame == NULL)
623 error (_("Symbol \"%s\" cannot be used because "
624 "there is no selected frame"),
987012b8 625 sym->print_name ());
bb2ec1b3 626
63e43d3a 627 val = read_var_value (sym, NULL, frame);
bb2ec1b3
TT		 628 if (VALUE_LVAL (val) != lval_memory)
629 error (_("Symbol \"%s\" cannot be used for compilation evaluation "
630 "as its address has not been found."),
987012b8 631 sym->print_name ());
bb2ec1b3
TT		 632
633 warning (_("Symbol \"%s\" is thread-local and currently can only "
634 "be referenced from the current thread in "
635 "compiled code."),
987012b8 636 sym->print_name ());
bb2ec1b3 637
d82b3862 638 fprintfi_filtered (indent, stream, "%s = %s;\n",
bb2ec1b3
TT		 639 result_name,
640 core_addr_to_string (value_address (val)));
d82b3862 641 fprintfi_filtered (indent - 2, stream, "}\n");
bb2ec1b3
TT		 642 return;
643 }
644
d82b3862 645 fprintfi_filtered (indent, stream, GCC_UINTPTR " __gdb_stack[%d];\n",
bb2ec1b3
TT		 646 stack_depth);
647
648 if (need_tempvar)
d82b3862
SM		 649 fprintfi_filtered (indent, stream, GCC_UINTPTR " __gdb_tmp;\n");
650 fprintfi_filtered (indent, stream, "int __gdb_tos = -1;\n");
bb2ec1b3
TT		 651
652 if (initial != NULL)
77b64a49 653 pushf (indent, stream, "%s", core_addr_to_string (*initial));
bb2ec1b3
TT		 654
655 while (op_ptr < op_end)
656 {
aead7601 657 enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr;
bb2ec1b3
TT		 658 uint64_t uoffset, reg;
659 int64_t offset;
660
d82b3862 661 print_spaces (indent - 2, stream);
bb2ec1b3
TT		 662 if (info[op_ptr - base].label)
663 {
664 print_label (stream, scope, op_ptr - base);
d82b3862 665 stream->puts (":;");
bb2ec1b3 666 }
d82b3862 667 stream->printf ("/* %s */\n", get_DW_OP_name (op));
bb2ec1b3
TT		 668
669 /* This is handy for debugging the generated code:
670 fprintf_filtered (stream, "if (__gdb_tos != %d) abort ();\n",
671 (int) info[op_ptr - base].depth - 1);
672 */
673
674 ++op_ptr;
675
676 switch (op)
677 {
678 case DW_OP_lit0:
679 case DW_OP_lit1:
680 case DW_OP_lit2:
681 case DW_OP_lit3:
682 case DW_OP_lit4:
683 case DW_OP_lit5:
684 case DW_OP_lit6:
685 case DW_OP_lit7:
686 case DW_OP_lit8:
687 case DW_OP_lit9:
688 case DW_OP_lit10:
689 case DW_OP_lit11:
690 case DW_OP_lit12:
691 case DW_OP_lit13:
692 case DW_OP_lit14:
693 case DW_OP_lit15:
694 case DW_OP_lit16:
695 case DW_OP_lit17:
696 case DW_OP_lit18:
697 case DW_OP_lit19:
698 case DW_OP_lit20:
699 case DW_OP_lit21:
700 case DW_OP_lit22:
701 case DW_OP_lit23:
702 case DW_OP_lit24:
703 case DW_OP_lit25:
704 case DW_OP_lit26:
705 case DW_OP_lit27:
706 case DW_OP_lit28:
707 case DW_OP_lit29:
708 case DW_OP_lit30:
709 case DW_OP_lit31:
710 push (indent, stream, op - DW_OP_lit0);
711 break;
712
713 case DW_OP_addr:
266934d1 714 uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
bb2ec1b3
TT		 715 op_ptr += addr_size;
716 /* Some versions of GCC emit DW_OP_addr before
717 DW_OP_GNU_push_tls_address. In this case the value is an
718 index, not an address. We don't support things like
719 branching between the address and the TLS op. */
720 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
721 uoffset += dwarf2_per_cu_text_offset (per_cu);
722 push (indent, stream, uoffset);
723 break;
724
725 case DW_OP_const1u:
726 push (indent, stream,
727 extract_unsigned_integer (op_ptr, 1, byte_order));
728 op_ptr += 1;
729 break;
730 case DW_OP_const1s:
731 push (indent, stream,
732 extract_signed_integer (op_ptr, 1, byte_order));
733 op_ptr += 1;
734 break;
735 case DW_OP_const2u:
736 push (indent, stream,
737 extract_unsigned_integer (op_ptr, 2, byte_order));
738 op_ptr += 2;
739 break;
740 case DW_OP_const2s:
741 push (indent, stream,
742 extract_signed_integer (op_ptr, 2, byte_order));
743 op_ptr += 2;
744 break;
745 case DW_OP_const4u:
746 push (indent, stream,
747 extract_unsigned_integer (op_ptr, 4, byte_order));
748 op_ptr += 4;
749 break;
750 case DW_OP_const4s:
751 push (indent, stream,
752 extract_signed_integer (op_ptr, 4, byte_order));
753 op_ptr += 4;
754 break;
755 case DW_OP_const8u:
756 push (indent, stream,
757 extract_unsigned_integer (op_ptr, 8, byte_order));
758 op_ptr += 8;
759 break;
760 case DW_OP_const8s:
761 push (indent, stream,
762 extract_signed_integer (op_ptr, 8, byte_order));
763 op_ptr += 8;
764 break;
765 case DW_OP_constu:
766 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
767 push (indent, stream, uoffset);
768 break;
769 case DW_OP_consts:
770 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
771 push (indent, stream, offset);
772 break;
773
774 case DW_OP_reg0:
775 case DW_OP_reg1:
776 case DW_OP_reg2:
777 case DW_OP_reg3:
778 case DW_OP_reg4:
779 case DW_OP_reg5:
780 case DW_OP_reg6:
781 case DW_OP_reg7:
782 case DW_OP_reg8:
783 case DW_OP_reg9:
784 case DW_OP_reg10:
785 case DW_OP_reg11:
786 case DW_OP_reg12:
787 case DW_OP_reg13:
788 case DW_OP_reg14:
789 case DW_OP_reg15:
790 case DW_OP_reg16:
791 case DW_OP_reg17:
792 case DW_OP_reg18:
793 case DW_OP_reg19:
794 case DW_OP_reg20:
795 case DW_OP_reg21:
796 case DW_OP_reg22:
797 case DW_OP_reg23:
798 case DW_OP_reg24:
799 case DW_OP_reg25:
800 case DW_OP_reg26:
801 case DW_OP_reg27:
802 case DW_OP_reg28:
803 case DW_OP_reg29:
804 case DW_OP_reg30:
805 case DW_OP_reg31:
806 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
807 pushf_register_address (indent, stream, registers_used, arch,
0fde2c53
DE		 808 dwarf_reg_to_regnum_or_error
809 (arch, op - DW_OP_reg0));
bb2ec1b3
TT		 810 break;
811
812 case DW_OP_regx:
813 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
814 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
815 pushf_register_address (indent, stream, registers_used, arch,
0fde2c53 816 dwarf_reg_to_regnum_or_error (arch, reg));
bb2ec1b3
TT		 817 break;
818
819 case DW_OP_breg0:
820 case DW_OP_breg1:
821 case DW_OP_breg2:
822 case DW_OP_breg3:
823 case DW_OP_breg4:
824 case DW_OP_breg5:
825 case DW_OP_breg6:
826 case DW_OP_breg7:
827 case DW_OP_breg8:
828 case DW_OP_breg9:
829 case DW_OP_breg10:
830 case DW_OP_breg11:
831 case DW_OP_breg12:
832 case DW_OP_breg13:
833 case DW_OP_breg14:
834 case DW_OP_breg15:
835 case DW_OP_breg16:
836 case DW_OP_breg17:
837 case DW_OP_breg18:
838 case DW_OP_breg19:
839 case DW_OP_breg20:
840 case DW_OP_breg21:
841 case DW_OP_breg22:
842 case DW_OP_breg23:
843 case DW_OP_breg24:
844 case DW_OP_breg25:
845 case DW_OP_breg26:
846 case DW_OP_breg27:
847 case DW_OP_breg28:
848 case DW_OP_breg29:
849 case DW_OP_breg30:
850 case DW_OP_breg31:
851 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
852 pushf_register (indent, stream, registers_used, arch,
0fde2c53
DE		 853 dwarf_reg_to_regnum_or_error (arch,
854 op - DW_OP_breg0),
bb2ec1b3
TT		 855 offset);
856 break;
857 case DW_OP_bregx:
858 {
859 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
860 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
861 pushf_register (indent, stream, registers_used, arch,
0fde2c53 862 dwarf_reg_to_regnum_or_error (arch, reg), offset);
bb2ec1b3
TT		 863 }
864 break;
865 case DW_OP_fbreg:
866 {
867 const gdb_byte *datastart;
868 size_t datalen;
869 const struct block *b;
870 struct symbol *framefunc;
871 char fb_name[50];
872
873 b = block_for_pc (pc);
874
875 if (!b)
876 error (_("No block found for address"));
877
878 framefunc = block_linkage_function (b);
879
880 if (!framefunc)
881 error (_("No function found for block"));
882
883 func_get_frame_base_dwarf_block (framefunc, pc,
884 &datastart, &datalen);
885
886 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
887
888 /* Generate a unique-enough name, in case the frame base
889 is computed multiple times in this expression. */
890 xsnprintf (fb_name, sizeof (fb_name), "__frame_base_%ld",
891 (long) (op_ptr - base));
892
893 do_compile_dwarf_expr_to_c (indent, stream,
3a9558c4 894 GCC_UINTPTR, fb_name,
bb2ec1b3
TT		 895 sym, pc,
896 arch, registers_used, addr_size,
897 datastart, datastart + datalen,
898 NULL, per_cu);
899
900 pushf (indent, stream, "%s + %s", fb_name, hex_string (offset));
901 }
902 break;
903
904 case DW_OP_dup:
905 pushf (indent, stream, "__gdb_stack[__gdb_tos]");
906 break;
907
908 case DW_OP_drop:
d82b3862 909 fprintfi_filtered (indent, stream, "--__gdb_tos;\n");
bb2ec1b3
TT		 910 break;
911
912 case DW_OP_pick:
913 offset = *op_ptr++;
77b64a49
PA		 914 pushf (indent, stream, "__gdb_stack[__gdb_tos - %s]",
915 plongest (offset));
bb2ec1b3
TT		 916 break;
917
918 case DW_OP_swap:
d82b3862 919 fprintfi_filtered (indent, stream,
bb2ec1b3 920 "__gdb_tmp = __gdb_stack[__gdb_tos - 1];\n");
d82b3862 921 fprintfi_filtered (indent, stream,
bb2ec1b3
TT		 922 "__gdb_stack[__gdb_tos - 1] = "
923 "__gdb_stack[__gdb_tos];\n");
d82b3862
SM		 924 fprintfi_filtered (indent, stream, ("__gdb_stack[__gdb_tos] = "
925 "__gdb_tmp;\n"));
bb2ec1b3
TT		 926 break;
927
928 case DW_OP_over:
929 pushf (indent, stream, "__gdb_stack[__gdb_tos - 1]");
930 break;
931
932 case DW_OP_rot:
d82b3862
SM		 933 fprintfi_filtered (indent, stream, ("__gdb_tmp = "
934 "__gdb_stack[__gdb_tos];\n"));
935 fprintfi_filtered (indent, stream,
bb2ec1b3
TT		 936 "__gdb_stack[__gdb_tos] = "
937 "__gdb_stack[__gdb_tos - 1];\n");
d82b3862 938 fprintfi_filtered (indent, stream,
bb2ec1b3
TT		 939 "__gdb_stack[__gdb_tos - 1] = "
940 "__gdb_stack[__gdb_tos -2];\n");
d82b3862 941 fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos - 2] = "
bb2ec1b3
TT		 942 "__gdb_tmp;\n");
943 break;
944
945 case DW_OP_deref:
946 case DW_OP_deref_size:
947 {
948 int size;
949 const char *mode;
950
951 if (op == DW_OP_deref_size)
952 size = *op_ptr++;
953 else
954 size = addr_size;
955
956 mode = c_get_mode_for_size (size);
957 if (mode == NULL)
958 error (_("Unsupported size %d in %s"),
959 size, get_DW_OP_name (op));
960
961 /* Cast to a pointer of the desired type, then
962 dereference. */
d82b3862 963 fprintfi_filtered (indent, stream,
bb2ec1b3
TT		 964 "__gdb_stack[__gdb_tos] = "
965 "*((__gdb_int_%s *) "
966 "__gdb_stack[__gdb_tos]);\n",
967 mode);
968 }
969 break;
970
971 case DW_OP_abs:
972 unary (indent, stream,
973 "((" GCC_INTPTR ") __gdb_stack[__gdb_tos]) < 0 ? "
974 "-__gdb_stack[__gdb_tos] : __gdb_stack[__gdb_tos]");
975 break;
976
977 case DW_OP_neg:
978 unary (indent, stream, "-__gdb_stack[__gdb_tos]");
979 break;
980
981 case DW_OP_not:
982 unary (indent, stream, "~__gdb_stack[__gdb_tos]");
983 break;
984
985 case DW_OP_plus_uconst:
986 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
987 unary (indent, stream, "__gdb_stack[__gdb_tos] + %s",
988 hex_string (reg));
989 break;
990
991 case DW_OP_div:
992 binary (indent, stream, ("((" GCC_INTPTR
993 ") __gdb_stack[__gdb_tos-1]) / (("
994 GCC_INTPTR ") __gdb_stack[__gdb_tos])"));
995 break;
996
997 case DW_OP_shra:
998 binary (indent, stream,
999 "((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) >> "
1000 "__gdb_stack[__gdb_tos]");
1001 break;
1002
1003#define BINARY(OP) \
77b64a49
PA		 1004 binary (indent, stream, "%s", "__gdb_stack[__gdb_tos-1] " #OP \
1005 " __gdb_stack[__gdb_tos]"); \
bb2ec1b3
TT		 1006 break
1007
1008 case DW_OP_and:
1009 BINARY (&);
1010 case DW_OP_minus:
1011 BINARY (-);
1012 case DW_OP_mod:
1013 BINARY (%);
1014 case DW_OP_mul:
1015 BINARY (*);
1016 case DW_OP_or:
1017 BINARY (|);
1018 case DW_OP_plus:
1019 BINARY (+);
1020 case DW_OP_shl:
1021 BINARY (<<);
1022 case DW_OP_shr:
1023 BINARY (>>);
1024 case DW_OP_xor:
1025 BINARY (^);
1026#undef BINARY
1027
1028#define COMPARE(OP) \
1029 binary (indent, stream, \
1030 "(((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) " #OP \
1031 " ((" GCC_INTPTR \
1032 ") __gdb_stack[__gdb_tos]))"); \
1033 break
1034
1035 case DW_OP_le:
1036 COMPARE (<=);
1037 case DW_OP_ge:
1038 COMPARE (>=);
1039 case DW_OP_eq:
1040 COMPARE (==);
1041 case DW_OP_lt:
1042 COMPARE (<);
1043 case DW_OP_gt:
1044 COMPARE (>);
1045 case DW_OP_ne:
1046 COMPARE (!=);
1047#undef COMPARE
1048
1049 case DW_OP_call_frame_cfa:
1050 {
1051 int regnum;
1052 CORE_ADDR text_offset;
1053 LONGEST off;
1054 const gdb_byte *cfa_start, *cfa_end;
1055
1056 if (dwarf2_fetch_cfa_info (arch, pc, per_cu,
1057 &regnum, &off,
1058 &text_offset, &cfa_start, &cfa_end))
1059 {
1060 /* Register. */
1061 pushf_register (indent, stream, registers_used, arch, regnum,
1062 off);
1063 }
1064 else
1065 {
1066 /* Another expression. */
1067 char cfa_name[50];
1068
1069 /* Generate a unique-enough name, in case the CFA is
1070 computed multiple times in this expression. */
1071 xsnprintf (cfa_name, sizeof (cfa_name),
1072 "__cfa_%ld", (long) (op_ptr - base));
1073
1074 do_compile_dwarf_expr_to_c (indent, stream,
3a9558c4 1075 GCC_UINTPTR, cfa_name,
bb2ec1b3
TT		 1076 sym, pc, arch, registers_used,
1077 addr_size,
1078 cfa_start, cfa_end,
1079 &text_offset, per_cu);
77b64a49 1080 pushf (indent, stream, "%s", cfa_name);
bb2ec1b3
TT		 1081 }
1082 }
1083
1084 break;
1085
1086 case DW_OP_skip:
1087 offset = extract_signed_integer (op_ptr, 2, byte_order);
1088 op_ptr += 2;
d82b3862 1089 fprintfi_filtered (indent, stream, "goto ");
bb2ec1b3 1090 print_label (stream, scope, op_ptr + offset - base);
d82b3862 1091 stream->puts (";\n");
bb2ec1b3
TT		 1092 break;
1093
1094 case DW_OP_bra:
1095 offset = extract_signed_integer (op_ptr, 2, byte_order);
1096 op_ptr += 2;
d82b3862 1097 fprintfi_filtered (indent, stream,
bb2ec1b3
TT		 1098 "if ((( " GCC_INTPTR
1099 ") __gdb_stack[__gdb_tos--]) != 0) goto ");
1100 print_label (stream, scope, op_ptr + offset - base);
d82b3862 1101 stream->puts (";\n");
bb2ec1b3
TT		 1102 break;
1103
1104 case DW_OP_nop:
1105 break;
1106
1107 default:
1108 error (_("unhandled DWARF op: %s"), get_DW_OP_name (op));
1109 }
1110 }
1111
d82b3862 1112 fprintfi_filtered (indent, stream, "%s = __gdb_stack[__gdb_tos];\n",
3a9558c4 1113 result_name);
d82b3862 1114 fprintfi_filtered (indent - 2, stream, "}\n");
bb2ec1b3
TT		 1115}
1116
1117/* See compile.h. */
1118
1119void
d82b3862 1120compile_dwarf_expr_to_c (string_file *stream, const char *result_name,
bb2ec1b3
TT		 1121 struct symbol *sym, CORE_ADDR pc,
1122 struct gdbarch *arch, unsigned char *registers_used,
1123 unsigned int addr_size,
1124 const gdb_byte *op_ptr, const gdb_byte *op_end,
1125 struct dwarf2_per_cu_data *per_cu)
1126{
3a9558c4 1127 do_compile_dwarf_expr_to_c (2, stream, GCC_UINTPTR, result_name, sym, pc,
bb2ec1b3
TT		 1128 arch, registers_used, addr_size, op_ptr, op_end,
1129 NULL, per_cu);
1130}
1131
1132/* See compile.h. */
1133
1134void
d82b3862 1135compile_dwarf_bounds_to_c (string_file *stream,
bb2ec1b3
TT		 1136 const char *result_name,
1137 const struct dynamic_prop *prop,
1138 struct symbol *sym, CORE_ADDR pc,
1139 struct gdbarch *arch, unsigned char *registers_used,
1140 unsigned int addr_size,
1141 const gdb_byte *op_ptr, const gdb_byte *op_end,
1142 struct dwarf2_per_cu_data *per_cu)
1143{
1144 do_compile_dwarf_expr_to_c (2, stream, "unsigned long ", result_name,
1145 sym, pc, arch, registers_used,
1146 addr_size, op_ptr, op_end, NULL, per_cu);
1147}
GDB Binutils - Deliverables
This page took 0.540948 seconds and 4 git commands to generate.