[PATCH 39/43] Change back the symbol needs to use the evaluator

[Zoran Zaric via Gdb-patches <gdb-patches@sourceware.org>]

With the new design of the DWARF expression evaluator, it is now
possible to again use the evaluator for the symbol needs check.

This should address the concerns mentioned in the first patch of this
series.

gdb/ChangeLog:

        * dwarf2/loc.c (dwarf2_get_symbol_read_needs): Remove function.
        (dwarf2_loc_desc_get_symbol_read_needs): New function.
        (locexpr_get_symbol_read_needs): Change to use
        dwarf2_loc_desc_get_symbol_read_needs function.
---
 gdb/dwarf2/loc.c | 415 ++---------------------------------------------
 1 file changed, 18 insertions(+), 397 deletions(-)

diff --git a/gdb/dwarf2/loc.c b/gdb/dwarf2/loc.c
index 7dfe28c3e46..3ea5d67d517 100644
--- a/gdb/dwarf2/loc.c
+++ b/gdb/dwarf2/loc.c
@@ -1735,403 +1735,28 @@ dwarf2_compile_property_to_c (string_file *stream,
    expression in EXPR.  */
 
 static enum symbol_needs_kind
-dwarf2_get_symbol_read_needs (gdb::array_view<const gdb_byte> expr,
-			     dwarf2_per_cu_data *per_cu,
-			     dwarf2_per_objfile *per_objfile,
-			     bfd_endian byte_order,
-			     int addr_size,
-			     int ref_addr_size,
-			     int depth = 0)
+dwarf2_loc_desc_get_symbol_read_needs (gdb::array_view<const gdb_byte> expr,
+				       dwarf2_per_cu_data *per_cu,
+				       dwarf2_per_objfile *per_objfile,
+				       struct type *type)
 {
-  const gdb_byte *expr_end = expr.data () + expr.size ();
-  const gdb_byte *op_ptr = expr.data ();
-  enum symbol_needs_kind symbol_needs = SYMBOL_NEEDS_NONE;
-  const int max_depth = 256;
-
-  if (depth > max_depth)
-    error (_("DWARF-2 expression error: Loop detected (%d)."), depth);
-
-  depth++;
+  scoped_value_mark free_values;
 
-  while (op_ptr < expr_end)
+  try
     {
-      enum dwarf_location_atom op
-	= (enum dwarf_location_atom) *op_ptr++;
-      uint64_t uoffset;
-      int64_t offset;
-
-      /* The DWARF expression might have a bug causing an infinite
-	 loop.  In that case, quitting is the only way out.  */
-      QUIT;
-
-      switch (op)
-	{
-	case DW_OP_lit0:
-	case DW_OP_lit1:
-	case DW_OP_lit2:
-	case DW_OP_lit3:
-	case DW_OP_lit4:
-	case DW_OP_lit5:
-	case DW_OP_lit6:
-	case DW_OP_lit7:
-	case DW_OP_lit8:
-	case DW_OP_lit9:
-	case DW_OP_lit10:
-	case DW_OP_lit11:
-	case DW_OP_lit12:
-	case DW_OP_lit13:
-	case DW_OP_lit14:
-	case DW_OP_lit15:
-	case DW_OP_lit16:
-	case DW_OP_lit17:
-	case DW_OP_lit18:
-	case DW_OP_lit19:
-	case DW_OP_lit20:
-	case DW_OP_lit21:
-	case DW_OP_lit22:
-	case DW_OP_lit23:
-	case DW_OP_lit24:
-	case DW_OP_lit25:
-	case DW_OP_lit26:
-	case DW_OP_lit27:
-	case DW_OP_lit28:
-	case DW_OP_lit29:
-	case DW_OP_lit30:
-	case DW_OP_lit31:
-	case DW_OP_stack_value:
-	case DW_OP_dup:
-	case DW_OP_drop:
-	case DW_OP_swap:
-	case DW_OP_over:
-	case DW_OP_rot:
-	case DW_OP_deref:
-	case DW_OP_abs:
-	case DW_OP_neg:
-	case DW_OP_not:
-	case DW_OP_and:
-	case DW_OP_div:
-	case DW_OP_minus:
-	case DW_OP_mod:
-	case DW_OP_mul:
-	case DW_OP_or:
-	case DW_OP_plus:
-	case DW_OP_shl:
-	case DW_OP_shr:
-	case DW_OP_shra:
-	case DW_OP_xor:
-	case DW_OP_le:
-	case DW_OP_ge:
-	case DW_OP_eq:
-	case DW_OP_lt:
-	case DW_OP_gt:
-	case DW_OP_ne:
-	case DW_OP_GNU_push_tls_address:
-	case DW_OP_nop:
-	case DW_OP_GNU_uninit:
-	case DW_OP_push_object_address:
-	  break;
-
-	case DW_OP_form_tls_address:
-	  if (symbol_needs <= SYMBOL_NEEDS_REGISTERS)
-	    symbol_needs = SYMBOL_NEEDS_REGISTERS;
-	  break;
-
-	case DW_OP_convert:
-	case DW_OP_GNU_convert:
-	case DW_OP_reinterpret:
-	case DW_OP_GNU_reinterpret:
-	case DW_OP_addrx:
-	case DW_OP_GNU_addr_index:
-	case DW_OP_GNU_const_index:
-	case DW_OP_constu:
-	case DW_OP_plus_uconst:
-	case DW_OP_piece:
-	  op_ptr = safe_read_uleb128 (op_ptr, expr_end, &uoffset);
-	  break;
-
-	case DW_OP_consts:
-	  op_ptr = safe_read_sleb128 (op_ptr, expr_end, &offset);
-	  break;
-
-	case DW_OP_bit_piece:
-	  op_ptr = safe_read_uleb128 (op_ptr, expr_end, &uoffset);
-	  op_ptr = safe_read_uleb128 (op_ptr, expr_end, &uoffset);
-	  break;
-
-	case DW_OP_deref_type:
-	case DW_OP_GNU_deref_type:
-	  op_ptr++;
-	  op_ptr = safe_read_uleb128 (op_ptr, expr_end, &uoffset);
-	  break;
-
-	case DW_OP_addr:
-	  op_ptr += addr_size;
-	  break;
-
-	case DW_OP_const1u:
-	case DW_OP_const1s:
-	  op_ptr += 1;
-	  break;
-
-	case DW_OP_const2u:
-	case DW_OP_const2s:
-	  op_ptr += 2;
-	  break;
-
-	case DW_OP_const4s:
-	case DW_OP_const4u:
-	  op_ptr += 4;
-	  break;
-
-	case DW_OP_const8s:
-	case DW_OP_const8u:
-	  op_ptr += 8;
-	  break;
-
-	case DW_OP_reg0:
-	case DW_OP_reg1:
-	case DW_OP_reg2:
-	case DW_OP_reg3:
-	case DW_OP_reg4:
-	case DW_OP_reg5:
-	case DW_OP_reg6:
-	case DW_OP_reg7:
-	case DW_OP_reg8:
-	case DW_OP_reg9:
-	case DW_OP_reg10:
-	case DW_OP_reg11:
-	case DW_OP_reg12:
-	case DW_OP_reg13:
-	case DW_OP_reg14:
-	case DW_OP_reg15:
-	case DW_OP_reg16:
-	case DW_OP_reg17:
-	case DW_OP_reg18:
-	case DW_OP_reg19:
-	case DW_OP_reg20:
-	case DW_OP_reg21:
-	case DW_OP_reg22:
-	case DW_OP_reg23:
-	case DW_OP_reg24:
-	case DW_OP_reg25:
-	case DW_OP_reg26:
-	case DW_OP_reg27:
-	case DW_OP_reg28:
-	case DW_OP_reg29:
-	case DW_OP_reg30:
-	case DW_OP_reg31:
-	case DW_OP_regx:
-	case DW_OP_breg0:
-	case DW_OP_breg1:
-	case DW_OP_breg2:
-	case DW_OP_breg3:
-	case DW_OP_breg4:
-	case DW_OP_breg5:
-	case DW_OP_breg6:
-	case DW_OP_breg7:
-	case DW_OP_breg8:
-	case DW_OP_breg9:
-	case DW_OP_breg10:
-	case DW_OP_breg11:
-	case DW_OP_breg12:
-	case DW_OP_breg13:
-	case DW_OP_breg14:
-	case DW_OP_breg15:
-	case DW_OP_breg16:
-	case DW_OP_breg17:
-	case DW_OP_breg18:
-	case DW_OP_breg19:
-	case DW_OP_breg20:
-	case DW_OP_breg21:
-	case DW_OP_breg22:
-	case DW_OP_breg23:
-	case DW_OP_breg24:
-	case DW_OP_breg25:
-	case DW_OP_breg26:
-	case DW_OP_breg27:
-	case DW_OP_breg28:
-	case DW_OP_breg29:
-	case DW_OP_breg30:
-	case DW_OP_breg31:
-	case DW_OP_bregx:
-	case DW_OP_fbreg:
-	case DW_OP_call_frame_cfa:
-	case DW_OP_entry_value:
-	case DW_OP_GNU_entry_value:
-	case DW_OP_GNU_parameter_ref:
-	case DW_OP_regval_type:
-	case DW_OP_GNU_regval_type:
-	  symbol_needs = SYMBOL_NEEDS_FRAME;
-	  break;
-
-	case DW_OP_implicit_value:
-	  op_ptr = safe_read_uleb128 (op_ptr, expr_end, &uoffset);
-	  op_ptr += uoffset;
-	  break;
-
-	case DW_OP_implicit_pointer:
-	case DW_OP_GNU_implicit_pointer:
-	  op_ptr += ref_addr_size;
-	  op_ptr = safe_read_sleb128 (op_ptr, expr_end, &offset);
-	  break;
-
-	case DW_OP_deref_size:
-	case DW_OP_pick:
-	  op_ptr++;
-	  break;
-
-	case DW_OP_skip:
-	  op_ptr += 2;
-	  break;
-
-	case DW_OP_bra:
-	  op_ptr += 2;
-	  break;
-
-	case DW_OP_call2:
-	  {
-	    cu_offset cu_off
-	      = (cu_offset) extract_unsigned_integer (op_ptr, 2, byte_order);
-	    op_ptr += 2;
-
-	    auto get_frame_pc = [&symbol_needs] ()
-	      {
-		symbol_needs = SYMBOL_NEEDS_FRAME;
-		return 0;
-	      };
-
-	    struct dwarf2_locexpr_baton baton
-	      = dwarf2_fetch_die_loc_cu_off (cu_off, per_cu,
-					     per_objfile,
-					     get_frame_pc);
-
-	    /* If SYMBOL_NEEDS_FRAME is returned from the previous call,
-	       we dont have to check the baton content.  */
-	    if (symbol_needs != SYMBOL_NEEDS_FRAME)
-	      {
-		gdbarch *arch = baton.per_objfile->objfile->arch ();
-		gdb::array_view<const gdb_byte> sub_expr (baton.data,
-							  baton.size);
-		symbol_needs
-		  = dwarf2_get_symbol_read_needs (sub_expr,
-						  baton.per_cu,
-						  baton.per_objfile,
-						  gdbarch_byte_order (arch),
-						  baton.per_cu->addr_size (),
-						  baton.per_cu->ref_addr_size (),
-						  depth);
-	      }
-	    break;
-	  }
-
-	case DW_OP_call4:
-	  {
-	    cu_offset cu_off
-	      = (cu_offset) extract_unsigned_integer (op_ptr, 4, byte_order);
-	    op_ptr += 4;
-
-	    auto get_frame_pc = [&symbol_needs] ()
-	      {
-		symbol_needs = SYMBOL_NEEDS_FRAME;
-		return 0;
-	      };
-
-	    struct dwarf2_locexpr_baton baton
-	      = dwarf2_fetch_die_loc_cu_off (cu_off, per_cu,
-					     per_objfile,
-					     get_frame_pc);
-
-	    /* If SYMBOL_NEEDS_FRAME is returned from the previous call,
-	       we dont have to check the baton content.  */
-	    if (symbol_needs != SYMBOL_NEEDS_FRAME)
-	      {
-		gdbarch *arch = baton.per_objfile->objfile->arch ();
-		gdb::array_view<const gdb_byte> sub_expr (baton.data,
-							  baton.size);
-		symbol_needs
-		  = dwarf2_get_symbol_read_needs (sub_expr,
-						  baton.per_cu,
-						  baton.per_objfile,
-						  gdbarch_byte_order (arch),
-						  baton.per_cu->addr_size (),
-						  baton.per_cu->ref_addr_size (),
-						  depth);
-	      }
-	    break;
-	  }
-
-	case DW_OP_GNU_variable_value:
-	  {
-	    sect_offset sect_off
-	      = (sect_offset) extract_unsigned_integer (op_ptr,
-							ref_addr_size,
-							byte_order);
-	    op_ptr += ref_addr_size;
-
-	    struct type *die_type
-	      = dwarf2_fetch_die_type_sect_off (sect_off, per_cu,
-						per_objfile);
-
-	    if (die_type == NULL)
-	      error (_("Bad DW_OP_GNU_variable_value DIE."));
-
-	    /* Note: Things still work when the following test is
-	       removed.  This test and error is here to conform to the
-	       proposed specification.  */
-	    if (die_type->code () != TYPE_CODE_INT
-	       && die_type->code () != TYPE_CODE_PTR)
-	      error (_("Type of DW_OP_GNU_variable_value DIE must be "
-		       "an integer or pointer."));
-
-	    auto get_frame_pc = [&symbol_needs] ()
-	      {
-		symbol_needs = SYMBOL_NEEDS_FRAME;
-		return 0;
-	      };
-
-	    struct dwarf2_locexpr_baton baton
-	      = dwarf2_fetch_die_loc_sect_off (sect_off, per_cu,
-					       per_objfile,
-					       get_frame_pc, true);
-
-	    /* If SYMBOL_NEEDS_FRAME is returned from the previous call,
-	       we dont have to check the baton content.  */
-	    if (symbol_needs != SYMBOL_NEEDS_FRAME)
-	      {
-		gdbarch *arch = baton.per_objfile->objfile->arch ();
-		gdb::array_view<const gdb_byte> sub_expr (baton.data,
-							  baton.size);
-		symbol_needs
-		  = dwarf2_get_symbol_read_needs (sub_expr,
-						  baton.per_cu,
-						  baton.per_objfile,
-						  gdbarch_byte_order (arch),
-						  baton.per_cu->addr_size (),
-						  baton.per_cu->ref_addr_size (),
-						  depth);
-	      }
-	    break;
-	  }
-
-	case DW_OP_const_type:
-	case DW_OP_GNU_const_type:
-	  op_ptr = safe_read_uleb128 (op_ptr, expr_end, &uoffset);
-	  offset = *op_ptr++;
-	  op_ptr += offset;
-	  break;
-
-	default:
-	  error (_("Unhandled DWARF expression opcode 0x%x"), op);
-	}
-      /* If it is known that a frame information is
-	 needed we can stop parsing the expression.  */
-      if (symbol_needs == SYMBOL_NEEDS_FRAME)
-	break;
+      dwarf2_evaluate (expr.data (), expr.size (), true, per_objfile, per_cu,
+		       nullptr, per_cu->addr_size (), nullptr, nullptr, type);
+    }
+  catch (const gdb_exception_error &ex)
+    {
+      if (ex.error == NOT_AVAILABLE_ERROR)
+       return SYMBOL_NEEDS_FRAME;
     }
 
-  return symbol_needs;
+  return SYMBOL_NEEDS_NONE;
 }
 
+
 /* A helper function that throws an unimplemented error mentioning a
    given DWARF operator.  */
 
@@ -2971,15 +2596,11 @@ locexpr_get_symbol_read_needs (struct symbol *symbol)
   struct dwarf2_locexpr_baton *dlbaton
     = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
 
-  gdbarch *arch = dlbaton->per_objfile->objfile->arch ();
   gdb::array_view<const gdb_byte> expr (dlbaton->data, dlbaton->size);
 
-  return dwarf2_get_symbol_read_needs (expr,
-				       dlbaton->per_cu,
-				       dlbaton->per_objfile,
-				       gdbarch_byte_order (arch),
-				       dlbaton->per_cu->addr_size (),
-				       dlbaton->per_cu->ref_addr_size ());
+  return dwarf2_loc_desc_get_symbol_read_needs (expr, dlbaton->per_cu,
+						dlbaton->per_objfile,
+						SYMBOL_TYPE (symbol));
 }
 
 /* Return true if DATA points to the end of a piece.  END is one past
-- 
2.17.1