X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gdb%2Fax.h;h=112c21b6217606e7340dc793657f0a6787352bfe;hb=c07aae6e727ca8ae2b3ef123d920b7cef2aff8c6;hp=1d601bb800da710c2913b2ae96bffcff2ac9cb26;hpb=a14ed312fd86dd2c862847230931451da2e49942;p=external%2Fbinutils.git
diff --git a/gdb/ax.h b/gdb/ax.h
index 1d601bb..112c21b 100644
--- a/gdb/ax.h
+++ b/gdb/ax.h
@@ -1,11 +1,11 @@
/* Definitions for expressions designed to be executed on the agent
- Copyright 1998, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1998-2019 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
@@ -14,12 +14,12 @@
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see . */
-#ifndef AGENTEXPR_H
-#define AGENTEXPR_H
+#ifndef AX_H
+#define AX_H
+
+#include "gdbsupport/vec.h"
/* It's sometimes useful to be able to debug programs that you can't
really stop for more than a fraction of a second. To this end, the
@@ -50,87 +50,122 @@
to the host GDB. */
-/* Agent expression data structures. */
+/* Different kinds of flaws an agent expression might have, as
+ detected by ax_reqs. */
+enum agent_flaws
+ {
+ agent_flaw_none = 0, /* code is good */
-/* The type of an element of the agent expression stack.
- The bytecode operation indicates which element we should access;
- the value itself has no typing information. GDB generates all
- bytecode streams, so we don't have to worry about type errors. */
+ /* There is an invalid instruction in the stream. */
+ agent_flaw_bad_instruction,
-union agent_val
- {
- LONGEST l;
- DOUBLEST d;
+ /* There is an incomplete instruction at the end of the expression. */
+ agent_flaw_incomplete_instruction,
+
+ /* ax_reqs was unable to prove that every jump target is to a
+ valid offset. Valid offsets are within the bounds of the
+ expression, and to a valid instruction boundary. */
+ agent_flaw_bad_jump,
+
+ /* ax_reqs was unable to prove to its satisfaction that, for each
+ jump target location, the stack will have the same height whether
+ that location is reached via a jump or by straight execution. */
+ agent_flaw_height_mismatch,
+
+ /* ax_reqs was unable to prove that every instruction following
+ an unconditional jump was the target of some other jump. */
+ agent_flaw_hole
};
+/* Agent expression data structures. */
+
/* A buffer containing a agent expression. */
struct agent_expr
{
+ /* Construct an empty agent expression. */
+ explicit agent_expr (struct gdbarch *gdbarch, CORE_ADDR scope);
+
+ ~agent_expr ();
+
+ /* The bytes of the expression. */
unsigned char *buf;
- int len; /* number of characters used */
- int size; /* allocated size */
+
+ /* The number of bytecode in the expression. */
+ int len;
+
+ /* Allocated space available currently. */
+ int size;
+
+ /* The target architecture assumed to be in effect. */
+ struct gdbarch *gdbarch;
+
+ /* The address to which the expression applies. */
CORE_ADDR scope;
- };
+ /* If the following is not equal to agent_flaw_none, the rest of the
+ information in this structure is suspect. */
+ enum agent_flaws flaw;
+
+ /* Number of elements left on stack at end; may be negative if expr
+ only consumes elements. */
+ int final_height;
+
+ /* Maximum and minimum stack height, relative to initial height. */
+ int max_height, min_height;
+
+ /* Largest `ref' or `const' opcode used, in bits. Zero means the
+ expression has no such instructions. */
+ int max_data_size;
+ /* Bit vector of registers needed. Register R is needed iff
+ reg_mask[R / 8] & (1 << (R % 8))
+
+ is non-zero. Note! You may not assume that this bitmask is long
+ enough to hold bits for all the registers of the machine; the
+ agent expression code has no idea how many registers the machine
+ has. However, the bitmask is reg_mask_len bytes long, so the
+ valid register numbers run from 0 to reg_mask_len * 8 - 1.
+
+ Also note that this mask may contain registers that are needed
+ for the original collection expression to work, but that are
+ not referenced by any bytecode. This could, for example, occur
+ when collecting a local variable allocated to a register; the
+ compiler sets the mask bit and skips generating a bytecode whose
+ result is going to be discarded anyway.
+ */
+ int reg_mask_len;
+ unsigned char *reg_mask;
+
+ /* For the data tracing facility, we need to insert `trace' bytecodes
+ before each data fetch; this records all the memory that the
+ expression touches in the course of evaluation, so that memory will
+ be available when the user later tries to evaluate the expression
+ in GDB.
+
+ Setting the flag 'tracing' to non-zero enables the code that
+ emits the trace bytecodes at the appropriate points. */
+
+ unsigned int tracing : 1;
+
+ /* This indicates that pointers to chars should get an added
+ tracenz bytecode to record nonzero bytes, up to a length that
+ is the value of trace_string. */
+
+ int trace_string;
+ };
-/* The actual values of the various bytecode operations.
+/* An agent_expr owning pointer. */
+typedef std::unique_ptr agent_expr_up;
- Other independent implementations of the agent bytecode engine will
- rely on the exact values of these enums, and may not be recompiled
- when we change this table. The numeric values should remain fixed
- whenever possible. Thus, we assign them values explicitly here (to
- allow gaps to form safely), and the disassembly table in
- agentexpr.h behaves like an opcode map. If you want to see them
- grouped logically, see doc/agentexpr.texi. */
+/* The actual values of the various bytecode operations. */
enum agent_op
{
- aop_float = 0x01,
- aop_add = 0x02,
- aop_sub = 0x03,
- aop_mul = 0x04,
- aop_div_signed = 0x05,
- aop_div_unsigned = 0x06,
- aop_rem_signed = 0x07,
- aop_rem_unsigned = 0x08,
- aop_lsh = 0x09,
- aop_rsh_signed = 0x0a,
- aop_rsh_unsigned = 0x0b,
- aop_trace = 0x0c,
- aop_trace_quick = 0x0d,
- aop_log_not = 0x0e,
- aop_bit_and = 0x0f,
- aop_bit_or = 0x10,
- aop_bit_xor = 0x11,
- aop_bit_not = 0x12,
- aop_equal = 0x13,
- aop_less_signed = 0x14,
- aop_less_unsigned = 0x15,
- aop_ext = 0x16,
- aop_ref8 = 0x17,
- aop_ref16 = 0x18,
- aop_ref32 = 0x19,
- aop_ref64 = 0x1a,
- aop_ref_float = 0x1b,
- aop_ref_double = 0x1c,
- aop_ref_long_double = 0x1d,
- aop_l_to_d = 0x1e,
- aop_d_to_l = 0x1f,
- aop_if_goto = 0x20,
- aop_goto = 0x21,
- aop_const8 = 0x22,
- aop_const16 = 0x23,
- aop_const32 = 0x24,
- aop_const64 = 0x25,
- aop_reg = 0x26,
- aop_end = 0x27,
- aop_dup = 0x28,
- aop_pop = 0x29,
- aop_zero_ext = 0x2a,
- aop_swap = 0x2b,
- aop_trace16 = 0x30,
+#define DEFOP(NAME, SIZE, DATA_SIZE, CONSUMED, PRODUCED, VALUE) \
+ aop_ ## NAME = VALUE,
+#include "gdbsupport/ax.def"
+#undef DEFOP
aop_last
};
@@ -138,16 +173,16 @@ enum agent_op
/* Functions for building expressions. */
-/* Allocate a new, empty agent expression. */
-extern struct agent_expr *new_agent_expr (CORE_ADDR);
-
-/* Free a agent expression. */
-extern void free_agent_expr (struct agent_expr *);
-extern struct cleanup *make_cleanup_free_agent_expr (struct agent_expr *);
+/* Append a raw byte to EXPR. */
+extern void ax_raw_byte (struct agent_expr *expr, gdb_byte byte);
/* Append a simple operator OP to EXPR. */
extern void ax_simple (struct agent_expr *EXPR, enum agent_op OP);
+/* Append a pick operator to EXPR. DEPTH is the stack item to pick,
+ with 0 being top of stack. */
+extern void ax_pick (struct agent_expr *EXPR, int DEPTH);
+
/* Append the floating-point prefix, for the next bytecode. */
#define ax_float(EXPR) (ax_simple ((EXPR), aop_float))
@@ -181,6 +216,15 @@ extern void ax_const_d (struct agent_expr *EXPR, LONGEST d);
/* Assemble code to push the value of register number REG on the
stack. */
extern void ax_reg (struct agent_expr *EXPR, int REG);
+
+/* Add the given register to the register mask of the expression. */
+extern void ax_reg_mask (struct agent_expr *ax, int reg);
+
+/* Assemble code to operate on a trace state variable. */
+extern void ax_tsv (struct agent_expr *expr, enum agent_op op, int num);
+
+/* Append a string to the bytecode stream. */
+extern void ax_string (struct agent_expr *x, const char *str, int slen);
/* Functions for printing out expressions, and otherwise debugging
@@ -195,7 +239,7 @@ struct aop_map
/* The name of the opcode. Null means that this entry is not a
valid opcode --- a hole in the opcode space. */
- char *name;
+ const char *name;
/* All opcodes take no operands from the bytecode stream, or take
unsigned integers of various sizes. If this is a positive number
@@ -219,72 +263,8 @@ struct aop_map
/* Map of the bytecodes, indexed by bytecode number. */
extern struct aop_map aop_map[];
-/* Different kinds of flaws an agent expression might have, as
- detected by agent_reqs. */
-enum agent_flaws
- {
- agent_flaw_none = 0, /* code is good */
-
- /* There is an invalid instruction in the stream. */
- agent_flaw_bad_instruction,
-
- /* There is an incomplete instruction at the end of the expression. */
- agent_flaw_incomplete_instruction,
-
- /* agent_reqs was unable to prove that every jump target is to a
- valid offset. Valid offsets are within the bounds of the
- expression, and to a valid instruction boundary. */
- agent_flaw_bad_jump,
-
- /* agent_reqs was unable to prove to its satisfaction that, for each
- jump target location, the stack will have the same height whether
- that location is reached via a jump or by straight execution. */
- agent_flaw_height_mismatch,
-
- /* agent_reqs was unable to prove that every instruction following
- an unconditional jump was the target of some other jump. */
- agent_flaw_hole
- };
-
-/* Structure describing the requirements of a bytecode expression. */
-struct agent_reqs
- {
-
- /* If the following is not equal to agent_flaw_none, the rest of the
- information in this structure is suspect. */
- enum agent_flaws flaw;
-
- /* Number of elements left on stack at end; may be negative if expr
- only consumes elements. */
- int final_height;
-
- /* Maximum and minimum stack height, relative to initial height. */
- int max_height, min_height;
-
- /* Largest `ref' or `const' opcode used, in bits. Zero means the
- expression has no such instructions. */
- int max_data_size;
-
- /* Bit vector of registers used. Register R is used iff
-
- reg_mask[R / 8] & (1 << (R % 8))
-
- is non-zero. Note! You may not assume that this bitmask is long
- enough to hold bits for all the registers of the machine; the
- agent expression code has no idea how many registers the machine
- has. However, the bitmask is reg_mask_len bytes long, so the
- valid register numbers run from 0 to reg_mask_len * 8 - 1.
-
- We're assuming eight-bit bytes. So sue me.
-
- The caller should free reg_list when done. */
- int reg_mask_len;
- unsigned char *reg_mask;
- };
-
+/* Given an agent expression AX, analyze and update its requirements. */
-/* Given an agent expression AX, fill in an agent_reqs structure REQS
- describing it. */
-extern void ax_reqs (struct agent_expr *ax, struct agent_reqs *reqs);
+extern void ax_reqs (struct agent_expr *ax);
-#endif /* AGENTEXPR_H */
+#endif /* AX_H */