GDB (xrefs)
compile-loc2c.c
Go to the documentation of this file.
1 /* Convert a DWARF location expression to C
2 
3  Copyright (C) 2014-2015 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.h"
28 #include "block.h"
29 #include "dwarf2-frame.h"
30 #include "gdb_vecs.h"
31 #include "value.h"
32 
33 
34 
35 /* Information about a given instruction. */
36 
37 struct 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 
51  /* Whether this instruction is DW_OP_GNU_push_tls_address. This is
52  a hack until we can add a feature to glibc to let us properly
53  generate code for TLS. */
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 
72 static void
73 compute_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  {
88  enum dwarf_location_atom op = *op_ptr;
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:
326  info[ndx].is_tls = 1;
327  break;
328 
329  case DW_OP_skip:
330  offset = extract_signed_integer (op_ptr, 2, byte_order);
331  op_ptr += 2;
332  offset = op_ptr + offset - base;
333  /* If the destination has not been seen yet, add it to the
334  to-do list. */
335  if (!info[offset].visited)
336  VEC_safe_push (int, *to_do, offset);
337  SET_CHECK_DEPTH (offset);
338  info[offset].label = 1;
339  /* We're done with this line of code. */
340  return;
341 
342  case DW_OP_bra:
343  offset = extract_signed_integer (op_ptr, 2, byte_order);
344  op_ptr += 2;
345  offset = op_ptr + offset - base;
346  --stack_depth;
347  /* If the destination has not been seen yet, add it to the
348  to-do list. */
349  if (!info[offset].visited)
350  VEC_safe_push (int, *to_do, offset);
351  SET_CHECK_DEPTH (offset);
352  info[offset].label = 1;
353  break;
354 
355  case DW_OP_nop:
356  break;
357 
358  default:
359  error (_("unhandled DWARF op: %s"), get_DW_OP_name (op));
360  }
361  }
362 
363  gdb_assert (op_ptr == op_end);
364 
365 #undef SET_CHECK_DEPTH
366 }
367 
368 /* Compute the maximum needed stack depth of a DWARF expression, and
369  some other information as well.
370 
371  BYTE_ORDER and ADDR_SIZE describe this bytecode in the obvious way.
372  NEED_TEMPVAR is an out parameter which is set if this expression
373  needs a special temporary variable to be emitted (see the code
374  generator).
375  IS_TLS is an out parameter which is set if this expression refers
376  to a TLS variable.
377  OP_PTR and OP_END are the bounds of the DWARF expression.
378  INITIAL_DEPTH is the initial depth of the DWARF expression stack.
379  INFO is an array of insn_info objects, indexed by offset from the
380  start of the DWARF expression.
381 
382  This returns the maximum stack depth. */
383 
384 static int
385 compute_stack_depth (enum bfd_endian byte_order, unsigned int addr_size,
386  int *need_tempvar, int *is_tls,
387  const gdb_byte *op_ptr, const gdb_byte *op_end,
388  int initial_depth,
389  struct insn_info **info)
390 {
391  unsigned char *set;
392  struct cleanup *outer_cleanup, *cleanup;
393  VEC (int) *to_do = NULL;
394  int stack_depth, i;
395 
396  *info = XCNEWVEC (struct insn_info, op_end - op_ptr);
397  outer_cleanup = make_cleanup (xfree, *info);
398 
399  cleanup = make_cleanup (VEC_cleanup (int), &to_do);
400 
401  VEC_safe_push (int, to_do, 0);
402  (*info)[0].depth = initial_depth;
403  (*info)[0].visited = 1;
404 
405  while (!VEC_empty (int, to_do))
406  {
407  int ndx = VEC_pop (int, to_do);
408 
409  compute_stack_depth_worker (ndx, need_tempvar, *info, &to_do,
410  byte_order, addr_size,
411  op_ptr, op_end);
412  }
413 
414  stack_depth = 0;
415  *is_tls = 0;
416  for (i = 0; i < op_end - op_ptr; ++i)
417  {
418  if ((*info)[i].depth > stack_depth)
419  stack_depth = (*info)[i].depth;
420  if ((*info)[i].is_tls)
421  *is_tls = 1;
422  }
423 
424  do_cleanups (cleanup);
425  discard_cleanups (outer_cleanup);
426  return stack_depth + 1;
427 }
428 
429 
430 
431 #define GCC_UINTPTR "__gdb_uintptr"
432 #define GCC_INTPTR "__gdb_intptr"
433 
434 /* Emit code to push a constant. */
435 
436 static void
437 push (int indent, struct ui_file *stream, ULONGEST l)
438 {
439  fprintfi_filtered (indent, stream,
440  "__gdb_stack[++__gdb_tos] = (" GCC_UINTPTR ") %s;\n",
441  hex_string (l));
442 }
443 
444 /* Emit code to push an arbitrary expression. This works like
445  printf. */
446 
447 static void pushf (int indent, struct ui_file *stream, const char *format, ...)
448  ATTRIBUTE_PRINTF (3, 4);
449 
450 static void
451 pushf (int indent, struct ui_file *stream, const char *format, ...)
452 {
453  va_list args;
454 
455  fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos + 1] = ");
456  va_start (args, format);
457  vfprintf_filtered (stream, format, args);
458  va_end (args);
459  fprintf_filtered (stream, ";\n");
460 
461  fprintfi_filtered (indent, stream, "++__gdb_tos;\n");
462 }
463 
464 /* Emit code for a unary expression -- one which operates in-place on
465  the top-of-stack. This works like printf. */
466 
467 static void unary (int indent, struct ui_file *stream, const char *format, ...)
468  ATTRIBUTE_PRINTF (3, 4);
469 
470 static void
471 unary (int indent, struct ui_file *stream, const char *format, ...)
472 {
473  va_list args;
474 
475  fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos] = ");
476  va_start (args, format);
477  vfprintf_filtered (stream, format, args);
478  va_end (args);
479  fprintf_filtered (stream, ";\n");
480 }
481 
482 /* Emit code for a unary expression -- one which uses the top two
483  stack items, popping the topmost one. This works like printf. */
484 static void binary (int indent, struct ui_file *stream, const char *format, ...)
485  ATTRIBUTE_PRINTF (3, 4);
486 
487 static void
488 binary (int indent, struct ui_file *stream, const char *format, ...)
489 {
490  va_list args;
491 
492  fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos - 1] = ");
493  va_start (args, format);
494  vfprintf_filtered (stream, format, args);
495  va_end (args);
496  fprintf_filtered (stream, ";\n");
497  fprintfi_filtered (indent, stream, "--__gdb_tos;\n");
498 }
499 
500 /* Print the name of a label given its "SCOPE", an arbitrary integer
501  used for uniqueness, and its TARGET, the bytecode offset
502  corresponding to the label's point of definition. */
503 
504 static void
505 print_label (struct ui_file *stream, unsigned int scope, int target)
506 {
507  fprintf_filtered (stream, "__label_%u_%s",
508  scope, pulongest (target));
509 }
510 
511 /* Emit code that pushes a register's address on the stack.
512  REGISTERS_USED is an out parameter which is updated to note which
513  register was needed by this expression. */
514 
515 static void
516 pushf_register_address (int indent, struct ui_file *stream,
517  unsigned char *registers_used,
518  struct gdbarch *gdbarch, int regnum)
519 {
520  char *regname = compile_register_name_mangled (gdbarch, regnum);
521  struct cleanup *cleanups = make_cleanup (xfree, regname);
522 
523  registers_used[regnum] = 1;
524  pushf (indent, stream,
526  regname);
527 
528  do_cleanups (cleanups);
529 }
530 
531 /* Emit code that pushes a register's value on the stack.
532  REGISTERS_USED is an out parameter which is updated to note which
533  register was needed by this expression. OFFSET is added to the
534  register's value before it is pushed. */
535 
536 static void
537 pushf_register (int indent, struct ui_file *stream,
538  unsigned char *registers_used,
539  struct gdbarch *gdbarch, int regnum, uint64_t offset)
540 {
541  char *regname = compile_register_name_mangled (gdbarch, regnum);
542  struct cleanup *cleanups = make_cleanup (xfree, regname);
543 
544  registers_used[regnum] = 1;
545  if (offset == 0)
546  pushf (indent, stream, COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
547  regname);
548  else
549  pushf (indent, stream,
551  regname, hex_string (offset));
552 
553  do_cleanups (cleanups);
554 }
555 
556 /* Compile a DWARF expression to C code.
557 
558  INDENT is the indentation level to use.
559  STREAM is the stream where the code should be written.
560 
561  TYPE_NAME names the type of the result of the DWARF expression.
562  For locations this is "void *" but for array bounds it will be an
563  integer type.
564 
565  RESULT_NAME is the name of a variable in the resulting C code. The
566  result of the expression will be assigned to this variable.
567 
568  SYM is the symbol corresponding to this expression.
569  PC is the location at which the expression is being evaluated.
570  ARCH is the architecture to use.
571 
572  REGISTERS_USED is an out parameter which is updated to note which
573  registers were needed by this expression.
574 
575  ADDR_SIZE is the DWARF address size to use.
576 
577  OPT_PTR and OP_END are the bounds of the DWARF expression.
578 
579  If non-NULL, INITIAL points to an initial value to write to the
580  stack. If NULL, no initial value is written.
581 
582  PER_CU is the per-CU object used for looking up various other
583  things. */
584 
585 static void
586 do_compile_dwarf_expr_to_c (int indent, struct ui_file *stream,
587  const char *type_name,
588  const char *result_name,
589  struct symbol *sym, CORE_ADDR pc,
590  struct gdbarch *arch,
591  unsigned char *registers_used,
592  unsigned int addr_size,
593  const gdb_byte *op_ptr, const gdb_byte *op_end,
594  CORE_ADDR *initial,
595  struct dwarf2_per_cu_data *per_cu)
596 {
597  /* We keep a counter so that labels and other objects we create have
598  unique names. */
599  static unsigned int scope;
600 
601  enum bfd_endian byte_order = gdbarch_byte_order (arch);
602  const gdb_byte * const base = op_ptr;
603  int need_tempvar = 0;
604  int is_tls = 0;
605  struct cleanup *cleanup;
606  struct insn_info *info;
607  int stack_depth;
608 
609  ++scope;
610 
611  fprintfi_filtered (indent, stream, "__attribute__ ((unused)) %s %s;\n",
612  type_name, result_name);
613  fprintfi_filtered (indent, stream, "{\n");
614  indent += 2;
615 
616  stack_depth = compute_stack_depth (byte_order, addr_size,
617  &need_tempvar, &is_tls,
618  op_ptr, op_end, initial != NULL,
619  &info);
620  cleanup = make_cleanup (xfree, info);
621 
622  /* This is a hack until we can add a feature to glibc to let us
623  properly generate code for TLS. You might think we could emit
624  the address in the ordinary course of translating
625  DW_OP_GNU_push_tls_address, but since the operand appears on the
626  stack, it is relatively hard to find, and the idea of calling
627  target_translate_tls_address with OFFSET==0 and then adding the
628  offset by hand seemed too hackish. */
629  if (is_tls)
630  {
631  struct frame_info *frame = get_selected_frame (NULL);
632  struct value *val;
633 
634  if (frame == NULL)
635  error (_("Symbol \"%s\" cannot be used because "
636  "there is no selected frame"),
637  SYMBOL_PRINT_NAME (sym));
638 
639  val = read_var_value (sym, frame);
640  if (VALUE_LVAL (val) != lval_memory)
641  error (_("Symbol \"%s\" cannot be used for compilation evaluation "
642  "as its address has not been found."),
643  SYMBOL_PRINT_NAME (sym));
644 
645  warning (_("Symbol \"%s\" is thread-local and currently can only "
646  "be referenced from the current thread in "
647  "compiled code."),
648  SYMBOL_PRINT_NAME (sym));
649 
650  fprintfi_filtered (indent, stream, "%s = %s;\n",
651  result_name,
653  fprintfi_filtered (indent - 2, stream, "}\n");
654  do_cleanups (cleanup);
655  return;
656  }
657 
658  fprintfi_filtered (indent, stream, GCC_UINTPTR " __gdb_stack[%d];\n",
659  stack_depth);
660 
661  if (need_tempvar)
662  fprintfi_filtered (indent, stream, GCC_UINTPTR " __gdb_tmp;\n");
663  fprintfi_filtered (indent, stream, "int __gdb_tos = -1;\n");
664 
665  if (initial != NULL)
666  pushf (indent, stream, "%s", core_addr_to_string (*initial));
667 
668  while (op_ptr < op_end)
669  {
670  enum dwarf_location_atom op = *op_ptr;
671  uint64_t uoffset, reg;
672  int64_t offset;
673 
674  print_spaces (indent - 2, stream);
675  if (info[op_ptr - base].label)
676  {
677  print_label (stream, scope, op_ptr - base);
678  fprintf_filtered (stream, ":;");
679  }
680  fprintf_filtered (stream, "/* %s */\n", get_DW_OP_name (op));
681 
682  /* This is handy for debugging the generated code:
683  fprintf_filtered (stream, "if (__gdb_tos != %d) abort ();\n",
684  (int) info[op_ptr - base].depth - 1);
685  */
686 
687  ++op_ptr;
688 
689  switch (op)
690  {
691  case DW_OP_lit0:
692  case DW_OP_lit1:
693  case DW_OP_lit2:
694  case DW_OP_lit3:
695  case DW_OP_lit4:
696  case DW_OP_lit5:
697  case DW_OP_lit6:
698  case DW_OP_lit7:
699  case DW_OP_lit8:
700  case DW_OP_lit9:
701  case DW_OP_lit10:
702  case DW_OP_lit11:
703  case DW_OP_lit12:
704  case DW_OP_lit13:
705  case DW_OP_lit14:
706  case DW_OP_lit15:
707  case DW_OP_lit16:
708  case DW_OP_lit17:
709  case DW_OP_lit18:
710  case DW_OP_lit19:
711  case DW_OP_lit20:
712  case DW_OP_lit21:
713  case DW_OP_lit22:
714  case DW_OP_lit23:
715  case DW_OP_lit24:
716  case DW_OP_lit25:
717  case DW_OP_lit26:
718  case DW_OP_lit27:
719  case DW_OP_lit28:
720  case DW_OP_lit29:
721  case DW_OP_lit30:
722  case DW_OP_lit31:
723  push (indent, stream, op - DW_OP_lit0);
724  break;
725 
726  case DW_OP_addr:
727  op_ptr += addr_size;
728  /* Some versions of GCC emit DW_OP_addr before
729  DW_OP_GNU_push_tls_address. In this case the value is an
730  index, not an address. We don't support things like
731  branching between the address and the TLS op. */
732  if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
733  uoffset += dwarf2_per_cu_text_offset (per_cu);
734  push (indent, stream, uoffset);
735  break;
736 
737  case DW_OP_const1u:
738  push (indent, stream,
739  extract_unsigned_integer (op_ptr, 1, byte_order));
740  op_ptr += 1;
741  break;
742  case DW_OP_const1s:
743  push (indent, stream,
744  extract_signed_integer (op_ptr, 1, byte_order));
745  op_ptr += 1;
746  break;
747  case DW_OP_const2u:
748  push (indent, stream,
749  extract_unsigned_integer (op_ptr, 2, byte_order));
750  op_ptr += 2;
751  break;
752  case DW_OP_const2s:
753  push (indent, stream,
754  extract_signed_integer (op_ptr, 2, byte_order));
755  op_ptr += 2;
756  break;
757  case DW_OP_const4u:
758  push (indent, stream,
759  extract_unsigned_integer (op_ptr, 4, byte_order));
760  op_ptr += 4;
761  break;
762  case DW_OP_const4s:
763  push (indent, stream,
764  extract_signed_integer (op_ptr, 4, byte_order));
765  op_ptr += 4;
766  break;
767  case DW_OP_const8u:
768  push (indent, stream,
769  extract_unsigned_integer (op_ptr, 8, byte_order));
770  op_ptr += 8;
771  break;
772  case DW_OP_const8s:
773  push (indent, stream,
774  extract_signed_integer (op_ptr, 8, byte_order));
775  op_ptr += 8;
776  break;
777  case DW_OP_constu:
778  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
779  push (indent, stream, uoffset);
780  break;
781  case DW_OP_consts:
782  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
783  push (indent, stream, offset);
784  break;
785 
786  case DW_OP_reg0:
787  case DW_OP_reg1:
788  case DW_OP_reg2:
789  case DW_OP_reg3:
790  case DW_OP_reg4:
791  case DW_OP_reg5:
792  case DW_OP_reg6:
793  case DW_OP_reg7:
794  case DW_OP_reg8:
795  case DW_OP_reg9:
796  case DW_OP_reg10:
797  case DW_OP_reg11:
798  case DW_OP_reg12:
799  case DW_OP_reg13:
800  case DW_OP_reg14:
801  case DW_OP_reg15:
802  case DW_OP_reg16:
803  case DW_OP_reg17:
804  case DW_OP_reg18:
805  case DW_OP_reg19:
806  case DW_OP_reg20:
807  case DW_OP_reg21:
808  case DW_OP_reg22:
809  case DW_OP_reg23:
810  case DW_OP_reg24:
811  case DW_OP_reg25:
812  case DW_OP_reg26:
813  case DW_OP_reg27:
814  case DW_OP_reg28:
815  case DW_OP_reg29:
816  case DW_OP_reg30:
817  case DW_OP_reg31:
818  dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
819  pushf_register_address (indent, stream, registers_used, arch,
821  op - DW_OP_reg0));
822  break;
823 
824  case DW_OP_regx:
825  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
826  dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
827  pushf_register_address (indent, stream, registers_used, arch,
828  dwarf2_reg_to_regnum_or_error (arch, reg));
829  break;
830 
831  case DW_OP_breg0:
832  case DW_OP_breg1:
833  case DW_OP_breg2:
834  case DW_OP_breg3:
835  case DW_OP_breg4:
836  case DW_OP_breg5:
837  case DW_OP_breg6:
838  case DW_OP_breg7:
839  case DW_OP_breg8:
840  case DW_OP_breg9:
841  case DW_OP_breg10:
842  case DW_OP_breg11:
843  case DW_OP_breg12:
844  case DW_OP_breg13:
845  case DW_OP_breg14:
846  case DW_OP_breg15:
847  case DW_OP_breg16:
848  case DW_OP_breg17:
849  case DW_OP_breg18:
850  case DW_OP_breg19:
851  case DW_OP_breg20:
852  case DW_OP_breg21:
853  case DW_OP_breg22:
854  case DW_OP_breg23:
855  case DW_OP_breg24:
856  case DW_OP_breg25:
857  case DW_OP_breg26:
858  case DW_OP_breg27:
859  case DW_OP_breg28:
860  case DW_OP_breg29:
861  case DW_OP_breg30:
862  case DW_OP_breg31:
863  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
864  pushf_register (indent, stream, registers_used, arch,
866  op - DW_OP_breg0),
867  offset);
868  break;
869  case DW_OP_bregx:
870  {
871  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
872  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
873  pushf_register (indent, stream, registers_used, arch,
874  dwarf2_reg_to_regnum_or_error (arch, reg), offset);
875  }
876  break;
877  case DW_OP_fbreg:
878  {
879  const gdb_byte *datastart;
880  size_t datalen;
881  const struct block *b;
882  struct symbol *framefunc;
883  char fb_name[50];
884 
885  b = block_for_pc (pc);
886 
887  if (!b)
888  error (_("No block found for address"));
889 
890  framefunc = block_linkage_function (b);
891 
892  if (!framefunc)
893  error (_("No function found for block"));
894 
895  func_get_frame_base_dwarf_block (framefunc, pc,
896  &datastart, &datalen);
897 
898  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
899 
900  /* Generate a unique-enough name, in case the frame base
901  is computed multiple times in this expression. */
902  xsnprintf (fb_name, sizeof (fb_name), "__frame_base_%ld",
903  (long) (op_ptr - base));
904 
905  do_compile_dwarf_expr_to_c (indent, stream,
906  GCC_UINTPTR, fb_name,
907  sym, pc,
908  arch, registers_used, addr_size,
909  datastart, datastart + datalen,
910  NULL, per_cu);
911 
912  pushf (indent, stream, "%s + %s", fb_name, hex_string (offset));
913  }
914  break;
915 
916  case DW_OP_dup:
917  pushf (indent, stream, "__gdb_stack[__gdb_tos]");
918  break;
919 
920  case DW_OP_drop:
921  fprintfi_filtered (indent, stream, "--__gdb_tos;\n");
922  break;
923 
924  case DW_OP_pick:
925  offset = *op_ptr++;
926  pushf (indent, stream, "__gdb_stack[__gdb_tos - %s]",
927  plongest (offset));
928  break;
929 
930  case DW_OP_swap:
931  fprintfi_filtered (indent, stream,
932  "__gdb_tmp = __gdb_stack[__gdb_tos - 1];\n");
933  fprintfi_filtered (indent, stream,
934  "__gdb_stack[__gdb_tos - 1] = "
935  "__gdb_stack[__gdb_tos];\n");
936  fprintfi_filtered (indent, stream, ("__gdb_stack[__gdb_tos] = "
937  "__gdb_tmp;\n"));
938  break;
939 
940  case DW_OP_over:
941  pushf (indent, stream, "__gdb_stack[__gdb_tos - 1]");
942  break;
943 
944  case DW_OP_rot:
945  fprintfi_filtered (indent, stream, ("__gdb_tmp = "
946  "__gdb_stack[__gdb_tos];\n"));
947  fprintfi_filtered (indent, stream,
948  "__gdb_stack[__gdb_tos] = "
949  "__gdb_stack[__gdb_tos - 1];\n");
950  fprintfi_filtered (indent, stream,
951  "__gdb_stack[__gdb_tos - 1] = "
952  "__gdb_stack[__gdb_tos -2];\n");
953  fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos - 2] = "
954  "__gdb_tmp;\n");
955  break;
956 
957  case DW_OP_deref:
958  case DW_OP_deref_size:
959  {
960  int size;
961  const char *mode;
962 
963  if (op == DW_OP_deref_size)
964  size = *op_ptr++;
965  else
966  size = addr_size;
967 
968  mode = c_get_mode_for_size (size);
969  if (mode == NULL)
970  error (_("Unsupported size %d in %s"),
971  size, get_DW_OP_name (op));
972 
973  /* Cast to a pointer of the desired type, then
974  dereference. */
975  fprintfi_filtered (indent, stream,
976  "__gdb_stack[__gdb_tos] = "
977  "*((__gdb_int_%s *) "
978  "__gdb_stack[__gdb_tos]);\n",
979  mode);
980  }
981  break;
982 
983  case DW_OP_abs:
984  unary (indent, stream,
985  "((" GCC_INTPTR ") __gdb_stack[__gdb_tos]) < 0 ? "
986  "-__gdb_stack[__gdb_tos] : __gdb_stack[__gdb_tos]");
987  break;
988 
989  case DW_OP_neg:
990  unary (indent, stream, "-__gdb_stack[__gdb_tos]");
991  break;
992 
993  case DW_OP_not:
994  unary (indent, stream, "~__gdb_stack[__gdb_tos]");
995  break;
996 
997  case DW_OP_plus_uconst:
998  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
999  unary (indent, stream, "__gdb_stack[__gdb_tos] + %s",
1000  hex_string (reg));
1001  break;
1002 
1003  case DW_OP_div:
1004  binary (indent, stream, ("((" GCC_INTPTR
1005  ") __gdb_stack[__gdb_tos-1]) / (("
1006  GCC_INTPTR ") __gdb_stack[__gdb_tos])"));
1007  break;
1008 
1009  case DW_OP_shra:
1010  binary (indent, stream,
1011  "((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) >> "
1012  "__gdb_stack[__gdb_tos]");
1013  break;
1014 
1015 #define BINARY(OP) \
1016  binary (indent, stream, "%s", "__gdb_stack[__gdb_tos-1] " #OP \
1017  " __gdb_stack[__gdb_tos]"); \
1018  break
1019 
1020  case DW_OP_and:
1021  BINARY (&);
1022  case DW_OP_minus:
1023  BINARY (-);
1024  case DW_OP_mod:
1025  BINARY (%);
1026  case DW_OP_mul:
1027  BINARY (*);
1028  case DW_OP_or:
1029  BINARY (|);
1030  case DW_OP_plus:
1031  BINARY (+);
1032  case DW_OP_shl:
1033  BINARY (<<);
1034  case DW_OP_shr:
1035  BINARY (>>);
1036  case DW_OP_xor:
1037  BINARY (^);
1038 #undef BINARY
1039 
1040 #define COMPARE(OP) \
1041  binary (indent, stream, \
1042  "(((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) " #OP \
1043  " ((" GCC_INTPTR \
1044  ") __gdb_stack[__gdb_tos]))"); \
1045  break
1046 
1047  case DW_OP_le:
1048  COMPARE (<=);
1049  case DW_OP_ge:
1050  COMPARE (>=);
1051  case DW_OP_eq:
1052  COMPARE (==);
1053  case DW_OP_lt:
1054  COMPARE (<);
1055  case DW_OP_gt:
1056  COMPARE (>);
1057  case DW_OP_ne:
1058  COMPARE (!=);
1059 #undef COMPARE
1060 
1061  case DW_OP_call_frame_cfa:
1062  {
1063  int regnum;
1064  CORE_ADDR text_offset;
1065  LONGEST off;
1066  const gdb_byte *cfa_start, *cfa_end;
1067 
1068  if (dwarf2_fetch_cfa_info (arch, pc, per_cu,
1069  &regnum, &off,
1070  &text_offset, &cfa_start, &cfa_end))
1071  {
1072  /* Register. */
1073  pushf_register (indent, stream, registers_used, arch, regnum,
1074  off);
1075  }
1076  else
1077  {
1078  /* Another expression. */
1079  char cfa_name[50];
1080 
1081  /* Generate a unique-enough name, in case the CFA is
1082  computed multiple times in this expression. */
1083  xsnprintf (cfa_name, sizeof (cfa_name),
1084  "__cfa_%ld", (long) (op_ptr - base));
1085 
1086  do_compile_dwarf_expr_to_c (indent, stream,
1087  GCC_UINTPTR, cfa_name,
1088  sym, pc, arch, registers_used,
1089  addr_size,
1090  cfa_start, cfa_end,
1091  &text_offset, per_cu);
1092  pushf (indent, stream, "%s", cfa_name);
1093  }
1094  }
1095 
1096  break;
1097 
1098  case DW_OP_skip:
1099  offset = extract_signed_integer (op_ptr, 2, byte_order);
1100  op_ptr += 2;
1101  fprintfi_filtered (indent, stream, "goto ");
1102  print_label (stream, scope, op_ptr + offset - base);
1103  fprintf_filtered (stream, ";\n");
1104  break;
1105 
1106  case DW_OP_bra:
1107  offset = extract_signed_integer (op_ptr, 2, byte_order);
1108  op_ptr += 2;
1109  fprintfi_filtered (indent, stream,
1110  "if ((( " GCC_INTPTR
1111  ") __gdb_stack[__gdb_tos--]) != 0) goto ");
1112  print_label (stream, scope, op_ptr + offset - base);
1113  fprintf_filtered (stream, ";\n");
1114  break;
1115 
1116  case DW_OP_nop:
1117  break;
1118 
1119  default:
1120  error (_("unhandled DWARF op: %s"), get_DW_OP_name (op));
1121  }
1122  }
1123 
1124  fprintfi_filtered (indent, stream, "%s = __gdb_stack[__gdb_tos];\n",
1125  result_name);
1126  fprintfi_filtered (indent - 2, stream, "}\n");
1127 
1128  do_cleanups (cleanup);
1129 }
1130 
1131 /* See compile.h. */
1132 
1133 void
1134 compile_dwarf_expr_to_c (struct ui_file *stream, const char *result_name,
1135  struct symbol *sym, CORE_ADDR pc,
1136  struct gdbarch *arch, unsigned char *registers_used,
1137  unsigned int addr_size,
1138  const gdb_byte *op_ptr, const gdb_byte *op_end,
1139  struct dwarf2_per_cu_data *per_cu)
1140 {
1141  do_compile_dwarf_expr_to_c (2, stream, GCC_UINTPTR, result_name, sym, pc,
1142  arch, registers_used, addr_size, op_ptr, op_end,
1143  NULL, per_cu);
1144 }
1145 
1146 /* See compile.h. */
1147 
1148 void
1150  const char *result_name,
1151  const struct dynamic_prop *prop,
1152  struct symbol *sym, CORE_ADDR pc,
1153  struct gdbarch *arch, unsigned char *registers_used,
1154  unsigned int addr_size,
1155  const gdb_byte *op_ptr, const gdb_byte *op_end,
1156  struct dwarf2_per_cu_data *per_cu)
1157 {
1158  do_compile_dwarf_expr_to_c (2, stream, "unsigned long ", result_name,
1159  sym, pc, arch, registers_used,
1160  addr_size, op_ptr, op_end, NULL, per_cu);
1161 }
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
unsigned int is_tls
Definition: compile-loc2c.c:55
void compile_dwarf_bounds_to_c(struct ui_file *stream, const char *result_name, const struct dynamic_prop *prop, struct symbol *sym, CORE_ADDR pc, struct gdbarch *arch, unsigned char *registers_used, unsigned int addr_size, const gdb_byte *op_ptr, const gdb_byte *op_end, struct dwarf2_per_cu_data *per_cu)
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
int dwarf2_fetch_cfa_info(struct gdbarch *gdbarch, CORE_ADDR pc, struct dwarf2_per_cu_data *data, int *regnum_out, LONGEST *offset_out, CORE_ADDR *text_offset_out, const gdb_byte **cfa_start_out, const gdb_byte **cfa_end_out)
Definition: dwarf2-frame.c:893
bfd_vma CORE_ADDR
Definition: common-types.h:41
static void pushf_register_address(int indent, struct ui_file *stream, unsigned char *registers_used, struct gdbarch *gdbarch, int regnum)
#define COMPARE(OP)
void xfree(void *)
Definition: common-utils.c:97
static void compute_stack_depth_worker(int start, int *need_tempvar, struct insn_info *info, VEC(int)**to_do, enum bfd_endian byte_order, unsigned int addr_size, const gdb_byte *op_ptr, const gdb_byte *op_end)
Definition: compile-loc2c.c:73
void warning(const char *fmt,...)
Definition: errors.c:26
struct type ** const(pascal_builtin_types[])
void print_spaces(int n, struct ui_file *file)
Definition: utils.c:1098
struct symbol * block_linkage_function(const struct block *bl)
Definition: block.c:100
struct value * read_var_value(struct symbol *var, struct frame_info *frame)
Definition: findvar.c:613
void dwarf_expr_require_composition(const gdb_byte *op_ptr, const gdb_byte *op_end, const char *op_name)
Definition: dwarf2expr.c:408
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
const gdb_byte * safe_read_uleb128(const gdb_byte *buf, const gdb_byte *buf_end, uint64_t *r)
Definition: dwarf2expr.c:373
#define VEC(T)
Definition: vec.h:398
#define _(String)
Definition: gdb_locale.h:40
static void print_label(struct ui_file *stream, unsigned int scope, int target)
char * compile_register_name_mangled(struct gdbarch *gdbarch, int regnum)
Definition: compile.c:642
#define VALUE_LVAL(val)
Definition: value.h:411
#define GCC_UINTPTR
static void binary(int indent, struct ui_file *stream, const char *format,...) ATTRIBUTE_PRINTF(3
const struct block * block_for_pc(CORE_ADDR pc)
Definition: block.c:282
unsigned int depth
Definition: compile-loc2c.c:41
void compile_dwarf_expr_to_c(struct ui_file *stream, const char *result_name, struct symbol *sym, CORE_ADDR pc, struct gdbarch *arch, unsigned char *registers_used, unsigned int addr_size, const gdb_byte *op_ptr, const gdb_byte *op_end, struct dwarf2_per_cu_data *per_cu)
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
void vfprintf_filtered(struct ui_file *stream, const char *format, va_list args)
Definition: utils.c:2302
#define COMPILE_I_SIMPLE_REGISTER_ARG_NAME
static void do_compile_dwarf_expr_to_c(int indent, struct ui_file *stream, const char *type_name, const char *result_name, struct symbol *sym, CORE_ADDR pc, struct gdbarch *arch, unsigned char *registers_used, unsigned int addr_size, const gdb_byte *op_ptr, const gdb_byte *op_end, CORE_ADDR *initial, struct dwarf2_per_cu_data *per_cu)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
#define gdb_assert(expr)
Definition: gdb_assert.h:33
#define VEC_pop(T, V)
Definition: vec.h:270
CORE_ADDR dwarf2_per_cu_text_offset(struct dwarf2_per_cu_data *cu)
Definition: dwarf2read.c:21938
static void unary(int indent, struct ui_file *stream, const char *format,...) ATTRIBUTE_PRINTF(3
int regnum
Definition: aarch64-tdep.c:69
const char * c_get_mode_for_size(int size)
#define GCC_INTPTR
const gdb_byte * safe_read_sleb128(const gdb_byte *buf, const gdb_byte *buf_end, int64_t *r)
Definition: dwarf2expr.c:385
Definition: regdef.h:22
Definition: block.h:60
#define VEC_empty(T, V)
Definition: vec.h:132
Definition: value.c:172
static void push(int indent, struct ui_file *stream, ULONGEST l)
static void pushf(int indent, struct ui_file *stream, const char *format,...) ATTRIBUTE_PRINTF(3
void fprintfi_filtered(int spaces, struct ui_file *stream, const char *format,...)
Definition: utils.c:2374
bfd_byte gdb_byte
Definition: common-types.h:38
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
int dwarf2_reg_to_regnum_or_error(struct gdbarch *arch, int dwarf_reg)
Definition: dwarf2loc.c:2780
void func_get_frame_base_dwarf_block(struct symbol *framefunc, CORE_ADDR pc, const gdb_byte **start, size_t *length)
Definition: dwarf2loc.c:415
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
#define SET_CHECK_DEPTH(WHERE)
int offset
Definition: agent.c:65
static void pushf_register(int indent, struct ui_file *stream, unsigned char *registers_used, struct gdbarch *gdbarch, int regnum, uint64_t offset)
struct gdbarch * arch
Definition: symtab.h:725
unsigned long long ULONGEST
Definition: common-types.h:53
static void ATTRIBUTE_PRINTF(6, 0)
Definition: cli-out.c:229
static int compute_stack_depth(enum bfd_endian byte_order, unsigned int addr_size, int *need_tempvar, int *is_tls, const gdb_byte *op_ptr, const gdb_byte *op_end, int initial_depth, struct insn_info **info)
#define VEC_cleanup(T)
Definition: vec.h:187
unsigned int label
Definition: compile-loc2c.c:49
Definition: symtab.h:703
#define BINARY(OP)
LONGEST extract_signed_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:49
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1440
unsigned int visited
Definition: compile-loc2c.c:45
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
long long LONGEST
Definition: common-types.h:52
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175