Make dwarf_stack_value::in_stack_memory a bool

Replace int with bool, because that's what it is.

gdb/ChangeLog:

	* dwarf2expr.h (dwarf_expr_piece) <v.mem.in_stack_memory>:
	Change type to bool.
	(dwarf_stack_value) <in_stack_memory>: Likewise.
	(dwarf_expr_context) <push_address>: Change parameter type to
	bool.
	<fetch_in_stack_memory>: Change return type to bool.
	<push>: Change parameter type to bool.
	* dwarf2expr.c (dwarf_expr_context::push): Change parameter type
	to bool.
	(dwarf_expr_context::push_address): Likewise.
	(dwarf_expr_context::fetch_in_stack_memory): Change return type
	to bool.
	(dwarf_expr_context::execute_stack_op): Adjust.
	* dwarf2loc.c (dwarf2_evaluate_loc_desc_full): Adjust.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 0f19d4adef1a250571b441c03f5e742b8e883929..15bf1ae0f7d3bccaf23b8f56a867d85efc9418a3 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,20 @@
+2017-09-14  Simon Marchi  <simon.marchi@ericsson.com>
+
+       * dwarf2expr.h (dwarf_expr_piece) <v.mem.in_stack_memory>:
+       Change type to bool.
+       (dwarf_stack_value) <in_stack_memory>: Likewise.
+       (dwarf_expr_context) <push_address>: Change parameter type to
+       bool.
+       <fetch_in_stack_memory>: Change return type to bool.
+       <push>: Change parameter type to bool.
+       * dwarf2expr.c (dwarf_expr_context::push): Change parameter type
+       to bool.
+       (dwarf_expr_context::push_address): Likewise.
+       (dwarf_expr_context::fetch_in_stack_memory): Change return type
+       to bool.
+       (dwarf_expr_context::execute_stack_op): Adjust.
+       * dwarf2loc.c (dwarf2_evaluate_loc_desc_full): Adjust.
+
 2017-09-14  Simon Marchi  <simon.marchi@ericsson.com>
 
        * dwarf2expr.h (struct dwarf_expr_piece): Move up.

diff --git a/gdb/dwarf2expr.c b/gdb/dwarf2expr.c
index 61a1e9e67a4a11b1b97908f967026134268ecbb3..1dfbc0f3f0853d7b94bc36540f456a04e288f0d5 100644 (file)
--- a/gdb/dwarf2expr.c
+++ b/gdb/dwarf2expr.c
@@ -130,7 +130,7 @@ dwarf_expr_context::grow_stack (size_t need)
 /* Push VALUE onto the stack.  */
 
 void
-dwarf_expr_context::push (struct value *value, int in_stack_memory)
+dwarf_expr_context::push (struct value *value, bool in_stack_memory)
 {
   struct dwarf_stack_value *v;
 
@@ -143,7 +143,7 @@ dwarf_expr_context::push (struct value *value, int in_stack_memory)
 /* Push VALUE onto the stack.  */
 
 void
-dwarf_expr_context::push_address (CORE_ADDR value, int in_stack_memory)
+dwarf_expr_context::push_address (CORE_ADDR value, bool in_stack_memory)
 {
   push (value_from_ulongest (address_type (), value), in_stack_memory);
 }
@@ -260,7 +260,7 @@ dwarf_expr_context::fetch_address (int n)
 
 /* Retrieve the in_stack_memory flag of the N'th item on the stack.  */
 
-int
+bool
 dwarf_expr_context::fetch_in_stack_memory (int n)
 {
   if (this->stack_len <= n)
@@ -599,12 +599,12 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr,
       enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr++;
       ULONGEST result;
       /* Assume the value is not in stack memory.
-        Code that knows otherwise sets this to 1.
+        Code that knows otherwise sets this to true.
         Some arithmetic on stack addresses can probably be assumed to still
         be a stack address, but we skip this complication for now.
         This is just an optimization, so it's always ok to punt
-        and leave this as 0.  */
-      int in_stack_memory = 0;
+        and leave this as false.  */
+      bool in_stack_memory = false;
       uint64_t uoffset, reg;
       int64_t offset;
       struct value *result_val = NULL;
@@ -897,7 +897,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr,
                       "base using explicit value operator"));
            result = result + offset;
            result_val = value_from_ulongest (address_type, result);
