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