projects / deliverable / binutils-gdb.git / blob
? search:


22253c4dbfd4c3f7939318139ece94fd0182c203
[deliverable/binutils-gdb.git] / gdb / compile / compile-loc2c.c
1 /* Convert a DWARF location expression to C
2
3 Copyright (C) 2014-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 "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-c.h"
28 #include "compile.h"
29 #include "block.h"
30 #include "dwarf2-frame.h"
31 #include "gdbsupport/gdb_vecs.h"
32 #include "value.h"
33 #include "gdbarch.h"
34
35 \f
36
37 /* Information about a given instruction. */
38
39 struct 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
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. */
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).
67 INFO is a vector of insn_info objects, indexed by offset from the
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
74 static void
75 compute_stack_depth_worker (int start, int *need_tempvar,
76 std::vector<struct insn_info> *info,
77 std::vector<int> *to_do,
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;
85 gdb_assert ((*info)[start].visited);
86 stack_depth = (*info)[start].depth;
87
88 while (op_ptr < op_end)
89 {
90 enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr;
91 uint64_t reg;
92 int64_t offset;
93 int ndx = op_ptr - base;
94
95 #define SET_CHECK_DEPTH(WHERE) \
96 if ((*info)[WHERE].visited) \
97 { \
98 if ((*info)[WHERE].depth != stack_depth) \
99 error (_("inconsistent stack depths")); \
100 } \
101 else \
102 { \
103 /* Stack depth not set, so set it. */ \
104 (*info)[WHERE].visited = 1; \
105 (*info)[WHERE].depth = stack_depth; \
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:
328 case DW_OP_form_tls_address:
329 (*info)[ndx].is_tls = 1;
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. */
338 if (!(*info)[offset].visited)
339 to_do->push_back (offset);
340 SET_CHECK_DEPTH (offset);
341 (*info)[offset].label = 1;
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. */
352 if (!(*info)[offset].visited)
353 to_do->push_back (offset);
354 SET_CHECK_DEPTH (offset);
355 (*info)[offset].label = 1;
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
387 static int
388 compute_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,
392 std::vector<struct insn_info> *info)
393 {
394 std::vector<int> to_do;
395 int stack_depth, i;
396
397 info->resize (op_end - op_ptr);
398
399 to_do.push_back (0);
400 (*info)[0].depth = initial_depth;
401 (*info)[0].visited = 1;
402
403 while (!to_do.empty ())
404 {
405 int ndx = to_do.back ();
406 to_do.pop_back ();
407
408 compute_stack_depth_worker (ndx, need_tempvar, info, &to_do,
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
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
433 static void
434 push (int indent, string_file *stream, ULONGEST l)
435 {
436 fprintfi_filtered (indent, stream,
437 "__gdb_stack[++__gdb_tos] = (" GCC_UINTPTR ") %s;\n",
438 hex_string (l));
439 }
440
441 /* Emit code to push an arbitrary expression. This works like
442 printf. */
443
444 static void pushf (int indent, string_file *stream, const char *format, ...)
445 ATTRIBUTE_PRINTF (3, 4);
446
447 static void
448 pushf (int indent, string_file *stream, const char *format, ...)
449 {
450 va_list args;
451
452 fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos + 1] = ");
453 va_start (args, format);
454 stream->vprintf (format, args);
455 va_end (args);
456 stream->puts (";\n");
457
458 fprintfi_filtered (indent, stream, "++__gdb_tos;\n");
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
464 static void unary (int indent, string_file *stream, const char *format, ...)
465 ATTRIBUTE_PRINTF (3, 4);
466
467 static void
468 unary (int indent, string_file *stream, const char *format, ...)
469 {
470 va_list args;
471
472 fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos] = ");
473 va_start (args, format);
474 stream->vprintf (format, args);
475 va_end (args);
476 stream->puts (";\n");
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. */
481 static void binary (int indent, string_file *stream, const char *format, ...)
482 ATTRIBUTE_PRINTF (3, 4);
483
484 static void
485 binary (int indent, string_file *stream, const char *format, ...)
486 {
487 va_list args;
488
489 fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos - 1] = ");
490 va_start (args, format);
491 stream->vprintf (format, args);
492 va_end (args);
493 stream->puts (";\n");
494 fprintfi_filtered (indent, stream, "--__gdb_tos;\n");
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
501 static void
502 print_label (string_file *stream, unsigned int scope, int target)
503 {
504 stream->printf ("__label_%u_%s", scope, pulongest (target));
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
511 static void
512 pushf_register_address (int indent, string_file *stream,
513 unsigned char *registers_used,
514 struct gdbarch *gdbarch, int regnum)
515 {
516 std::string regname = compile_register_name_mangled (gdbarch, regnum);
517
518 registers_used[regnum] = 1;
519 pushf (indent, stream,
520 "(" GCC_UINTPTR ") &" COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
521 regname.c_str ());
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
529 static void
530 pushf_register (int indent, string_file *stream,
531 unsigned char *registers_used,
532 struct gdbarch *gdbarch, int regnum, uint64_t offset)
533 {
534 std::string regname = compile_register_name_mangled (gdbarch, regnum);
535
536 registers_used[regnum] = 1;
537 if (offset == 0)
538 pushf (indent, stream, COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
539 regname.c_str ());
540 else
541 pushf (indent, stream,
542 COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s + (" GCC_UINTPTR ") %s",
543 regname.c_str (), hex_string (offset));
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
575 static void
576 do_compile_dwarf_expr_to_c (int indent, string_file *stream,
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;
595 std::vector<struct insn_info> info;
596 int stack_depth;
597
598 ++scope;
599
600 fprintfi_filtered (indent, stream, "__attribute__ ((unused)) %s %s;\n",
601 type_name, result_name);
602 fprintfi_filtered (indent, stream, "{\n");
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);
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"),
625 SYMBOL_PRINT_NAME (sym));
626
627 val = read_var_value (sym, NULL, frame);
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."),
631 SYMBOL_PRINT_NAME (sym));
632
633 warning (_("Symbol \"%s\" is thread-local and currently can only "
634 "be referenced from the current thread in "
635 "compiled code."),
636 SYMBOL_PRINT_NAME (sym));
637
638 fprintfi_filtered (indent, stream, "%s = %s;\n",
639 result_name,
640 core_addr_to_string (value_address (val)));
641 fprintfi_filtered (indent - 2, stream, "}\n");
642 return;
643 }
644
645 fprintfi_filtered (indent, stream, GCC_UINTPTR " __gdb_stack[%d];\n",
646 stack_depth);
647
648 if (need_tempvar)
649 fprintfi_filtered (indent, stream, GCC_UINTPTR " __gdb_tmp;\n");
650 fprintfi_filtered (indent, stream, "int __gdb_tos = -1;\n");
651
652 if (initial != NULL)
653 pushf (indent, stream, "%s", core_addr_to_string (*initial));
654
655 while (op_ptr < op_end)
656 {
657 enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr;
658 uint64_t uoffset, reg;
659 int64_t offset;
660
661 print_spaces (indent - 2, stream);
662 if (info[op_ptr - base].label)
663 {
664 print_label (stream, scope, op_ptr - base);
665 stream->puts (":;");
666 }
667 stream->printf ("/* %s */\n", get_DW_OP_name (op));
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:
714 uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
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,
808 dwarf_reg_to_regnum_or_error
809 (arch, op - DW_OP_reg0));
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,
816 dwarf_reg_to_regnum_or_error (arch, reg));
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,
853 dwarf_reg_to_regnum_or_error (arch,
854 op - DW_OP_breg0),
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,
862 dwarf_reg_to_regnum_or_error (arch, reg), offset);
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,
894 GCC_UINTPTR, fb_name,
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:
909 fprintfi_filtered (indent, stream, "--__gdb_tos;\n");
910 break;
911
912 case DW_OP_pick:
913 offset = *op_ptr++;
914 pushf (indent, stream, "__gdb_stack[__gdb_tos - %s]",
915 plongest (offset));
916 break;
917
918 case DW_OP_swap:
919 fprintfi_filtered (indent, stream,
920 "__gdb_tmp = __gdb_stack[__gdb_tos - 1];\n");
921 fprintfi_filtered (indent, stream,
922 "__gdb_stack[__gdb_tos - 1] = "
923 "__gdb_stack[__gdb_tos];\n");
924 fprintfi_filtered (indent, stream, ("__gdb_stack[__gdb_tos] = "
925 "__gdb_tmp;\n"));
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:
933 fprintfi_filtered (indent, stream, ("__gdb_tmp = "
934 "__gdb_stack[__gdb_tos];\n"));
935 fprintfi_filtered (indent, stream,
936 "__gdb_stack[__gdb_tos] = "
937 "__gdb_stack[__gdb_tos - 1];\n");
938 fprintfi_filtered (indent, stream,
939 "__gdb_stack[__gdb_tos - 1] = "
940 "__gdb_stack[__gdb_tos -2];\n");
941 fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos - 2] = "
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. */
963 fprintfi_filtered (indent, stream,
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) \
1004 binary (indent, stream, "%s", "__gdb_stack[__gdb_tos-1] " #OP \
1005 " __gdb_stack[__gdb_tos]"); \
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,
1075 GCC_UINTPTR, cfa_name,
1076 sym, pc, arch, registers_used,
1077 addr_size,
1078 cfa_start, cfa_end,
1079 &text_offset, per_cu);
1080 pushf (indent, stream, "%s", cfa_name);
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;
1089 fprintfi_filtered (indent, stream, "goto ");
1090 print_label (stream, scope, op_ptr + offset - base);
1091 stream->puts (";\n");
1092 break;
1093
1094 case DW_OP_bra:
1095 offset = extract_signed_integer (op_ptr, 2, byte_order);
1096 op_ptr += 2;
1097 fprintfi_filtered (indent, stream,
1098 "if ((( " GCC_INTPTR
1099 ") __gdb_stack[__gdb_tos--]) != 0) goto ");
1100 print_label (stream, scope, op_ptr + offset - base);
1101 stream->puts (";\n");
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
1112 fprintfi_filtered (indent, stream, "%s = __gdb_stack[__gdb_tos];\n",
1113 result_name);
1114 fprintfi_filtered (indent - 2, stream, "}\n");
1115 }
1116
1117 /* See compile.h. */
1118
1119 void
1120 compile_dwarf_expr_to_c (string_file *stream, const char *result_name,
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 {
1127 do_compile_dwarf_expr_to_c (2, stream, GCC_UINTPTR, result_name, sym, pc,
1128 arch, registers_used, addr_size, op_ptr, op_end,
1129 NULL, per_cu);
1130 }
1131
1132 /* See compile.h. */
1133
1134 void
1135 compile_dwarf_bounds_to_c (string_file *stream,
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.058128 seconds and 3 git commands to generate.