-           in_stack_memory = 1;
+           in_stack_memory = true;
            this->stack_len = before_stack_len;
            this->location = DWARF_VALUE_MEMORY;
          }
@@ -1187,7 +1187,7 @@ dwarf_expr_context::execute_stack_op (const gdb_byte *op_ptr,
        case DW_OP_call_frame_cfa:
          result = this->get_frame_cfa ();
          result_val = value_from_ulongest (address_type, result);
-         in_stack_memory = 1;
+         in_stack_memory = true;
          break;
 
        case DW_OP_GNU_push_tls_address:

diff --git a/gdb/dwarf2expr.h b/gdb/dwarf2expr.h
index 39bcea3cab00341e05d9b30b7f4647c7bba3dbb7..a6aec280853f80691cfd42d851a10a1d17b1ece6 100644 (file)
--- a/gdb/dwarf2expr.h
+++ b/gdb/dwarf2expr.h
@@ -62,7 +62,7 @@ struct dwarf_expr_piece
       CORE_ADDR addr;
       /* Non-zero if the piece is known to be in memory and on
         the program's stack.  */
-      int in_stack_memory;
+      bool in_stack_memory;
     } mem;
 
     /* The piece's register number, for DWARF_VALUE_REGISTER pieces.  */
@@ -102,12 +102,11 @@ struct dwarf_stack_value
 {
   struct value *value;
 
-  /* Non-zero if the piece is in memory and is known to be
-     on the program's stack.  It is always ok to set this to zero.
-     This is used, for example, to optimize memory access from the target.
-     It can vastly speed up backtraces on long latency connections when
-     "set stack-cache on".  */
-  int in_stack_memory;
+  /* True if the piece is in memory and is known to be on the program's stack.
+     It is always ok to set this to zero.  This is used, for example, to
+     optimize memory access from the target.  It can vastly speed up backtraces
+     on long latency connections when "set stack-cache on".  */
+  bool in_stack_memory;
 };
 
 /* The expression evaluator works with a dwarf_expr_context, describing
@@ -117,11 +116,11 @@ struct dwarf_expr_context
   dwarf_expr_context ();
   virtual ~dwarf_expr_context ();
 
-  void push_address (CORE_ADDR value, int in_stack_memory);
+  void push_address (CORE_ADDR value, bool in_stack_memory);
   void eval (const gdb_byte *addr, size_t len);
   struct value *fetch (int n);
   CORE_ADDR fetch_address (int n);
-  int fetch_in_stack_memory (int n);
+  bool fetch_in_stack_memory (int n);
 
   /* The stack of values, allocated with xmalloc.  */
   struct dwarf_stack_value *stack;
@@ -251,7 +250,7 @@ private:
 
   struct type *address_type () const;
   void grow_stack (size_t need);
-  void push (struct value *value, int in_stack_memory);
+  void push (struct value *value, bool in_stack_memory);
   int stack_empty_p () const;
   void add_piece (ULONGEST size, ULONGEST offset);
   void execute_stack_op (const gdb_byte *op_ptr, const gdb_byte *op_end);

diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
index cfbea3c9da2ea97f4130db3cc79a5a128d497181..3c2f6aaf582fad8fe7ea8cbf8fdf2dd0dae4e119 100644 (file)
--- a/gdb/dwarf2loc.c
+++ b/gdb/dwarf2loc.c
@@ -2441,7 +2441,7 @@ dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
          {
            struct type *ptr_type;
            CORE_ADDR address = ctx.fetch_address (0);
-           int in_stack_memory = ctx.fetch_in_stack_memory (0);
+           bool in_stack_memory = ctx.fetch_in_stack_memory (0);
 
            /* DW_OP_deref_size (and possibly other operations too) may
               create a pointer instead of an address.  Ideally, the