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