2003-01-13 Andrew Cagney <ac131313@redhat.com>
* ax-gdb.c, c-valprint.c, charset.c, corefile.c: Update copyright.
* demangle.c, disasm.c, dwarf2cfi.c, dwarfread.c: Update copyright.
* elfread.c, eval.c, expprint.c, expression.h: Update copyright.
* f-typeprint.c, findvar.c, gcore.c, gdb_mbuild.sh: Update copyright.
* gdbtypes.h, gnu-v2-abi.c, inferior.h, inftarg.c: Update copyright.
* language.c, language.h, m32r-tdep.c: Update copyright.
* mn10200-tdep.c, scm-lang.c, scm-lang.h: Update copyright.
* somsolib.c, somsolib.h, symfile.c, symtab.h: Update copyright.
* thread-db.c, typeprint.c, utils.c, valarith.c: Update copyright.
* values.c, win32-nat.c, x86-64-linux-nat.c: Update copyright.
* x86-64-linux-tdep.c, z8k-tdep.c: Update copyright.
* cli/cli-decode.h, config/h8500/tm-h8500.h: Update copyright.
Index: mi/ChangeLog
2003-01-13 Andrew Cagney <ac131313@redhat.com>
* mi-cmd-env.c: Update copyright.
2003-01-14 01:49:06 +01:00
|
|
|
|
/* GDB-specific functions for operating on agent expressions.
|
|
|
|
|
|
2011-01-01 16:34:07 +01:00
|
|
|
|
Copyright (C) 1998, 1999, 2000, 2001, 2003, 2007, 2008, 2009, 2010, 2011
|
2007-01-09 18:59:20 +01:00
|
|
|
|
Free Software Foundation, Inc.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
This file is part of GDB.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
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
|
2007-08-23 20:08:50 +02:00
|
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
1999-07-07 22:19:36 +02:00
|
|
|
|
(at your option) any later version.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
You should have received a copy of the GNU General Public License
|
2007-08-23 20:08:50 +02:00
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
|
#include "symtab.h"
|
|
|
|
|
#include "symfile.h"
|
|
|
|
|
#include "gdbtypes.h"
|
2009-12-30 00:57:59 +01:00
|
|
|
|
#include "language.h"
|
1999-04-16 03:35:26 +02:00
|
|
|
|
#include "value.h"
|
|
|
|
|
#include "expression.h"
|
|
|
|
|
#include "command.h"
|
|
|
|
|
#include "gdbcmd.h"
|
|
|
|
|
#include "frame.h"
|
|
|
|
|
#include "target.h"
|
|
|
|
|
#include "ax.h"
|
|
|
|
|
#include "ax-gdb.h"
|
2002-08-28 00:37:14 +02:00
|
|
|
|
#include "gdb_string.h"
|
2003-02-19 David Carlton <carlton@math.stanford.edu>
* Makefile.in (SFILES): Add block.c.
(block_h): New.
(COMMON_OBS): Add block.o.
(block.o): New.
(x86-64-tdep.o): Add $(block_h).
(values.o, valops.o, tracepoint.o, symtab.o, symmisc.o, symfile.o)
(stack.o, printcmd.o, p-exp.tab.o, parse.o, objfiles.o)
(objc-exp.tab.o, objc-lang.o, nlmread.o, mips-tdep.o, mdebugread.o)
(m2-exp.tab.o, linespec.o, jv-lang.o, jv-exp.tab.o, infcmd.o)
(f-valprint.o, findvar.o, f-exp.tab.o, expprint.o, coffread.o)
(c-exp.tab.o, buildsym.o, breakpoint.o, blockframe.o, ax-gdb.o)
(alpha-tdep.o, ada-lang.o, ada-exp.tab.o, mi-cmd-stack.o): Ditto.
* value.h: Add opaque declaration for struct block.
* parser-defs.h, objc-lang.h, buildsym.h, breakpoint.h: Ditto.
* ada-lang.h: Ditto.
* x86-64-tdep.c: #include "block.h"
* values.c, valops.c, tracepoint.c, symtab.c, symmisc.c: Ditto.
* symfile.c, stack.c, printcmd.c, p-exp.y, parse.c: Ditto.
* objfiles.c, objc-exp.y, objc-lang.c, nlmread.c: Ditto.
* mips-tdep.c, mdebugread.c, m2-exp.y, linespec.c: Ditto.
* jv-lang.c, jv-exp.y, infcmd.c, f-valprint.c: Ditto.
* findvar.c, f-exp.y, expprint.c, coffread.c, c-exp.y: Ditto.
* buildsym.c, breakpoint.c, blockframe.c, ax-gdb.c: Ditto.
* alpha-tdep.c, ada-lang.c, ada-exp.y: Ditto.
* blockframe.c (blockvector_for_pc_sect): Move to "block.c".
(blockvector_for_pc, block_for_pc_sect, block_for_pc): Ditto.
* symtab.c (block_function): Ditto.
(contained_in): Ditto.
* frame.h: Move block_for_pc and block_for_pc_sect declarations to
block.h. Add opaque declaration for struct block.
* symtab.h: Move block_function and contained_in declarations to
block.h. Add opaque declarations for struct block, struct
blockvector.
(struct block): Move to block.h.
(struct blockvector): Ditto.
(BLOCK_START, BLOCK_END, BLOCK_FUNCTION, BLOCK_SUPERBLOCK)
(BLOCK_GCC_COMPILED, BLOCK_HASHTABLE, BLOCK_NSYMS, BLOCK_SYM)
(BLOCK_BUCKETS, BLOCK_BUCKET, BLOCK_HASHTABLE_SIZE)
(ALL_BLOCK_SYMBOLS, BLOCK_SHOULD_SORT, BLOCKVECTOR_NBLOCKS)
(BLOCKVECTOR_BLOCK, GLOBAL_BLOCK, STATIC_BLOCK, FIRST_LOCAL_BLOCK):
Ditto.
* block.c: New file.
* block.h: New file.
2003-02-19 David Carlton <carlton@math.stanford.edu>
* mi-cmd-stack.c: #include "block.h"
2003-02-20 01:01:07 +01:00
|
|
|
|
#include "block.h"
|
2003-03-01 18:03:19 +01:00
|
|
|
|
#include "regcache.h"
|
2008-08-21 22:13:08 +02:00
|
|
|
|
#include "user-regs.h"
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
#include "language.h"
|
2009-12-24 02:42:03 +01:00
|
|
|
|
#include "dictionary.h"
|
Add trace file support.
* tracepoint.h (enum trace_stop_reason): New enum.
(struct trace_status): New struct.
(parse_trace_status): Declare.
(struct uploaded_tp): Move here from remote.c,
add fields for actions.
(struct uploaded_tsv): New struct.
* tracepoint.c (tfile_ops): New target vector.
(trace_fd): New global.
(tfile_open): New function.
(tfile_close): New function.
(tfile_files_info): New function.
(tfile_get_trace_status): New function.
(tfile_get_traceframe_address): New function.
(tfile_trace_find): New function.
(tfile_fetch_registers): New function.
(tfile_xfer_partial): New function.
(tfile_get_trace_state_variable_value): New function.
(init_tfile_ops): New function.
(_initialize_tracepoint): Call it, add tfile target.
(trace_status): New global.
(current_trace_status): New function.
(trace_running_p): Remove, change all users to get from
current_trace_status()->running.
(get_trace_status): Remove.
(trace_status_command): Call target_get_trace_status directly,
report more detail including tracing stop reasons.
(trace_find_command): Always allow tfind on a file.
(trace_find_pc_command): Ditto.
(trace_find_tracepoint_command): Ditto.
(trace_find_line_command): Ditto.
(trace_find_range_command): Ditto.
(trace_find_outside_command): Ditto.
(trace_frames_offset, cur_offset): Declare as off_t.
(trace_regblock_size): Rename from reg_size, update users.
(parse_trace_status): New function.
(tfile_interp_line): New function.
(disconnect_or_stop_tracing): Ensure current trace
status before asking what to do.
(stop_reason_names): New global.
(trace_save_command): New command.
(get_uploaded_tp): Move here from remote.c.
(find_matching_tracepoint): Ditto.
(merge_uploaded_tracepoints): New function.
(parse_trace_status): Use stop_reason_names.
(_initialize_tracepoint): Define tsave command.
* target.h (target_ops): New fields to_save_trace_data,
to_upload_tracepoints, to_upload_trace_state_variables,
to_get_raw_trace_data, change to_get_trace_status
to take a pointer to a status struct.
(target_save_trace_data): New macro.
(target_upload_tracepoints): New macro.
(target_upload_trace_state_variables): New macro.
(target_get_raw_trace_data): New macro.
* target.c (update_current_target): Add new methods, change
signature of to_get_trace_status.
* remote.c (hex2bin): Make globally visible.
(bin2hex): Ditto.
(remote_download_trace_state_variable): Download name also.
(remote_get_trace_status): Update parameter, use
parse_trace_status.
(remote_save_trace_data): New function.
(remote_upload_tracepoints): New function.
(remote_upload_trace_state_variables): New function.
(remote_get_raw_trace_data): New function.
(remote_start_remote): Use them.
(_initialize_remote_ops): Add operations.
* ax-gdb.c: Include breakpoint.h.
* breakpoint.c (create_tracepoint_from_upload): Use
break_command_really, return tracepoint, warn about unimplemented
parts.
* NEWS: Mention trace file addition.
* gdb.texinfo (Trace Files): New section.
(Tracepoint Packets): Document QTSave and qTBuffer.
(Trace File Format): New appendix.
* generic/gdbtk-bp.c (gdb_trace_status): Use current_trace_status.
* gdb.trace/tfile.c: New file.
* gdb.trace/tfile.exp: New file.
2010-01-15 23:37:20 +01:00
|
|
|
|
#include "breakpoint.h"
|
2009-12-29 00:39:10 +01:00
|
|
|
|
#include "tracepoint.h"
|
2010-03-16 00:53:21 +01:00
|
|
|
|
#include "cp-support.h"
|
2011-09-27 15:09:37 +02:00
|
|
|
|
#include "arch-utils.h"
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-09-28 23:55:21 +02:00
|
|
|
|
/* To make sense of this file, you should read doc/agentexpr.texi.
|
|
|
|
|
Then look at the types and enums in ax-gdb.h. For the code itself,
|
|
|
|
|
look at gen_expr, towards the bottom; that's the main function that
|
|
|
|
|
looks at the GDB expressions and calls everything else to generate
|
|
|
|
|
code.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
I'm beginning to wonder whether it wouldn't be nicer to internally
|
|
|
|
|
generate trees, with types, and then spit out the bytecode in
|
|
|
|
|
linear form afterwards; we could generate fewer `swap', `ext', and
|
|
|
|
|
`zero_ext' bytecodes that way; it would make good constant folding
|
|
|
|
|
easier, too. But at the moment, I think we should be willing to
|
|
|
|
|
pay for the simplicity of this code with less-than-optimal bytecode
|
|
|
|
|
strings.
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
Remember, "GBD" stands for "Great Britain, Dammit!" So be careful. */
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
2010-12-31 20:16:37 +01:00
|
|
|
|
/* Prototypes for local functions. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* There's a standard order to the arguments of these functions:
|
|
|
|
|
union exp_element ** --- pointer into expression
|
|
|
|
|
struct agent_expr * --- agent expression buffer to generate code into
|
|
|
|
|
struct axs_value * --- describes value left on top of stack */
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
|
static struct value *const_var_ref (struct symbol *var);
|
|
|
|
|
static struct value *const_expr (union exp_element **pc);
|
|
|
|
|
static struct value *maybe_const_expr (union exp_element **pc);
|
|
|
|
|
|
2011-01-05 23:22:53 +01:00
|
|
|
|
static void gen_traced_pop (struct gdbarch *, struct agent_expr *,
|
|
|
|
|
struct axs_value *);
|
2000-05-28 03:12:42 +02:00
|
|
|
|
|
|
|
|
|
static void gen_sign_extend (struct agent_expr *, struct type *);
|
|
|
|
|
static void gen_extend (struct agent_expr *, struct type *);
|
|
|
|
|
static void gen_fetch (struct agent_expr *, struct type *);
|
|
|
|
|
static void gen_left_shift (struct agent_expr *, int);
|
|
|
|
|
|
|
|
|
|
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
static void gen_frame_args_address (struct gdbarch *, struct agent_expr *);
|
|
|
|
|
static void gen_frame_locals_address (struct gdbarch *, struct agent_expr *);
|
2000-05-28 03:12:42 +02:00
|
|
|
|
static void gen_offset (struct agent_expr *ax, int offset);
|
|
|
|
|
static void gen_sym_offset (struct agent_expr *, struct symbol *);
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
static void gen_var_ref (struct gdbarch *, struct agent_expr *ax,
|
2000-05-28 03:12:42 +02:00
|
|
|
|
struct axs_value *value, struct symbol *var);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void gen_int_literal (struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value,
|
|
|
|
|
LONGEST k, struct type *type);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void require_rvalue (struct agent_expr *ax, struct axs_value *value);
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
static void gen_usual_unary (struct expression *exp, struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value);
|
2000-05-28 03:12:42 +02:00
|
|
|
|
static int type_wider_than (struct type *type1, struct type *type2);
|
|
|
|
|
static struct type *max_type (struct type *type1, struct type *type2);
|
|
|
|
|
static void gen_conversion (struct agent_expr *ax,
|
|
|
|
|
struct type *from, struct type *to);
|
|
|
|
|
static int is_nontrivial_conversion (struct type *from, struct type *to);
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
static void gen_usual_arithmetic (struct expression *exp,
|
|
|
|
|
struct agent_expr *ax,
|
2000-05-28 03:12:42 +02:00
|
|
|
|
struct axs_value *value1,
|
|
|
|
|
struct axs_value *value2);
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
static void gen_integral_promotions (struct expression *exp,
|
|
|
|
|
struct agent_expr *ax,
|
2000-05-28 03:12:42 +02:00
|
|
|
|
struct axs_value *value);
|
|
|
|
|
static void gen_cast (struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value, struct type *type);
|
|
|
|
|
static void gen_scale (struct agent_expr *ax,
|
|
|
|
|
enum agent_op op, struct type *type);
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
static void gen_ptradd (struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct axs_value *value1, struct axs_value *value2);
|
|
|
|
|
static void gen_ptrsub (struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct axs_value *value1, struct axs_value *value2);
|
|
|
|
|
static void gen_ptrdiff (struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct axs_value *value1, struct axs_value *value2,
|
|
|
|
|
struct type *result_type);
|
2000-05-28 03:12:42 +02:00
|
|
|
|
static void gen_binop (struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value,
|
|
|
|
|
struct axs_value *value1,
|
|
|
|
|
struct axs_value *value2,
|
|
|
|
|
enum agent_op op,
|
|
|
|
|
enum agent_op op_unsigned, int may_carry, char *name);
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
static void gen_logical_not (struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct type *result_type);
|
2000-05-28 03:12:42 +02:00
|
|
|
|
static void gen_complement (struct agent_expr *ax, struct axs_value *value);
|
|
|
|
|
static void gen_deref (struct agent_expr *, struct axs_value *);
|
|
|
|
|
static void gen_address_of (struct agent_expr *, struct axs_value *);
|
2009-06-17 20:40:53 +02:00
|
|
|
|
static void gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
|
2000-05-28 03:12:42 +02:00
|
|
|
|
struct axs_value *value,
|
|
|
|
|
struct type *type, int start, int end);
|
2010-03-16 00:53:21 +01:00
|
|
|
|
static void gen_primitive_field (struct expression *exp,
|
|
|
|
|
struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value,
|
|
|
|
|
int offset, int fieldno, struct type *type);
|
|
|
|
|
static int gen_struct_ref_recursive (struct expression *exp,
|
|
|
|
|
struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value,
|
|
|
|
|
char *field, int offset,
|
|
|
|
|
struct type *type);
|
2009-06-17 20:40:53 +02:00
|
|
|
|
static void gen_struct_ref (struct expression *exp, struct agent_expr *ax,
|
2000-05-28 03:12:42 +02:00
|
|
|
|
struct axs_value *value,
|
|
|
|
|
char *field,
|
|
|
|
|
char *operator_name, char *operand_name);
|
2010-03-17 23:04:43 +01:00
|
|
|
|
static void gen_static_field (struct gdbarch *gdbarch,
|
2010-03-16 00:53:21 +01:00
|
|
|
|
struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct type *type, int fieldno);
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
static void gen_repeat (struct expression *exp, union exp_element **pc,
|
2000-05-28 03:12:42 +02:00
|
|
|
|
struct agent_expr *ax, struct axs_value *value);
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
static void gen_sizeof (struct expression *exp, union exp_element **pc,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct type *size_type);
|
|
|
|
|
static void gen_expr (struct expression *exp, union exp_element **pc,
|
2000-05-28 03:12:42 +02:00
|
|
|
|
struct agent_expr *ax, struct axs_value *value);
|
2009-12-29 00:39:10 +01:00
|
|
|
|
static void gen_expr_binop_rest (struct expression *exp,
|
|
|
|
|
enum exp_opcode op, union exp_element **pc,
|
|
|
|
|
struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value,
|
|
|
|
|
struct axs_value *value1,
|
|
|
|
|
struct axs_value *value2);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
|
static void agent_command (char *exp, int from_tty);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Detecting constant expressions. */
|
|
|
|
|
|
|
|
|
|
/* If the variable reference at *PC is a constant, return its value.
|
|
|
|
|
Otherwise, return zero.
|
|
|
|
|
|
|
|
|
|
Hey, Wally! How can a variable reference be a constant?
|
|
|
|
|
|
|
|
|
|
Well, Beav, this function really handles the OP_VAR_VALUE operator,
|
|
|
|
|
not specifically variable references. GDB uses OP_VAR_VALUE to
|
|
|
|
|
refer to any kind of symbolic reference: function names, enum
|
|
|
|
|
elements, and goto labels are all handled through the OP_VAR_VALUE
|
|
|
|
|
operator, even though they're constants. It makes sense given the
|
|
|
|
|
situation.
|
|
|
|
|
|
|
|
|
|
Gee, Wally, don'cha wonder sometimes if data representations that
|
|
|
|
|
subvert commonly accepted definitions of terms in favor of heavily
|
|
|
|
|
context-specific interpretations are really just a tool of the
|
|
|
|
|
programming hegemony to preserve their power and exclude the
|
|
|
|
|
proletariat? */
|
|
|
|
|
|
|
|
|
|
static struct value *
|
2000-07-30 03:48:28 +02:00
|
|
|
|
const_var_ref (struct symbol *var)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
struct type *type = SYMBOL_TYPE (var);
|
|
|
|
|
|
|
|
|
|
switch (SYMBOL_CLASS (var))
|
|
|
|
|
{
|
|
|
|
|
case LOC_CONST:
|
|
|
|
|
return value_from_longest (type, (LONGEST) SYMBOL_VALUE (var));
|
|
|
|
|
|
|
|
|
|
case LOC_LABEL:
|
* gdbarch.sh (POINTER_TO_ADDRESS, ADDRESS_TO_POINTER): Two new
functions which architectures can redefine, defaulting to
generic_pointer_to_address and generic_address_to_pointer.
* findvar.c (extract_typed_address, store_typed_address,
generic_pointer_to_address, generic_address_to_pointer): New
functions.
(POINTER_TO_ADDRESS, ADDRESS_TO_POINTER): Provide default
definitions.
(extract_address, store_address): Doc fixes.
* values.c (value_as_pointer): Doc fix.
(value_from_pointer): New function.
* defs.h (extract_typed_address, store_typed_address): New
declarations.
* inferior.h (generic_address_to_pointer,
generic_pointer_to_address): New declarations.
* value.h (value_from_pointer): New declaration.
* ax-gdb.c (const_var_ref): Use value_from_pointer, not
value_from_longest.
* blockframe.c (generic_push_dummy_frame): Use read_pc and
read_sp, not read_register.
* c-valprint.c (c_val_print): Use extract_typed_address instead of
extract_address to extract vtable entries and references.
* cp-valprint.c (cp_print_value_fields): Use value_from_pointer
instead of value_from_longest to extract the vtable's address.
* eval.c (evaluate_subexp_standard): Use value_from_pointer
instead of value_from_longest to compute `this', and for doing
pointer-to-member dereferencing.
* findvar.c (read_register): Use extract_unsigned_integer, not
extract_address.
(read_var_value): Use store_typed_address instead of store_address
for building label values.
(locate_var_value): Use value_from_pointer instead of
value_from_longest.
* hppa-tdep.c (find_stub_with_shl_get): Use value_from_pointer,
instead of value_from_longest, to build arguments to __d_shl_get.
* printcmd.c (set_next_address): Use value_from_pointer, not
value_from_longest.
(x_command): Use value_from_pointer, not value_from_longest.
* tracepoint.c (set_traceframe_context): Use value_from_pointer,
not value_from_longest.
* valarith.c (value_add, value_sub): Use value_from_pointer, not
value_from_longest.
* valops.c (find_function_in_inferior, value_coerce_array,
value_coerce_function, value_addr, hand_function_call): Same.
* value.h (COERCE_REF): Use unpack_pointer, not unpack_long.
* values.c (unpack_long): Use extract_typed_address to produce
addresses from pointers and references, not extract_address.
(value_from_longest): Use store_typed_address instead of
store_address to produce pointer and reference values.
2000-04-14 20:43:41 +02:00
|
|
|
|
return value_from_pointer (type, (CORE_ADDR) SYMBOL_VALUE_ADDRESS (var));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* If the expression starting at *PC has a constant value, return it.
|
|
|
|
|
Otherwise, return zero. If we return a value, then *PC will be
|
|
|
|
|
advanced to the end of it. If we return zero, *PC could be
|
|
|
|
|
anywhere. */
|
|
|
|
|
static struct value *
|
2000-07-30 03:48:28 +02:00
|
|
|
|
const_expr (union exp_element **pc)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
enum exp_opcode op = (*pc)->opcode;
|
|
|
|
|
struct value *v1;
|
|
|
|
|
|
|
|
|
|
switch (op)
|
|
|
|
|
{
|
|
|
|
|
case OP_LONG:
|
|
|
|
|
{
|
|
|
|
|
struct type *type = (*pc)[1].type;
|
|
|
|
|
LONGEST k = (*pc)[2].longconst;
|
2010-05-18 21:23:37 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
(*pc) += 4;
|
|
|
|
|
return value_from_longest (type, k);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case OP_VAR_VALUE:
|
|
|
|
|
{
|
|
|
|
|
struct value *v = const_var_ref ((*pc)[2].symbol);
|
2010-05-18 21:23:37 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
(*pc) += 4;
|
|
|
|
|
return v;
|
|
|
|
|
}
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
/* We could add more operators in here. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case UNOP_NEG:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
v1 = const_expr (pc);
|
|
|
|
|
if (v1)
|
|
|
|
|
return value_neg (v1);
|
|
|
|
|
else
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Like const_expr, but guarantee also that *PC is undisturbed if the
|
|
|
|
|
expression is not constant. */
|
|
|
|
|
static struct value *
|
2000-07-30 03:48:28 +02:00
|
|
|
|
maybe_const_expr (union exp_element **pc)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
union exp_element *tentative_pc = *pc;
|
|
|
|
|
struct value *v = const_expr (&tentative_pc);
|
|
|
|
|
|
|
|
|
|
/* If we got a value, then update the real PC. */
|
|
|
|
|
if (v)
|
|
|
|
|
*pc = tentative_pc;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
return v;
|
|
|
|
|
}
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Generating bytecode from GDB expressions: general assumptions */
|
|
|
|
|
|
|
|
|
|
/* Here are a few general assumptions made throughout the code; if you
|
|
|
|
|
want to make a change that contradicts one of these, then you'd
|
|
|
|
|
better scan things pretty thoroughly.
|
|
|
|
|
|
|
|
|
|
- We assume that all values occupy one stack element. For example,
|
1999-07-07 22:19:36 +02:00
|
|
|
|
sometimes we'll swap to get at the left argument to a binary
|
|
|
|
|
operator. If we decide that void values should occupy no stack
|
|
|
|
|
elements, or that synthetic arrays (whose size is determined at
|
|
|
|
|
run time, created by the `@' operator) should occupy two stack
|
|
|
|
|
elements (address and length), then this will cause trouble.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
- We assume the stack elements are infinitely wide, and that we
|
1999-07-07 22:19:36 +02:00
|
|
|
|
don't have to worry what happens if the user requests an
|
|
|
|
|
operation that is wider than the actual interpreter's stack.
|
|
|
|
|
That is, it's up to the interpreter to handle directly all the
|
|
|
|
|
integer widths the user has access to. (Woe betide the language
|
|
|
|
|
with bignums!)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
- We don't support side effects. Thus, we don't have to worry about
|
1999-07-07 22:19:36 +02:00
|
|
|
|
GCC's generalized lvalues, function calls, etc.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
- We don't support floating point. Many places where we switch on
|
1999-07-07 22:19:36 +02:00
|
|
|
|
some type don't bother to include cases for floating point; there
|
|
|
|
|
may be even more subtle ways this assumption exists. For
|
|
|
|
|
example, the arguments to % must be integers.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
- We assume all subexpressions have a static, unchanging type. If
|
1999-07-07 22:19:36 +02:00
|
|
|
|
we tried to support convenience variables, this would be a
|
|
|
|
|
problem.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
- All values on the stack should always be fully zero- or
|
1999-07-07 22:19:36 +02:00
|
|
|
|
sign-extended.
|
|
|
|
|
|
|
|
|
|
(I wasn't sure whether to choose this or its opposite --- that
|
|
|
|
|
only addresses are assumed extended --- but it turns out that
|
|
|
|
|
neither convention completely eliminates spurious extend
|
|
|
|
|
operations (if everything is always extended, then you have to
|
|
|
|
|
extend after add, because it could overflow; if nothing is
|
|
|
|
|
extended, then you end up producing extends whenever you change
|
|
|
|
|
sizes), and this is simpler.) */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Generating bytecode from GDB expressions: the `trace' kludge */
|
|
|
|
|
|
|
|
|
|
/* The compiler in this file is a general-purpose mechanism for
|
|
|
|
|
translating GDB expressions into bytecode. One ought to be able to
|
|
|
|
|
find a million and one uses for it.
|
|
|
|
|
|
|
|
|
|
However, at the moment it is HOPELESSLY BRAIN-DAMAGED for the sake
|
|
|
|
|
of expediency. Let he who is without sin cast the first stone.
|
|
|
|
|
|
|
|
|
|
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.
|
|
|
|
|
|
|
|
|
|
This should be done (I think) in a post-processing pass, that walks
|
|
|
|
|
an arbitrary agent expression and inserts `trace' operations at the
|
|
|
|
|
appropriate points. But it's much faster to just hack them
|
|
|
|
|
directly into the code. And since we're in a crunch, that's what
|
|
|
|
|
I've done.
|
|
|
|
|
|
|
|
|
|
Setting the flag trace_kludge to non-zero enables the code that
|
|
|
|
|
emits the trace bytecodes at the appropriate points. */
|
2010-04-20 20:52:59 +02:00
|
|
|
|
int trace_kludge;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2010-03-17 23:04:43 +01:00
|
|
|
|
/* Scan for all static fields in the given class, including any base
|
|
|
|
|
classes, and generate tracing bytecodes for each. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gen_trace_static_fields (struct gdbarch *gdbarch,
|
|
|
|
|
struct agent_expr *ax,
|
|
|
|
|
struct type *type)
|
|
|
|
|
{
|
|
|
|
|
int i, nbases = TYPE_N_BASECLASSES (type);
|
|
|
|
|
struct axs_value value;
|
|
|
|
|
|
|
|
|
|
CHECK_TYPEDEF (type);
|
|
|
|
|
|
|
|
|
|
for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
|
|
|
|
|
{
|
|
|
|
|
if (field_is_static (&TYPE_FIELD (type, i)))
|
|
|
|
|
{
|
|
|
|
|
gen_static_field (gdbarch, ax, &value, type, i);
|
|
|
|
|
if (value.optimized_out)
|
|
|
|
|
continue;
|
|
|
|
|
switch (value.kind)
|
|
|
|
|
{
|
|
|
|
|
case axs_lvalue_memory:
|
|
|
|
|
{
|
|
|
|
|
int length = TYPE_LENGTH (check_typedef (value.type));
|
|
|
|
|
|
|
|
|
|
ax_const_l (ax, length);
|
|
|
|
|
ax_simple (ax, aop_trace);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case axs_lvalue_register:
|
2010-04-24 01:51:05 +02:00
|
|
|
|
/* We don't actually need the register's value to be pushed,
|
|
|
|
|
just note that we need it to be collected. */
|
|
|
|
|
ax_reg_mask (ax, value.u.reg);
|
2010-03-17 23:04:43 +01:00
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Now scan through base classes recursively. */
|
|
|
|
|
for (i = 0; i < nbases; i++)
|
|
|
|
|
{
|
|
|
|
|
struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
|
|
|
|
|
|
|
|
|
|
gen_trace_static_fields (gdbarch, ax, basetype);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Trace the lvalue on the stack, if it needs it. In either case, pop
|
|
|
|
|
the value. Useful on the left side of a comma, and at the end of
|
|
|
|
|
an expression being used for tracing. */
|
|
|
|
|
static void
|
2010-03-17 23:04:43 +01:00
|
|
|
|
gen_traced_pop (struct gdbarch *gdbarch,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
if (trace_kludge)
|
|
|
|
|
switch (value->kind)
|
|
|
|
|
{
|
|
|
|
|
case axs_rvalue:
|
|
|
|
|
/* We don't trace rvalues, just the lvalues necessary to
|
1999-07-07 22:19:36 +02:00
|
|
|
|
produce them. So just dispose of this value. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ax_simple (ax, aop_pop);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case axs_lvalue_memory:
|
|
|
|
|
{
|
2007-10-27 01:04:57 +02:00
|
|
|
|
int length = TYPE_LENGTH (check_typedef (value->type));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* There's no point in trying to use a trace_quick bytecode
|
|
|
|
|
here, since "trace_quick SIZE pop" is three bytes, whereas
|
|
|
|
|
"const8 SIZE trace" is also three bytes, does the same
|
|
|
|
|
thing, and the simplest code which generates that will also
|
|
|
|
|
work correctly for objects with large sizes. */
|
|
|
|
|
ax_const_l (ax, length);
|
|
|
|
|
ax_simple (ax, aop_trace);
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case axs_lvalue_register:
|
2010-04-24 01:51:05 +02:00
|
|
|
|
/* We don't actually need the register's value to be on the
|
|
|
|
|
stack, and the target will get heartburn if the register is
|
|
|
|
|
larger than will fit in a stack, so just mark it for
|
|
|
|
|
collection and be done with it. */
|
|
|
|
|
ax_reg_mask (ax, value->u.reg);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
/* If we're not tracing, just pop the value. */
|
|
|
|
|
ax_simple (ax, aop_pop);
|
2010-03-17 23:04:43 +01:00
|
|
|
|
|
|
|
|
|
/* To trace C++ classes with static fields stored elsewhere. */
|
|
|
|
|
if (trace_kludge
|
|
|
|
|
&& (TYPE_CODE (value->type) == TYPE_CODE_STRUCT
|
|
|
|
|
|| TYPE_CODE (value->type) == TYPE_CODE_UNION))
|
|
|
|
|
gen_trace_static_fields (gdbarch, ax, value->type);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generating bytecode from GDB expressions: helper functions */
|
|
|
|
|
|
|
|
|
|
/* Assume that the lower bits of the top of the stack is a value of
|
|
|
|
|
type TYPE, and the upper bits are zero. Sign-extend if necessary. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_sign_extend (struct agent_expr *ax, struct type *type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Do we need to sign-extend this? */
|
1999-07-07 22:19:36 +02:00
|
|
|
|
if (!TYPE_UNSIGNED (type))
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
ax_ext (ax, TYPE_LENGTH (type) * TARGET_CHAR_BIT);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Assume the lower bits of the top of the stack hold a value of type
|
|
|
|
|
TYPE, and the upper bits are garbage. Sign-extend or truncate as
|
|
|
|
|
needed. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_extend (struct agent_expr *ax, struct type *type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
int bits = TYPE_LENGTH (type) * TARGET_CHAR_BIT;
|
2010-05-18 21:23:37 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* I just had to. */
|
|
|
|
|
((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Assume that the top of the stack contains a value of type "pointer
|
|
|
|
|
to TYPE"; generate code to fetch its value. Note that TYPE is the
|
|
|
|
|
target type, not the pointer type. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_fetch (struct agent_expr *ax, struct type *type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
if (trace_kludge)
|
|
|
|
|
{
|
|
|
|
|
/* Record the area of memory we're about to fetch. */
|
|
|
|
|
ax_trace_quick (ax, TYPE_LENGTH (type));
|
|
|
|
|
}
|
|
|
|
|
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
switch (TYPE_CODE (type))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
case TYPE_CODE_PTR:
|
2009-12-30 00:57:59 +01:00
|
|
|
|
case TYPE_CODE_REF:
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case TYPE_CODE_ENUM:
|
|
|
|
|
case TYPE_CODE_INT:
|
|
|
|
|
case TYPE_CODE_CHAR:
|
2010-03-19 23:00:17 +01:00
|
|
|
|
case TYPE_CODE_BOOL:
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* It's a scalar value, so we know how to dereference it. How
|
|
|
|
|
many bytes long is it? */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
switch (TYPE_LENGTH (type))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
case 8 / TARGET_CHAR_BIT:
|
|
|
|
|
ax_simple (ax, aop_ref8);
|
|
|
|
|
break;
|
|
|
|
|
case 16 / TARGET_CHAR_BIT:
|
|
|
|
|
ax_simple (ax, aop_ref16);
|
|
|
|
|
break;
|
|
|
|
|
case 32 / TARGET_CHAR_BIT:
|
|
|
|
|
ax_simple (ax, aop_ref32);
|
|
|
|
|
break;
|
|
|
|
|
case 64 / TARGET_CHAR_BIT:
|
|
|
|
|
ax_simple (ax, aop_ref64);
|
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Either our caller shouldn't have asked us to dereference
|
|
|
|
|
that pointer (other code's fault), or we're not
|
|
|
|
|
implementing something we should be (this code's fault).
|
|
|
|
|
In any case, it's a bug the user shouldn't see. */
|
|
|
|
|
default:
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("gen_fetch: strange size"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
gen_sign_extend (ax, type);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
/* Either our caller shouldn't have asked us to dereference that
|
1999-07-07 22:19:36 +02:00
|
|
|
|
pointer (other code's fault), or we're not implementing
|
|
|
|
|
something we should be (this code's fault). In any case,
|
|
|
|
|
it's a bug the user shouldn't see. */
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("gen_fetch: bad type code"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code to left shift the top of the stack by DISTANCE bits, or
|
|
|
|
|
right shift it by -DISTANCE bits if DISTANCE < 0. This generates
|
|
|
|
|
unsigned (logical) right shifts. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_left_shift (struct agent_expr *ax, int distance)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
if (distance > 0)
|
|
|
|
|
{
|
|
|
|
|
ax_const_l (ax, distance);
|
|
|
|
|
ax_simple (ax, aop_lsh);
|
|
|
|
|
}
|
|
|
|
|
else if (distance < 0)
|
|
|
|
|
{
|
|
|
|
|
ax_const_l (ax, -distance);
|
|
|
|
|
ax_simple (ax, aop_rsh_unsigned);
|
|
|
|
|
}
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generating bytecode from GDB expressions: symbol references */
|
|
|
|
|
|
|
|
|
|
/* Generate code to push the base address of the argument portion of
|
|
|
|
|
the top stack frame. */
|
|
|
|
|
static void
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_frame_args_address (struct gdbarch *gdbarch, struct agent_expr *ax)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2001-08-11 02:59:29 +02:00
|
|
|
|
int frame_reg;
|
|
|
|
|
LONGEST frame_offset;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gdbarch_virtual_frame_pointer (gdbarch,
|
2007-06-12 18:43:39 +02:00
|
|
|
|
ax->scope, &frame_reg, &frame_offset);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
ax_reg (ax, frame_reg);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_offset (ax, frame_offset);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code to push the base address of the locals portion of the
|
|
|
|
|
top stack frame. */
|
|
|
|
|
static void
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_frame_locals_address (struct gdbarch *gdbarch, struct agent_expr *ax)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2001-08-11 02:59:29 +02:00
|
|
|
|
int frame_reg;
|
|
|
|
|
LONGEST frame_offset;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gdbarch_virtual_frame_pointer (gdbarch,
|
2007-06-12 18:43:39 +02:00
|
|
|
|
ax->scope, &frame_reg, &frame_offset);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
ax_reg (ax, frame_reg);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_offset (ax, frame_offset);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code to add OFFSET to the top of the stack. Try to
|
|
|
|
|
generate short and readable code. We use this for getting to
|
|
|
|
|
variables on the stack, and structure members. If we were
|
|
|
|
|
programming in ML, it would be clearer why these are the same
|
|
|
|
|
thing. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_offset (struct agent_expr *ax, int offset)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* It would suffice to simply push the offset and add it, but this
|
|
|
|
|
makes it easier to read positive and negative offsets in the
|
|
|
|
|
bytecode. */
|
|
|
|
|
if (offset > 0)
|
|
|
|
|
{
|
|
|
|
|
ax_const_l (ax, offset);
|
|
|
|
|
ax_simple (ax, aop_add);
|
|
|
|
|
}
|
|
|
|
|
else if (offset < 0)
|
|
|
|
|
{
|
|
|
|
|
ax_const_l (ax, -offset);
|
|
|
|
|
ax_simple (ax, aop_sub);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* In many cases, a symbol's value is the offset from some other
|
|
|
|
|
address (stack frame, base register, etc.) Generate code to add
|
|
|
|
|
VAR's value to the top of the stack. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_sym_offset (struct agent_expr *ax, struct symbol *var)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
gen_offset (ax, SYMBOL_VALUE (var));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code for a variable reference to AX. The variable is the
|
|
|
|
|
symbol VAR. Set VALUE to describe the result. */
|
|
|
|
|
|
|
|
|
|
static void
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_var_ref (struct gdbarch *gdbarch, struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value, struct symbol *var)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2010-12-31 20:16:37 +01:00
|
|
|
|
/* Dereference any typedefs. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->type = check_typedef (SYMBOL_TYPE (var));
|
2010-03-17 23:04:43 +01:00
|
|
|
|
value->optimized_out = 0;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* I'm imitating the code in read_var_value. */
|
|
|
|
|
switch (SYMBOL_CLASS (var))
|
|
|
|
|
{
|
|
|
|
|
case LOC_CONST: /* A constant, like an enum value. */
|
|
|
|
|
ax_const_l (ax, (LONGEST) SYMBOL_VALUE (var));
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_LABEL: /* A goto label, being used as a value. */
|
|
|
|
|
ax_const_l (ax, (LONGEST) SYMBOL_VALUE_ADDRESS (var));
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_CONST_BYTES:
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2011-01-05 23:22:53 +01:00
|
|
|
|
_("gen_var_ref: LOC_CONST_BYTES "
|
|
|
|
|
"symbols are not supported"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Variable at a fixed location in memory. Easy. */
|
|
|
|
|
case LOC_STATIC:
|
|
|
|
|
/* Push the address of the variable. */
|
|
|
|
|
ax_const_l (ax, SYMBOL_VALUE_ADDRESS (var));
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_ARG: /* var lives in argument area of frame */
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_frame_args_address (gdbarch, ax);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_sym_offset (ax, var);
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_REF_ARG: /* As above, but the frame slot really
|
|
|
|
|
holds the address of the variable. */
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_frame_args_address (gdbarch, ax);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_sym_offset (ax, var);
|
|
|
|
|
/* Don't assume any particular pointer size. */
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_fetch (ax, builtin_type (gdbarch)->builtin_data_ptr);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_LOCAL: /* var lives in locals area of frame */
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_frame_locals_address (gdbarch, ax);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_sym_offset (ax, var);
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_TYPEDEF:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Cannot compute value of typedef `%s'."),
|
2003-02-20 David Carlton <carlton@math.stanford.edu>
* symtab.h (SYMBOL_PRINT_NAME): Rename from SYMBOL_SOURCE_NAME;
expand comment.
* ada-lang.c (user_select_syms, ada_finish_decode_line_1): Replace
SYMBOL_PRINT_NAME with SYMBOL_SOURCE_NAME.
* ada-typeprint.c (ada_typedef_print): Ditto.
* ax-gdb.c (gen_var_ref): Ditto.
* breakpoint.c (print_one_breakpoint): Ditto.
* buildsym.c (finish_block): Ditto.
* c-valprint.c (c_val_print): Ditto.
* expprint.c (print_subexp): Ditto.
* findvar.c (locate_var_value): Ditto.
* infcmd.c (jump_command): Ditto.
* linespec.c (decode_line_2, decode_compound): Ditto.
* maint.c (maintenance_translate_address): Ditto.
* objc-lang.c (compare_selectors, compare_classes): Ditto.
* printcmd.c (build_address_symbolic, sym_info, print_frame_args):
Ditto.
* p-valprint.c (pascal_val_print): Ditto.
* stabsread.c (define_symbol): Ditto.
* stack.c (print_frame, frame_info, print_block_frame_locals)
(print_frame_arg_vars, return_command): Ditto.
* symfile.c (compare_symbols, compare_psymbols): Ditto.
* symmisc.c (print_symbol): Ditto.
* symtab.c (lookup_partial_symbol, lookup_block_symbol)
(compare_search_syms, print_symbol_info, print_msymbol_info)
(rbreak_command): Ditto.
* tracepoint.c (tracepoints_info): Ditto.
* typeprint.c (typedef_print): Ditto.
* valops.c (value_of_variable, hand_function_call): Ditto.
* cli/cli-cmds.c (edit_command, list_command): Ditto.
* ada-typeprint.c: Update Copyright.
* infcmd.c, objc-lang.c, p-valprint.c, symmisc.c: Ditto.
* tracepoint.c, cli/cli-cmds.c: Ditto.
2003-02-20 18:17:25 +01:00
|
|
|
|
SYMBOL_PRINT_NAME (var));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_BLOCK:
|
|
|
|
|
ax_const_l (ax, BLOCK_START (SYMBOL_BLOCK_VALUE (var)));
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_REGISTER:
|
|
|
|
|
/* Don't generate any code at all; in the process of treating
|
|
|
|
|
this as an lvalue or rvalue, the caller will generate the
|
|
|
|
|
right code. */
|
|
|
|
|
value->kind = axs_lvalue_register;
|
2009-06-04 14:28:39 +02:00
|
|
|
|
value->u.reg = SYMBOL_REGISTER_OPS (var)->register_number (var, gdbarch);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* A lot like LOC_REF_ARG, but the pointer lives directly in a
|
2008-05-27 21:29:52 +02:00
|
|
|
|
register, not on the stack. Simpler than LOC_REGISTER
|
|
|
|
|
because it's just like any other case where the thing
|
|
|
|
|
has a real address. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case LOC_REGPARM_ADDR:
|
2009-06-04 14:28:39 +02:00
|
|
|
|
ax_reg (ax, SYMBOL_REGISTER_OPS (var)->register_number (var, gdbarch));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case LOC_UNRESOLVED:
|
|
|
|
|
{
|
1999-07-07 22:19:36 +02:00
|
|
|
|
struct minimal_symbol *msym
|
* ax-gdb.c (gen_var_ref): Use SYMBOL_LINKAGE_NAME.
* blockframe.c (find_pc_partial_function): Likewise.
* buildsym.c (find_symbol_in_list): Likewise.
* c-valprint.c (c_val_print): Likewise.
* coffread.c (patch_opaque_types, process_coff_symbol): Likewise.
(coff_read_enum_type): Likewise. Use SYMBOL_SET_LINKAGE_NAME.
* cp-support.c (cp_remove_params): Renamed from remove_params and
made global.
(overload_list_add_symbol): Update call to remove_params.
* cp-support.h (cp_remove_params): Declare.
* dwarf2read.c (process_enumeration_scope): Use SYMBOL_LINKAGE_NAME.
(dwarf2_const_value): Use SYMBOL_PRINT_NAME.
* expprint.c (dump_subexp_body_standard): Likewise.
* f-valprint.c (info_common_command, there_is_a_visible_common_named):
Use SYMBOL_LINKAGE_NAME to find symbols and SYMBOL_PRINT_NAME
for messages.
* findvar.c (read_var_value): Use SYMBOL_LINKAGE_NAME.
* gnu-v2-abi.c (gnuv2_value_rtti_type): Likewise.
* hppa-hpux-tdep.c (hppa32_hpux_in_solib_call_trampoline)
(hppa_hpux_skip_trampoline_code): Use SYMBOL_LINKAGE_NAME to find
symbols and SYMBOL_PRINT_NAME for messages.
* jv-lang.c (add_class_symbol): Use SYMBOL_SET_LINKAGE_NAME.
* linespec.c (decode_line_2): Use SYMBOL_LINKAGE_NAME.
* mdebugread.c (parse_symbol): Use SYMBOL_LINKAGE_NAME and
SYMBOL_SET_LINKAGE_NAME.
(mylookup_symbol): Use SYMBOL_LINKAGE_NAME.
* minsyms.c (add_minsym_to_demangled_hash_table): Use
SYMBOL_SEARCH_NAME.
(lookup_minimal_symbol): Use SYMBOL_LINKAGE_NAME or
SYMBOL_MATCHES_SEARCH_NAME, depending on the pass.
* objfiles.h (ALL_OBJFILE_MSYMBOLS): Use SYMBOL_LINKAGE_NAME.
* printcmd.c (build_address_symbolic): Use SYMBOL_LINKAGE_NAME.
(address_info): Use SYMBOL_PRINT_NAME for messages and
SYMBOL_LINKAGE_NAME for lookups.
* sol-thread.c (info_cb): Use SYMBOL_PRINT_NAME for messages.
* stabsread.c (patch_block_stabs, define_symbol)
(read_type, read_enum_type, common_block_end)
(cleanup_undefined_types_1, scan_file_globals): Use
SYMBOL_LINKAGE_NAME, SYMBOL_SET_LINKAGE_NAME, ALL_OBJFILE_MSYMBOLS,
and SYMBOL_PRINT_NAME.
* stack.c (print_frame_args): Use SYMBOL_LINKAGE_NAME.
(print_frame, frame_info): Use SYMBOL_PRINT_NAME for output. Use
cp_remove_params instead of cplus_demangle.
(print_block_frame_labels, print_frame_arg_vars): Use
SYMBOL_LINKAGE_NAME.
* symmisc.c (dump_msymbols): Use ALL_OBJFILE_MSYMBOLS and
SYMBOL_LINKAGE_NAME.
(dump_symtab_1, print_symbol, print_partial_symbols)
(maintenance_check_symtabs): Use SYMBOL_LINKAGE_NAME.
* symtab.h (DEPRECATED_SYMBOL_NAME): Delete.
(SYMBOL_SET_LINKAGE_NAME): New.
(SYMBOL_SET_NAMES): Add a comment.
* tracepoint.c (set_traceframe_context, validate_actionline)
(collect_symbol, scope_info): Use SYMBOL_LINKAGE_NAME for
lookups and SYMBOL_PRINT_NAME for output.
* typeprint.c (typedef_print): Use SYMBOL_LINKAGE_NAME.
* xcoffread.c (process_xcoff_symbol): Use SYMBOL_SET_LINKAGE_NAME.
2008-08-21 20:14:39 +02:00
|
|
|
|
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
|
2010-05-18 21:23:37 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
if (!msym)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var));
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Push the address of the variable. */
|
|
|
|
|
ax_const_l (ax, SYMBOL_VALUE_ADDRESS (msym));
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2003-02-28 21:03:18 +01:00
|
|
|
|
case LOC_COMPUTED:
|
2004-01-26 21:36:32 +01:00
|
|
|
|
/* FIXME: cagney/2004-01-26: It should be possible to
|
2009-06-04 14:28:39 +02:00
|
|
|
|
unconditionally call the SYMBOL_COMPUTED_OPS method when available.
|
2004-02-06 19:30:47 +01:00
|
|
|
|
Unfortunately DWARF 2 stores the frame-base (instead of the
|
2004-01-26 21:36:32 +01:00
|
|
|
|
function) location in a function's symbol. Oops! For the
|
|
|
|
|
moment enable this when/where applicable. */
|
2009-06-17 20:40:53 +02:00
|
|
|
|
SYMBOL_COMPUTED_OPS (var)->tracepoint_var_ref (var, gdbarch, ax, value);
|
2003-02-28 21:03:18 +01:00
|
|
|
|
break;
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case LOC_OPTIMIZED_OUT:
|
2010-03-17 23:04:43 +01:00
|
|
|
|
/* Flag this, but don't say anything; leave it up to callers to
|
|
|
|
|
warn the user. */
|
|
|
|
|
value->optimized_out = 1;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Cannot find value of botched symbol `%s'."),
|
2003-02-20 David Carlton <carlton@math.stanford.edu>
* symtab.h (SYMBOL_PRINT_NAME): Rename from SYMBOL_SOURCE_NAME;
expand comment.
* ada-lang.c (user_select_syms, ada_finish_decode_line_1): Replace
SYMBOL_PRINT_NAME with SYMBOL_SOURCE_NAME.
* ada-typeprint.c (ada_typedef_print): Ditto.
* ax-gdb.c (gen_var_ref): Ditto.
* breakpoint.c (print_one_breakpoint): Ditto.
* buildsym.c (finish_block): Ditto.
* c-valprint.c (c_val_print): Ditto.
* expprint.c (print_subexp): Ditto.
* findvar.c (locate_var_value): Ditto.
* infcmd.c (jump_command): Ditto.
* linespec.c (decode_line_2, decode_compound): Ditto.
* maint.c (maintenance_translate_address): Ditto.
* objc-lang.c (compare_selectors, compare_classes): Ditto.
* printcmd.c (build_address_symbolic, sym_info, print_frame_args):
Ditto.
* p-valprint.c (pascal_val_print): Ditto.
* stabsread.c (define_symbol): Ditto.
* stack.c (print_frame, frame_info, print_block_frame_locals)
(print_frame_arg_vars, return_command): Ditto.
* symfile.c (compare_symbols, compare_psymbols): Ditto.
* symmisc.c (print_symbol): Ditto.
* symtab.c (lookup_partial_symbol, lookup_block_symbol)
(compare_search_syms, print_symbol_info, print_msymbol_info)
(rbreak_command): Ditto.
* tracepoint.c (tracepoints_info): Ditto.
* typeprint.c (typedef_print): Ditto.
* valops.c (value_of_variable, hand_function_call): Ditto.
* cli/cli-cmds.c (edit_command, list_command): Ditto.
* ada-typeprint.c: Update Copyright.
* infcmd.c, objc-lang.c, p-valprint.c, symmisc.c: Ditto.
* tracepoint.c, cli/cli-cmds.c: Ditto.
2003-02-20 18:17:25 +01:00
|
|
|
|
SYMBOL_PRINT_NAME (var));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generating bytecode from GDB expressions: literals */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_int_literal (struct agent_expr *ax, struct axs_value *value, LONGEST k,
|
|
|
|
|
struct type *type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
ax_const_l (ax, k);
|
|
|
|
|
value->kind = axs_rvalue;
|
2007-10-27 01:04:57 +02:00
|
|
|
|
value->type = check_typedef (type);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generating bytecode from GDB expressions: unary conversions, casts */
|
|
|
|
|
|
|
|
|
|
/* Take what's on the top of the stack (as described by VALUE), and
|
|
|
|
|
try to make an rvalue out of it. Signal an error if we can't do
|
|
|
|
|
that. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
require_rvalue (struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2010-03-18 02:47:33 +01:00
|
|
|
|
/* Only deal with scalars, structs and such may be too large
|
|
|
|
|
to fit in a stack entry. */
|
|
|
|
|
value->type = check_typedef (value->type);
|
|
|
|
|
if (TYPE_CODE (value->type) == TYPE_CODE_ARRAY
|
|
|
|
|
|| TYPE_CODE (value->type) == TYPE_CODE_STRUCT
|
|
|
|
|
|| TYPE_CODE (value->type) == TYPE_CODE_UNION
|
|
|
|
|
|| TYPE_CODE (value->type) == TYPE_CODE_FUNC)
|
2010-03-18 17:01:29 +01:00
|
|
|
|
error (_("Value not scalar: cannot be an rvalue."));
|
2010-03-18 02:47:33 +01:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
switch (value->kind)
|
|
|
|
|
{
|
|
|
|
|
case axs_rvalue:
|
|
|
|
|
/* It's already an rvalue. */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case axs_lvalue_memory:
|
|
|
|
|
/* The top of stack is the address of the object. Dereference. */
|
|
|
|
|
gen_fetch (ax, value->type);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case axs_lvalue_register:
|
|
|
|
|
/* There's nothing on the stack, but value->u.reg is the
|
|
|
|
|
register number containing the value.
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
When we add floating-point support, this is going to have to
|
|
|
|
|
change. What about SPARC register pairs, for example? */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ax_reg (ax, value->u.reg);
|
|
|
|
|
gen_extend (ax, value->type);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Assume the top of the stack is described by VALUE, and perform the
|
|
|
|
|
usual unary conversions. This is motivated by ANSI 6.2.2, but of
|
|
|
|
|
course GDB expressions are not ANSI; they're the mishmash union of
|
|
|
|
|
a bunch of languages. Rah.
|
|
|
|
|
|
|
|
|
|
NOTE! This function promises to produce an rvalue only when the
|
|
|
|
|
incoming value is of an appropriate type. In other words, the
|
|
|
|
|
consumer of the value this function produces may assume the value
|
|
|
|
|
is an rvalue only after checking its type.
|
|
|
|
|
|
|
|
|
|
The immediate issue is that if the user tries to use a structure or
|
|
|
|
|
union as an operand of, say, the `+' operator, we don't want to try
|
|
|
|
|
to convert that structure to an rvalue; require_rvalue will bomb on
|
|
|
|
|
structs and unions. Rather, we want to simply pass the struct
|
|
|
|
|
lvalue through unchanged, and let `+' raise an error. */
|
|
|
|
|
|
|
|
|
|
static void
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_usual_unary (struct expression *exp, struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* We don't have to generate any code for the usual integral
|
|
|
|
|
conversions, since values are always represented as full-width on
|
|
|
|
|
the stack. Should we tweak the type? */
|
|
|
|
|
|
|
|
|
|
/* Some types require special handling. */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
switch (TYPE_CODE (value->type))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Functions get converted to a pointer to the function. */
|
|
|
|
|
case TYPE_CODE_FUNC:
|
|
|
|
|
value->type = lookup_pointer_type (value->type);
|
|
|
|
|
value->kind = axs_rvalue; /* Should always be true, but just in case. */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Arrays get converted to a pointer to their first element, and
|
1999-07-07 22:19:36 +02:00
|
|
|
|
are no longer an lvalue. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case TYPE_CODE_ARRAY:
|
|
|
|
|
{
|
|
|
|
|
struct type *elements = TYPE_TARGET_TYPE (value->type);
|
2010-05-18 21:23:37 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->type = lookup_pointer_type (elements);
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
/* We don't need to generate any code; the address of the array
|
|
|
|
|
is also the address of its first element. */
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
/* Don't try to convert structures and unions to rvalues. Let the
|
|
|
|
|
consumer signal an error. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case TYPE_CODE_STRUCT:
|
|
|
|
|
case TYPE_CODE_UNION:
|
|
|
|
|
return;
|
|
|
|
|
|
2010-03-19 23:00:17 +01:00
|
|
|
|
/* If the value is an enum or a bool, call it an integer. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case TYPE_CODE_ENUM:
|
2010-03-19 23:00:17 +01:00
|
|
|
|
case TYPE_CODE_BOOL:
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
value->type = builtin_type (exp->gdbarch)->builtin_int;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If the value is an lvalue, dereference it. */
|
|
|
|
|
require_rvalue (ax, value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return non-zero iff the type TYPE1 is considered "wider" than the
|
|
|
|
|
type TYPE2, according to the rules described in gen_usual_arithmetic. */
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
type_wider_than (struct type *type1, struct type *type2)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
return (TYPE_LENGTH (type1) > TYPE_LENGTH (type2)
|
|
|
|
|
|| (TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
|
|
|
|
|
&& TYPE_UNSIGNED (type1)
|
1999-07-07 22:19:36 +02:00
|
|
|
|
&& !TYPE_UNSIGNED (type2)));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return the "wider" of the two types TYPE1 and TYPE2. */
|
|
|
|
|
static struct type *
|
2000-07-30 03:48:28 +02:00
|
|
|
|
max_type (struct type *type1, struct type *type2)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
return type_wider_than (type1, type2) ? type1 : type2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code to convert a scalar value of type FROM to type TO. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_conversion (struct agent_expr *ax, struct type *from, struct type *to)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Perhaps there is a more graceful way to state these rules. */
|
|
|
|
|
|
|
|
|
|
/* If we're converting to a narrower type, then we need to clear out
|
|
|
|
|
the upper bits. */
|
|
|
|
|
if (TYPE_LENGTH (to) < TYPE_LENGTH (from))
|
|
|
|
|
gen_extend (ax, from);
|
|
|
|
|
|
|
|
|
|
/* If the two values have equal width, but different signednesses,
|
|
|
|
|
then we need to extend. */
|
|
|
|
|
else if (TYPE_LENGTH (to) == TYPE_LENGTH (from))
|
|
|
|
|
{
|
|
|
|
|
if (TYPE_UNSIGNED (from) != TYPE_UNSIGNED (to))
|
|
|
|
|
gen_extend (ax, to);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If we're converting to a wider type, and becoming unsigned, then
|
|
|
|
|
we need to zero out any possible sign bits. */
|
|
|
|
|
else if (TYPE_LENGTH (to) > TYPE_LENGTH (from))
|
|
|
|
|
{
|
|
|
|
|
if (TYPE_UNSIGNED (to))
|
|
|
|
|
gen_extend (ax, to);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return non-zero iff the type FROM will require any bytecodes to be
|
|
|
|
|
emitted to be converted to the type TO. */
|
|
|
|
|
static int
|
2000-07-30 03:48:28 +02:00
|
|
|
|
is_nontrivial_conversion (struct type *from, struct type *to)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2010-04-24 01:51:05 +02:00
|
|
|
|
struct agent_expr *ax = new_agent_expr (NULL, 0);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
int nontrivial;
|
|
|
|
|
|
|
|
|
|
/* Actually generate the code, and see if anything came out. At the
|
|
|
|
|
moment, it would be trivial to replicate the code in
|
|
|
|
|
gen_conversion here, but in the future, when we're supporting
|
|
|
|
|
floating point and the like, it may not be. Doing things this
|
|
|
|
|
way allows this function to be independent of the logic in
|
|
|
|
|
gen_conversion. */
|
|
|
|
|
gen_conversion (ax, from, to);
|
|
|
|
|
nontrivial = ax->len > 0;
|
|
|
|
|
free_agent_expr (ax);
|
|
|
|
|
return nontrivial;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code to perform the "usual arithmetic conversions" (ANSI C
|
|
|
|
|
6.2.1.5) for the two operands of an arithmetic operator. This
|
|
|
|
|
effectively finds a "least upper bound" type for the two arguments,
|
|
|
|
|
and promotes each argument to that type. *VALUE1 and *VALUE2
|
|
|
|
|
describe the values as they are passed in, and as they are left. */
|
|
|
|
|
static void
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_usual_arithmetic (struct expression *exp, struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value1, struct axs_value *value2)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Do the usual binary conversions. */
|
|
|
|
|
if (TYPE_CODE (value1->type) == TYPE_CODE_INT
|
|
|
|
|
&& TYPE_CODE (value2->type) == TYPE_CODE_INT)
|
|
|
|
|
{
|
|
|
|
|
/* The ANSI integral promotions seem to work this way: Order the
|
1999-07-07 22:19:36 +02:00
|
|
|
|
integer types by size, and then by signedness: an n-bit
|
|
|
|
|
unsigned type is considered "wider" than an n-bit signed
|
|
|
|
|
type. Promote to the "wider" of the two types, and always
|
|
|
|
|
promote at least to int. */
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
struct type *target = max_type (builtin_type (exp->gdbarch)->builtin_int,
|
1999-04-16 03:35:26 +02:00
|
|
|
|
max_type (value1->type, value2->type));
|
|
|
|
|
|
|
|
|
|
/* Deal with value2, on the top of the stack. */
|
|
|
|
|
gen_conversion (ax, value2->type, target);
|
|
|
|
|
|
|
|
|
|
/* Deal with value1, not on the top of the stack. Don't
|
|
|
|
|
generate the `swap' instructions if we're not actually going
|
|
|
|
|
to do anything. */
|
|
|
|
|
if (is_nontrivial_conversion (value1->type, target))
|
|
|
|
|
{
|
|
|
|
|
ax_simple (ax, aop_swap);
|
|
|
|
|
gen_conversion (ax, value1->type, target);
|
|
|
|
|
ax_simple (ax, aop_swap);
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-27 01:04:57 +02:00
|
|
|
|
value1->type = value2->type = check_typedef (target);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code to perform the integral promotions (ANSI 6.2.1.1) on
|
|
|
|
|
the value on the top of the stack, as described by VALUE. Assume
|
|
|
|
|
the value has integral type. */
|
|
|
|
|
static void
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_integral_promotions (struct expression *exp, struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
const struct builtin_type *builtin = builtin_type (exp->gdbarch);
|
|
|
|
|
|
|
|
|
|
if (!type_wider_than (value->type, builtin->builtin_int))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_conversion (ax, value->type, builtin->builtin_int);
|
|
|
|
|
value->type = builtin->builtin_int;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
else if (!type_wider_than (value->type, builtin->builtin_unsigned_int))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_conversion (ax, value->type, builtin->builtin_unsigned_int);
|
|
|
|
|
value->type = builtin->builtin_unsigned_int;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generate code for a cast to TYPE. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* GCC does allow casts to yield lvalues, so this should be fixed
|
|
|
|
|
before merging these changes into the trunk. */
|
|
|
|
|
require_rvalue (ax, value);
|
2010-12-31 20:16:37 +01:00
|
|
|
|
/* Dereference typedefs. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
type = check_typedef (type);
|
|
|
|
|
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
switch (TYPE_CODE (type))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
case TYPE_CODE_PTR:
|
2009-12-30 00:57:59 +01:00
|
|
|
|
case TYPE_CODE_REF:
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* It's implementation-defined, and I'll bet this is what GCC
|
|
|
|
|
does. */
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TYPE_CODE_ARRAY:
|
|
|
|
|
case TYPE_CODE_STRUCT:
|
|
|
|
|
case TYPE_CODE_UNION:
|
|
|
|
|
case TYPE_CODE_FUNC:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Invalid type cast: intended type must be scalar."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case TYPE_CODE_ENUM:
|
2010-03-19 23:00:17 +01:00
|
|
|
|
case TYPE_CODE_BOOL:
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* We don't have to worry about the size of the value, because
|
|
|
|
|
all our integral values are fully sign-extended, and when
|
|
|
|
|
casting pointers we can do anything we like. Is there any
|
2007-10-27 01:07:26 +02:00
|
|
|
|
way for us to know what GCC actually does with a cast like
|
|
|
|
|
this? */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case TYPE_CODE_INT:
|
|
|
|
|
gen_conversion (ax, value->type, type);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TYPE_CODE_VOID:
|
|
|
|
|
/* We could pop the value, and rely on everyone else to check
|
1999-07-07 22:19:36 +02:00
|
|
|
|
the type and notice that this value doesn't occupy a stack
|
|
|
|
|
slot. But for now, leave the value on the stack, and
|
|
|
|
|
preserve the "value == stack element" assumption. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Casts to requested type are not yet implemented."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
value->type = type;
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generating bytecode from GDB expressions: arithmetic */
|
|
|
|
|
|
|
|
|
|
/* Scale the integer on the top of the stack by the size of the target
|
|
|
|
|
of the pointer type TYPE. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
struct type *element = TYPE_TARGET_TYPE (type);
|
|
|
|
|
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
if (TYPE_LENGTH (element) != 1)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
ax_const_l (ax, TYPE_LENGTH (element));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ax_simple (ax, op);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
/* Generate code for pointer arithmetic PTR + INT. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
static void
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_ptradd (struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct axs_value *value1, struct axs_value *value2)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2009-12-30 00:57:59 +01:00
|
|
|
|
gdb_assert (pointer_type (value1->type));
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_scale (ax, aop_mul, value1->type);
|
|
|
|
|
ax_simple (ax, aop_add);
|
|
|
|
|
gen_extend (ax, value1->type); /* Catch overflow. */
|
|
|
|
|
value->type = value1->type;
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
/* Generate code for pointer arithmetic PTR - INT. */
|
|
|
|
|
static void
|
|
|
|
|
gen_ptrsub (struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct axs_value *value1, struct axs_value *value2)
|
|
|
|
|
{
|
2009-12-30 00:57:59 +01:00
|
|
|
|
gdb_assert (pointer_type (value1->type));
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_scale (ax, aop_mul, value1->type);
|
|
|
|
|
ax_simple (ax, aop_sub);
|
|
|
|
|
gen_extend (ax, value1->type); /* Catch overflow. */
|
|
|
|
|
value->type = value1->type;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
/* Generate code for pointer arithmetic PTR - PTR. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
static void
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_ptrdiff (struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct axs_value *value1, struct axs_value *value2,
|
|
|
|
|
struct type *result_type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2009-12-30 00:57:59 +01:00
|
|
|
|
gdb_assert (pointer_type (value1->type));
|
|
|
|
|
gdb_assert (pointer_type (value2->type));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
if (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type))
|
|
|
|
|
!= TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type)))
|
2011-01-07 18:35:27 +01:00
|
|
|
|
error (_("\
|
|
|
|
|
First argument of `-' is a pointer, but second argument is neither\n\
|
|
|
|
|
an integer nor a pointer of the same type."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
ax_simple (ax, aop_sub);
|
|
|
|
|
gen_scale (ax, aop_div_unsigned, value1->type);
|
|
|
|
|
value->type = result_type;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
}
|
|
|
|
|
|
2010-03-19 23:00:17 +01:00
|
|
|
|
static void
|
|
|
|
|
gen_equal (struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct axs_value *value1, struct axs_value *value2,
|
|
|
|
|
struct type *result_type)
|
|
|
|
|
{
|
|
|
|
|
if (pointer_type (value1->type) || pointer_type (value2->type))
|
|
|
|
|
ax_simple (ax, aop_equal);
|
|
|
|
|
else
|
|
|
|
|
gen_binop (ax, value, value1, value2,
|
|
|
|
|
aop_equal, aop_equal, 0, "equal");
|
|
|
|
|
value->type = result_type;
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gen_less (struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct axs_value *value1, struct axs_value *value2,
|
|
|
|
|
struct type *result_type)
|
|
|
|
|
{
|
|
|
|
|
if (pointer_type (value1->type) || pointer_type (value2->type))
|
|
|
|
|
ax_simple (ax, aop_less_unsigned);
|
|
|
|
|
else
|
|
|
|
|
gen_binop (ax, value, value1, value2,
|
|
|
|
|
aop_less_signed, aop_less_unsigned, 0, "less than");
|
|
|
|
|
value->type = result_type;
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
}
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Generate code for a binary operator that doesn't do pointer magic.
|
|
|
|
|
We set VALUE to describe the result value; we assume VALUE1 and
|
|
|
|
|
VALUE2 describe the two operands, and that they've undergone the
|
|
|
|
|
usual binary conversions. MAY_CARRY should be non-zero iff the
|
|
|
|
|
result needs to be extended. NAME is the English name of the
|
|
|
|
|
operator, used in error messages */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_binop (struct agent_expr *ax, struct axs_value *value,
|
2011-01-05 23:22:53 +01:00
|
|
|
|
struct axs_value *value1, struct axs_value *value2,
|
|
|
|
|
enum agent_op op, enum agent_op op_unsigned,
|
|
|
|
|
int may_carry, char *name)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* We only handle INT op INT. */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
if ((TYPE_CODE (value1->type) != TYPE_CODE_INT)
|
|
|
|
|
|| (TYPE_CODE (value2->type) != TYPE_CODE_INT))
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Invalid combination of types in %s."), name);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ax_simple (ax,
|
|
|
|
|
TYPE_UNSIGNED (value1->type) ? op_unsigned : op);
|
|
|
|
|
if (may_carry)
|
1999-07-07 22:19:36 +02:00
|
|
|
|
gen_extend (ax, value1->type); /* catch overflow */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->type = value1->type;
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_logical_not (struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct type *result_type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
if (TYPE_CODE (value->type) != TYPE_CODE_INT
|
|
|
|
|
&& TYPE_CODE (value->type) != TYPE_CODE_PTR)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Invalid type of operand to `!'."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
ax_simple (ax, aop_log_not);
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
value->type = result_type;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_complement (struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
if (TYPE_CODE (value->type) != TYPE_CODE_INT)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Invalid type of operand to `~'."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
ax_simple (ax, aop_bit_not);
|
|
|
|
|
gen_extend (ax, value->type);
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generating bytecode from GDB expressions: * & . -> @ sizeof */
|
|
|
|
|
|
|
|
|
|
/* Dereference the value on the top of the stack. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_deref (struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* The caller should check the type, because several operators use
|
|
|
|
|
this, and we don't know what error message to generate. */
|
2009-12-30 00:57:59 +01:00
|
|
|
|
if (!pointer_type (value->type))
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("gen_deref: expected a pointer"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* We've got an rvalue now, which is a pointer. We want to yield an
|
|
|
|
|
lvalue, whose address is exactly that pointer. So we don't
|
|
|
|
|
actually emit any code; we just change the type from "Pointer to
|
|
|
|
|
T" to "T", and mark the value as an lvalue in memory. Leave it
|
|
|
|
|
to the consumer to actually dereference it. */
|
|
|
|
|
value->type = check_typedef (TYPE_TARGET_TYPE (value->type));
|
2010-02-11 19:24:57 +01:00
|
|
|
|
if (TYPE_CODE (value->type) == TYPE_CODE_VOID)
|
|
|
|
|
error (_("Attempt to dereference a generic pointer."));
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
value->kind = ((TYPE_CODE (value->type) == TYPE_CODE_FUNC)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
? axs_rvalue : axs_lvalue_memory);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Produce the address of the lvalue on the top of the stack. */
|
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_address_of (struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Special case for taking the address of a function. The ANSI
|
|
|
|
|
standard describes this as a special case, too, so this
|
|
|
|
|
arrangement is not without motivation. */
|
2002-05-13 Daniel Jacobowitz <drow@mvista.com>
* ax-gdb.c (gen_sign_extend, gen_fetch, gen_usual_unary)
(gen_cast, gen_scale, gen_add, gen_sub, gen_binop, gen_deref)
(gen_address_of, gen_struct_ref, gen_repeat): Use type
access macros.
* c-typeprint.c (cp_type_print_method_args): Likewise.
(c_type_print_args): Likewise.
* d10v-tdep.c (d10v_push_arguments): Likewise.
(d10v_extract_return_value): Likewise.
* expprint.c (print_subexp): Likewise.
* gdbtypes.c (lookup_primitive_typename): Likewise.
(lookup_template_type, add_mangled_type, print_arg_types): Likewise.
* gdbtypes.h (TYPE_UNSIGNED, TYPE_NOSIGN, TYPE_STUB)
(TYPE_TARGET_STUB, TYPE_STATIC, TYPE_CONST, TYPE_VOLATILE)
(TYPE_PROTOTYPED, TYPE_INCOMPLETE, TYPE_CODE_SPACE, TYPE_VARARGS)
(TYPE_VECTOR): Likewise.
* hpread.c (hpread_read_struct_type)
(fix_static_member_physnames, fixup_class_method_type)
(hpread_type_lookup): Likewise.
* mdebugread.c (parse_symbol, parse_type): Likewise.
* p-lang.c (is_pascal_string_type): Likewise.
* valops.c (hand_function_call): Likewise.
* x86-64-tdep.c (classify_argument): Likewise.
* hpread.c (hpread_read_function_type)
(hpread_read_doc_function_type): Call replace_type.
* dstread.c (create_new_type): Delete.
(decode_dst_structure, process_dst_function): Call alloc_type.
Use type access macros.
2002-05-13 16:00:36 +02:00
|
|
|
|
if (TYPE_CODE (value->type) == TYPE_CODE_FUNC)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* The value's already an rvalue on the stack, so we just need to
|
|
|
|
|
change the type. */
|
|
|
|
|
value->type = lookup_pointer_type (value->type);
|
|
|
|
|
else
|
|
|
|
|
switch (value->kind)
|
|
|
|
|
{
|
|
|
|
|
case axs_rvalue:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Operand of `&' is an rvalue, which has no address."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case axs_lvalue_register:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Operand of `&' is in a register, and has no address."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case axs_lvalue_memory:
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
value->type = lookup_pointer_type (value->type);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Generate code to push the value of a bitfield of a structure whose
|
|
|
|
|
address is on the top of the stack. START and END give the
|
|
|
|
|
starting and one-past-ending *bit* numbers of the field within the
|
|
|
|
|
structure. */
|
|
|
|
|
static void
|
2009-06-17 20:40:53 +02:00
|
|
|
|
gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value, struct type *type,
|
|
|
|
|
int start, int end)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Note that ops[i] fetches 8 << i bits. */
|
|
|
|
|
static enum agent_op ops[]
|
2010-05-18 21:23:37 +02:00
|
|
|
|
= {aop_ref8, aop_ref16, aop_ref32, aop_ref64};
|
1999-04-16 03:35:26 +02:00
|
|
|
|
static int num_ops = (sizeof (ops) / sizeof (ops[0]));
|
|
|
|
|
|
|
|
|
|
/* We don't want to touch any byte that the bitfield doesn't
|
|
|
|
|
actually occupy; we shouldn't make any accesses we're not
|
|
|
|
|
explicitly permitted to. We rely here on the fact that the
|
|
|
|
|
bytecode `ref' operators work on unaligned addresses.
|
|
|
|
|
|
|
|
|
|
It takes some fancy footwork to get the stack to work the way
|
|
|
|
|
we'd like. Say we're retrieving a bitfield that requires three
|
|
|
|
|
fetches. Initially, the stack just contains the address:
|
1999-07-07 22:19:36 +02:00
|
|
|
|
addr
|
1999-04-16 03:35:26 +02:00
|
|
|
|
For the first fetch, we duplicate the address
|
1999-07-07 22:19:36 +02:00
|
|
|
|
addr addr
|
1999-04-16 03:35:26 +02:00
|
|
|
|
then add the byte offset, do the fetch, and shift and mask as
|
|
|
|
|
needed, yielding a fragment of the value, properly aligned for
|
|
|
|
|
the final bitwise or:
|
1999-07-07 22:19:36 +02:00
|
|
|
|
addr frag1
|
1999-04-16 03:35:26 +02:00
|
|
|
|
then we swap, and repeat the process:
|
1999-07-07 22:19:36 +02:00
|
|
|
|
frag1 addr --- address on top
|
|
|
|
|
frag1 addr addr --- duplicate it
|
|
|
|
|
frag1 addr frag2 --- get second fragment
|
|
|
|
|
frag1 frag2 addr --- swap again
|
|
|
|
|
frag1 frag2 frag3 --- get third fragment
|
1999-04-16 03:35:26 +02:00
|
|
|
|
Notice that, since the third fragment is the last one, we don't
|
|
|
|
|
bother duplicating the address this time. Now we have all the
|
|
|
|
|
fragments on the stack, and we can simply `or' them together,
|
|
|
|
|
yielding the final value of the bitfield. */
|
|
|
|
|
|
|
|
|
|
/* The first and one-after-last bits in the field, but rounded down
|
|
|
|
|
and up to byte boundaries. */
|
|
|
|
|
int bound_start = (start / TARGET_CHAR_BIT) * TARGET_CHAR_BIT;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
int bound_end = (((end + TARGET_CHAR_BIT - 1)
|
|
|
|
|
/ TARGET_CHAR_BIT)
|
|
|
|
|
* TARGET_CHAR_BIT);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* current bit offset within the structure */
|
|
|
|
|
int offset;
|
|
|
|
|
|
|
|
|
|
/* The index in ops of the opcode we're considering. */
|
|
|
|
|
int op;
|
|
|
|
|
|
|
|
|
|
/* The number of fragments we generated in the process. Probably
|
|
|
|
|
equal to the number of `one' bits in bytesize, but who cares? */
|
|
|
|
|
int fragment_count;
|
|
|
|
|
|
2010-12-31 20:16:37 +01:00
|
|
|
|
/* Dereference any typedefs. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
type = check_typedef (type);
|
|
|
|
|
|
|
|
|
|
/* Can we fetch the number of bits requested at all? */
|
|
|
|
|
if ((end - start) > ((1 << num_ops) * 8))
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("gen_bitfield_ref: bitfield too wide"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Note that we know here that we only need to try each opcode once.
|
|
|
|
|
That may not be true on machines with weird byte sizes. */
|
|
|
|
|
offset = bound_start;
|
|
|
|
|
fragment_count = 0;
|
|
|
|
|
for (op = num_ops - 1; op >= 0; op--)
|
|
|
|
|
{
|
|
|
|
|
/* number of bits that ops[op] would fetch */
|
|
|
|
|
int op_size = 8 << op;
|
|
|
|
|
|
|
|
|
|
/* The stack at this point, from bottom to top, contains zero or
|
1999-07-07 22:19:36 +02:00
|
|
|
|
more fragments, then the address. */
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Does this fetch fit within the bitfield? */
|
|
|
|
|
if (offset + op_size <= bound_end)
|
|
|
|
|
{
|
|
|
|
|
/* Is this the last fragment? */
|
|
|
|
|
int last_frag = (offset + op_size == bound_end);
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
if (!last_frag)
|
|
|
|
|
ax_simple (ax, aop_dup); /* keep a copy of the address */
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Add the offset. */
|
|
|
|
|
gen_offset (ax, offset / TARGET_CHAR_BIT);
|
|
|
|
|
|
|
|
|
|
if (trace_kludge)
|
|
|
|
|
{
|
|
|
|
|
/* Record the area of memory we're about to fetch. */
|
|
|
|
|
ax_trace_quick (ax, op_size / TARGET_CHAR_BIT);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Perform the fetch. */
|
|
|
|
|
ax_simple (ax, ops[op]);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
|
|
|
|
/* Shift the bits we have to their proper position.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_left_shift will generate right shifts when the operand
|
|
|
|
|
is negative.
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
A big-endian field diagram to ponder:
|
|
|
|
|
byte 0 byte 1 byte 2 byte 3 byte 4 byte 5 byte 6 byte 7
|
|
|
|
|
+------++------++------++------++------++------++------++------+
|
|
|
|
|
xxxxAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCxxxxxxxxxxx
|
|
|
|
|
^ ^ ^ ^
|
|
|
|
|
bit number 16 32 48 53
|
1999-04-16 03:35:26 +02:00
|
|
|
|
These are bit numbers as supplied by GDB. Note that the
|
|
|
|
|
bit numbers run from right to left once you've fetched the
|
|
|
|
|
value!
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
A little-endian field diagram to ponder:
|
|
|
|
|
byte 7 byte 6 byte 5 byte 4 byte 3 byte 2 byte 1 byte 0
|
|
|
|
|
+------++------++------++------++------++------++------++------+
|
|
|
|
|
xxxxxxxxxxxAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCxxxx
|
|
|
|
|
^ ^ ^ ^ ^
|
|
|
|
|
bit number 48 32 16 4 0
|
|
|
|
|
|
|
|
|
|
In both cases, the most significant end is on the left
|
|
|
|
|
(i.e. normal numeric writing order), which means that you
|
|
|
|
|
don't go crazy thinking about `left' and `right' shifts.
|
|
|
|
|
|
|
|
|
|
We don't have to worry about masking yet:
|
|
|
|
|
- If they contain garbage off the least significant end, then we
|
|
|
|
|
must be looking at the low end of the field, and the right
|
|
|
|
|
shift will wipe them out.
|
|
|
|
|
- If they contain garbage off the most significant end, then we
|
|
|
|
|
must be looking at the most significant end of the word, and
|
|
|
|
|
the sign/zero extension will wipe them out.
|
|
|
|
|
- If we're in the interior of the word, then there is no garbage
|
|
|
|
|
on either end, because the ref operators zero-extend. */
|
2009-06-17 20:40:53 +02:00
|
|
|
|
if (gdbarch_byte_order (exp->gdbarch) == BFD_ENDIAN_BIG)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_left_shift (ax, end - (offset + op_size));
|
1999-07-07 22:19:36 +02:00
|
|
|
|
else
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_left_shift (ax, offset - start);
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
if (!last_frag)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Bring the copy of the address up to the top. */
|
|
|
|
|
ax_simple (ax, aop_swap);
|
|
|
|
|
|
|
|
|
|
offset += op_size;
|
|
|
|
|
fragment_count++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Generate enough bitwise `or' operations to combine all the
|
|
|
|
|
fragments we left on the stack. */
|
|
|
|
|
while (fragment_count-- > 1)
|
|
|
|
|
ax_simple (ax, aop_bit_or);
|
|
|
|
|
|
|
|
|
|
/* Sign- or zero-extend the value as appropriate. */
|
|
|
|
|
((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, end - start));
|
|
|
|
|
|
|
|
|
|
/* This is *not* an lvalue. Ugh. */
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
value->type = type;
|
|
|
|
|
}
|
|
|
|
|
|
2010-03-16 00:53:21 +01:00
|
|
|
|
/* Generate bytecodes for field number FIELDNO of type TYPE. OFFSET
|
|
|
|
|
is an accumulated offset (in bytes), will be nonzero for objects
|
|
|
|
|
embedded in other objects, like C++ base classes. Behavior should
|
|
|
|
|
generally follow value_primitive_field. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gen_primitive_field (struct expression *exp,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
int offset, int fieldno, struct type *type)
|
|
|
|
|
{
|
|
|
|
|
/* Is this a bitfield? */
|
|
|
|
|
if (TYPE_FIELD_PACKED (type, fieldno))
|
|
|
|
|
gen_bitfield_ref (exp, ax, value, TYPE_FIELD_TYPE (type, fieldno),
|
|
|
|
|
(offset * TARGET_CHAR_BIT
|
|
|
|
|
+ TYPE_FIELD_BITPOS (type, fieldno)),
|
|
|
|
|
(offset * TARGET_CHAR_BIT
|
|
|
|
|
+ TYPE_FIELD_BITPOS (type, fieldno)
|
|
|
|
|
+ TYPE_FIELD_BITSIZE (type, fieldno)));
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
gen_offset (ax, offset
|
|
|
|
|
+ TYPE_FIELD_BITPOS (type, fieldno) / TARGET_CHAR_BIT);
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
value->type = TYPE_FIELD_TYPE (type, fieldno);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Search for the given field in either the given type or one of its
|
|
|
|
|
base classes. Return 1 if found, 0 if not. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value,
|
|
|
|
|
char *field, int offset, struct type *type)
|
|
|
|
|
{
|
|
|
|
|
int i, rslt;
|
|
|
|
|
int nbases = TYPE_N_BASECLASSES (type);
|
|
|
|
|
|
|
|
|
|
CHECK_TYPEDEF (type);
|
|
|
|
|
|
|
|
|
|
for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
|
|
|
|
|
{
|
|
|
|
|
char *this_name = TYPE_FIELD_NAME (type, i);
|
|
|
|
|
|
|
|
|
|
if (this_name)
|
|
|
|
|
{
|
|
|
|
|
if (strcmp (field, this_name) == 0)
|
|
|
|
|
{
|
|
|
|
|
/* Note that bytecodes for the struct's base (aka
|
|
|
|
|
"this") will have been generated already, which will
|
|
|
|
|
be unnecessary but not harmful if the static field is
|
|
|
|
|
being handled as a global. */
|
|
|
|
|
if (field_is_static (&TYPE_FIELD (type, i)))
|
|
|
|
|
{
|
2010-03-17 23:04:43 +01:00
|
|
|
|
gen_static_field (exp->gdbarch, ax, value, type, i);
|
|
|
|
|
if (value->optimized_out)
|
2011-01-05 23:22:53 +01:00
|
|
|
|
error (_("static field `%s' has been "
|
|
|
|
|
"optimized out, cannot use"),
|
2010-03-17 23:04:43 +01:00
|
|
|
|
field);
|
2010-03-16 00:53:21 +01:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
gen_primitive_field (exp, ax, value, offset, i, type);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
#if 0 /* is this right? */
|
|
|
|
|
if (this_name[0] == '\0')
|
|
|
|
|
internal_error (__FILE__, __LINE__,
|
|
|
|
|
_("find_field: anonymous unions not supported"));
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Now scan through base classes recursively. */
|
|
|
|
|
for (i = 0; i < nbases; i++)
|
|
|
|
|
{
|
|
|
|
|
struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
|
|
|
|
|
|
|
|
|
|
rslt = gen_struct_ref_recursive (exp, ax, value, field,
|
2011-01-05 23:22:53 +01:00
|
|
|
|
offset + TYPE_BASECLASS_BITPOS (type, i)
|
|
|
|
|
/ TARGET_CHAR_BIT,
|
2010-03-16 00:53:21 +01:00
|
|
|
|
basetype);
|
|
|
|
|
if (rslt)
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Not found anywhere, flag so caller can complain. */
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Generate code to reference the member named FIELD of a structure or
|
|
|
|
|
union. The top of the stack, as described by VALUE, should have
|
|
|
|
|
type (pointer to a)* struct/union. OPERATOR_NAME is the name of
|
|
|
|
|
the operator being compiled, and OPERAND_NAME is the kind of thing
|
|
|
|
|
it operates on; we use them in error messages. */
|
|
|
|
|
static void
|
2009-06-17 20:40:53 +02:00
|
|
|
|
gen_struct_ref (struct expression *exp, struct agent_expr *ax,
|
|
|
|
|
struct axs_value *value, char *field,
|
2000-07-30 03:48:28 +02:00
|
|
|
|
char *operator_name, char *operand_name)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
struct type *type;
|
2010-03-16 00:53:21 +01:00
|
|
|
|
int found;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Follow pointers until we reach a non-pointer. These aren't the C
|
|
|
|
|
semantics, but they're what the normal GDB evaluator does, so we
|
|
|
|
|
should at least be consistent. */
|
2009-12-30 00:57:59 +01:00
|
|
|
|
while (pointer_type (value->type))
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
require_rvalue (ax, value);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_deref (ax, value);
|
|
|
|
|
}
|
2000-10-30 22:15:56 +01:00
|
|
|
|
type = check_typedef (value->type);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* This must yield a structure or a union. */
|
|
|
|
|
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
|
|
|
|
|
&& TYPE_CODE (type) != TYPE_CODE_UNION)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("The left operand of `%s' is not a %s."),
|
1999-04-16 03:35:26 +02:00
|
|
|
|
operator_name, operand_name);
|
|
|
|
|
|
|
|
|
|
/* And it must be in memory; we don't deal with structure rvalues,
|
|
|
|
|
or structures living in registers. */
|
|
|
|
|
if (value->kind != axs_lvalue_memory)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Structure does not live in memory."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2010-03-16 00:53:21 +01:00
|
|
|
|
/* Search through fields and base classes recursively. */
|
|
|
|
|
found = gen_struct_ref_recursive (exp, ax, value, field, 0, type);
|
|
|
|
|
|
|
|
|
|
if (!found)
|
|
|
|
|
error (_("Couldn't find member named `%s' in struct/union/class `%s'"),
|
|
|
|
|
field, TYPE_TAG_NAME (type));
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
2010-03-16 00:53:21 +01:00
|
|
|
|
static int
|
|
|
|
|
gen_namespace_elt (struct expression *exp,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
const struct type *curtype, char *name);
|
|
|
|
|
static int
|
|
|
|
|
gen_maybe_namespace_elt (struct expression *exp,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
const struct type *curtype, char *name);
|
|
|
|
|
|
|
|
|
|
static void
|
2010-03-17 23:04:43 +01:00
|
|
|
|
gen_static_field (struct gdbarch *gdbarch,
|
2010-03-16 00:53:21 +01:00
|
|
|
|
struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct type *type, int fieldno)
|
|
|
|
|
{
|
|
|
|
|
if (TYPE_FIELD_LOC_KIND (type, fieldno) == FIELD_LOC_KIND_PHYSADDR)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2010-03-16 00:53:21 +01:00
|
|
|
|
ax_const_l (ax, TYPE_FIELD_STATIC_PHYSADDR (type, fieldno));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->kind = axs_lvalue_memory;
|
2010-03-16 00:53:21 +01:00
|
|
|
|
value->type = TYPE_FIELD_TYPE (type, fieldno);
|
2010-03-17 23:04:43 +01:00
|
|
|
|
value->optimized_out = 0;
|
2010-03-16 00:53:21 +01:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2011-05-18 22:19:52 +02:00
|
|
|
|
const char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
|
2010-03-16 00:53:21 +01:00
|
|
|
|
struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0);
|
|
|
|
|
|
2010-03-17 23:04:43 +01:00
|
|
|
|
if (sym)
|
|
|
|
|
{
|
|
|
|
|
gen_var_ref (gdbarch, ax, value, sym);
|
|
|
|
|
|
|
|
|
|
/* Don't error if the value was optimized out, we may be
|
|
|
|
|
scanning all static fields and just want to pass over this
|
|
|
|
|
and continue with the rest. */
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Silently assume this was optimized out; class printing
|
|
|
|
|
will let the user know why the data is missing. */
|
|
|
|
|
value->optimized_out = 1;
|
|
|
|
|
}
|
2010-03-16 00:53:21 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
gen_struct_elt_for_reference (struct expression *exp,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct type *type, char *fieldname)
|
|
|
|
|
{
|
|
|
|
|
struct type *t = type;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
|
|
|
|
|
&& TYPE_CODE (t) != TYPE_CODE_UNION)
|
|
|
|
|
internal_error (__FILE__, __LINE__,
|
|
|
|
|
_("non-aggregate type to gen_struct_elt_for_reference"));
|
|
|
|
|
|
|
|
|
|
for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
|
|
|
|
|
{
|
|
|
|
|
char *t_field_name = TYPE_FIELD_NAME (t, i);
|
|
|
|
|
|
|
|
|
|
if (t_field_name && strcmp (t_field_name, fieldname) == 0)
|
|
|
|
|
{
|
|
|
|
|
if (field_is_static (&TYPE_FIELD (t, i)))
|
|
|
|
|
{
|
2010-03-17 23:04:43 +01:00
|
|
|
|
gen_static_field (exp->gdbarch, ax, value, t, i);
|
|
|
|
|
if (value->optimized_out)
|
2011-01-05 23:22:53 +01:00
|
|
|
|
error (_("static field `%s' has been "
|
|
|
|
|
"optimized out, cannot use"),
|
2010-03-17 23:04:43 +01:00
|
|
|
|
fieldname);
|
2010-03-16 00:53:21 +01:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
if (TYPE_FIELD_PACKED (t, i))
|
|
|
|
|
error (_("pointers to bitfield members not allowed"));
|
|
|
|
|
|
|
|
|
|
/* FIXME we need a way to do "want_address" equivalent */
|
|
|
|
|
|
|
|
|
|
error (_("Cannot reference non-static field \"%s\""), fieldname);
|
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
2010-03-16 00:53:21 +01:00
|
|
|
|
|
|
|
|
|
/* FIXME add other scoped-reference cases here */
|
|
|
|
|
|
|
|
|
|
/* Do a last-ditch lookup. */
|
|
|
|
|
return gen_maybe_namespace_elt (exp, ax, value, type, fieldname);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
2010-03-16 00:53:21 +01:00
|
|
|
|
/* C++: Return the member NAME of the namespace given by the type
|
|
|
|
|
CURTYPE. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
gen_namespace_elt (struct expression *exp,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
const struct type *curtype, char *name)
|
|
|
|
|
{
|
|
|
|
|
int found = gen_maybe_namespace_elt (exp, ax, value, curtype, name);
|
|
|
|
|
|
|
|
|
|
if (!found)
|
|
|
|
|
error (_("No symbol \"%s\" in namespace \"%s\"."),
|
|
|
|
|
name, TYPE_TAG_NAME (curtype));
|
|
|
|
|
|
|
|
|
|
return found;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* A helper function used by value_namespace_elt and
|
|
|
|
|
value_struct_elt_for_reference. It looks up NAME inside the
|
|
|
|
|
context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
|
|
|
|
|
is a class and NAME refers to a type in CURTYPE itself (as opposed
|
|
|
|
|
to, say, some base class of CURTYPE). */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
gen_maybe_namespace_elt (struct expression *exp,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
const struct type *curtype, char *name)
|
|
|
|
|
{
|
|
|
|
|
const char *namespace_name = TYPE_TAG_NAME (curtype);
|
|
|
|
|
struct symbol *sym;
|
|
|
|
|
|
|
|
|
|
sym = cp_lookup_symbol_namespace (namespace_name, name,
|
|
|
|
|
block_for_pc (ax->scope),
|
2010-03-16 01:52:54 +01:00
|
|
|
|
VAR_DOMAIN);
|
2010-03-16 00:53:21 +01:00
|
|
|
|
|
|
|
|
|
if (sym == NULL)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
gen_var_ref (exp->gdbarch, ax, value, sym);
|
|
|
|
|
|
2010-03-17 23:04:43 +01:00
|
|
|
|
if (value->optimized_out)
|
|
|
|
|
error (_("`%s' has been optimized out, cannot use"),
|
|
|
|
|
SYMBOL_PRINT_NAME (sym));
|
|
|
|
|
|
2010-03-16 00:53:21 +01:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
gen_aggregate_elt_ref (struct expression *exp,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct type *type, char *field,
|
|
|
|
|
char *operator_name, char *operand_name)
|
|
|
|
|
{
|
|
|
|
|
switch (TYPE_CODE (type))
|
|
|
|
|
{
|
|
|
|
|
case TYPE_CODE_STRUCT:
|
|
|
|
|
case TYPE_CODE_UNION:
|
|
|
|
|
return gen_struct_elt_for_reference (exp, ax, value, type, field);
|
|
|
|
|
break;
|
|
|
|
|
case TYPE_CODE_NAMESPACE:
|
|
|
|
|
return gen_namespace_elt (exp, ax, value, type, field);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
internal_error (__FILE__, __LINE__,
|
|
|
|
|
_("non-aggregate type in gen_aggregate_elt_ref"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2010-12-31 20:16:37 +01:00
|
|
|
|
/* Generate code for GDB's magical `repeat' operator.
|
1999-04-16 03:35:26 +02:00
|
|
|
|
LVALUE @ INT creates an array INT elements long, and whose elements
|
|
|
|
|
have the same type as LVALUE, located in memory so that LVALUE is
|
|
|
|
|
its first element. For example, argv[0]@argc gives you the array
|
|
|
|
|
of command-line arguments.
|
|
|
|
|
|
|
|
|
|
Unfortunately, because we have to know the types before we actually
|
|
|
|
|
have a value for the expression, we can't implement this perfectly
|
|
|
|
|
without changing the type system, having values that occupy two
|
|
|
|
|
stack slots, doing weird things with sizeof, etc. So we require
|
|
|
|
|
the right operand to be a constant expression. */
|
|
|
|
|
static void
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_repeat (struct expression *exp, union exp_element **pc,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
struct axs_value value1;
|
2010-05-18 21:23:37 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* We don't want to turn this into an rvalue, so no conversions
|
|
|
|
|
here. */
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (exp, pc, ax, &value1);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
if (value1.kind != axs_lvalue_memory)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Left operand of `@' must be an object in memory."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Evaluate the length; it had better be a constant. */
|
|
|
|
|
{
|
|
|
|
|
struct value *v = const_expr (pc);
|
|
|
|
|
int length;
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
if (!v)
|
2011-01-05 23:22:53 +01:00
|
|
|
|
error (_("Right operand of `@' must be a "
|
|
|
|
|
"constant, in agent expressions."));
|
2005-02-07 Andrew Cagney <cagney@gnu.org>
* value.h (deprecated_set_value_type): Declare.
* value.c (deprecated_set_value_type): Define.
* hpacc-abi.c, gnu-v2-abi.c, cp-valprint.c: Update.
* c-valprint.c, jv-lang.c, objc-lang.c, ada-lang.c: Update.
* infcall.c, printcmd.c, valops.c, eval.c, p-exp.y: Update.
* ax-gdb.c, tracepoint.c: Update.
2005-02-08 00:51:03 +01:00
|
|
|
|
if (TYPE_CODE (value_type (v)) != TYPE_CODE_INT)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Right operand of `@' must be an integer."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
length = value_as_long (v);
|
|
|
|
|
if (length <= 0)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Right operand of `@' must be positive."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* The top of the stack is already the address of the object, so
|
|
|
|
|
all we need to do is frob the type of the lvalue. */
|
|
|
|
|
{
|
|
|
|
|
/* FIXME-type-allocation: need a way to free this type when we are
|
1999-07-07 22:19:36 +02:00
|
|
|
|
done with it. */
|
2009-07-02 14:18:46 +02:00
|
|
|
|
struct type *array
|
|
|
|
|
= lookup_array_range_type (value1.type, 0, length - 1);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
value->type = array;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Emit code for the `sizeof' operator.
|
|
|
|
|
*PC should point at the start of the operand expression; we advance it
|
|
|
|
|
to the first instruction after the operand. */
|
|
|
|
|
static void
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_sizeof (struct expression *exp, union exp_element **pc,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct type *size_type)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* We don't care about the value of the operand expression; we only
|
|
|
|
|
care about its type. However, in the current arrangement, the
|
|
|
|
|
only way to find an expression's type is to generate code for it.
|
|
|
|
|
So we generate code for the operand, and then throw it away,
|
|
|
|
|
replacing it with code that simply pushes its size. */
|
|
|
|
|
int start = ax->len;
|
2010-05-18 21:23:37 +02:00
|
|
|
|
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (exp, pc, ax, value);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Throw away the code we just generated. */
|
|
|
|
|
ax->len = start;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ax_const_l (ax, TYPE_LENGTH (value->type));
|
|
|
|
|
value->kind = axs_rvalue;
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
value->type = size_type;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Generating bytecode from GDB expressions: general recursive thingy */
|
|
|
|
|
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
/* XXX: i18n */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* A gen_expr function written by a Gen-X'er guy.
|
|
|
|
|
Append code for the subexpression of EXPR starting at *POS_P to AX. */
|
|
|
|
|
static void
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (struct expression *exp, union exp_element **pc,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
/* Used to hold the descriptions of operand expressions. */
|
2009-12-30 00:21:38 +01:00
|
|
|
|
struct axs_value value1, value2, value3;
|
2009-12-29 00:39:10 +01:00
|
|
|
|
enum exp_opcode op = (*pc)[0].opcode, op2;
|
2009-12-30 00:21:38 +01:00
|
|
|
|
int if1, go1, if2, go2, end;
|
2010-03-19 23:00:17 +01:00
|
|
|
|
struct type *int_type = builtin_type (exp->gdbarch)->builtin_int;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* If we're looking at a constant expression, just push its value. */
|
|
|
|
|
{
|
|
|
|
|
struct value *v = maybe_const_expr (pc);
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
if (v)
|
|
|
|
|
{
|
|
|
|
|
ax_const_l (ax, value_as_long (v));
|
|
|
|
|
value->kind = axs_rvalue;
|
2004-11-12 Andrew Cagney <cagney@gnu.org>
* value.h (VALUE_TYPE, VALUE_NEXT, VALUE_OFFSET, VALUE_BITSIZE)
(VALUE_BITPOS): Delete.
(value_type, value_offset, value_bitsize, value_bitpos): Declare.
* value.c (value_type, value_offset, value_bitpos)
(value_bitsize): New functions. Update references.
* arm-tdep.c, gnu-v3-abi.c, hpacc-abi.c, gnu-v2-abi.c: Update.
* f-valprint.c, cp-valprint.c, c-valprint.c: Update.
* ada-valprint.c, typeprint.c, scm-valprint.c, scm-exp.c: Update.
* p-valprint.c, jv-valprint.c, jv-lang.c, varobj.c: Update.
* objc-lang.c, ada-lang.c, std-regs.c, stack.c: Update.
* infcall.c, linespec.c, printcmd.c, valarith.c: Update.
* valops.c, eval.c, findvar.c, breakpoint.c: Update.
* tracepoint.c, ax-gdb.c, mi/mi-main.c, cli/cli-dump.c:
* rs6000-tdep.c, ppc-sysv-tdep.c: Update.
2004-11-12 22:45:08 +01:00
|
|
|
|
value->type = check_typedef (value_type (v));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Otherwise, go ahead and generate code for it. */
|
|
|
|
|
switch (op)
|
|
|
|
|
{
|
|
|
|
|
/* Binary arithmetic operators. */
|
|
|
|
|
case BINOP_ADD:
|
|
|
|
|
case BINOP_SUB:
|
|
|
|
|
case BINOP_MUL:
|
|
|
|
|
case BINOP_DIV:
|
|
|
|
|
case BINOP_REM:
|
2010-03-13 00:13:19 +01:00
|
|
|
|
case BINOP_LSH:
|
|
|
|
|
case BINOP_RSH:
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case BINOP_SUBSCRIPT:
|
|
|
|
|
case BINOP_BITWISE_AND:
|
|
|
|
|
case BINOP_BITWISE_IOR:
|
|
|
|
|
case BINOP_BITWISE_XOR:
|
2009-07-14 23:40:34 +02:00
|
|
|
|
case BINOP_EQUAL:
|
|
|
|
|
case BINOP_NOTEQUAL:
|
|
|
|
|
case BINOP_LESS:
|
|
|
|
|
case BINOP_GTR:
|
|
|
|
|
case BINOP_LEQ:
|
|
|
|
|
case BINOP_GEQ:
|
1999-04-16 03:35:26 +02:00
|
|
|
|
(*pc)++;
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (exp, pc, ax, &value1);
|
|
|
|
|
gen_usual_unary (exp, ax, &value1);
|
2009-12-29 00:39:10 +01:00
|
|
|
|
gen_expr_binop_rest (exp, op, pc, ax, value, &value1, &value2);
|
|
|
|
|
break;
|
|
|
|
|
|
2009-12-30 00:21:38 +01:00
|
|
|
|
case BINOP_LOGICAL_AND:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
/* Generate the obvious sequence of tests and jumps. */
|
|
|
|
|
gen_expr (exp, pc, ax, &value1);
|
|
|
|
|
gen_usual_unary (exp, ax, &value1);
|
|
|
|
|
if1 = ax_goto (ax, aop_if_goto);
|
|
|
|
|
go1 = ax_goto (ax, aop_goto);
|
|
|
|
|
ax_label (ax, if1, ax->len);
|
|
|
|
|
gen_expr (exp, pc, ax, &value2);
|
|
|
|
|
gen_usual_unary (exp, ax, &value2);
|
|
|
|
|
if2 = ax_goto (ax, aop_if_goto);
|
|
|
|
|
go2 = ax_goto (ax, aop_goto);
|
|
|
|
|
ax_label (ax, if2, ax->len);
|
|
|
|
|
ax_const_l (ax, 1);
|
|
|
|
|
end = ax_goto (ax, aop_goto);
|
|
|
|
|
ax_label (ax, go1, ax->len);
|
|
|
|
|
ax_label (ax, go2, ax->len);
|
|
|
|
|
ax_const_l (ax, 0);
|
|
|
|
|
ax_label (ax, end, ax->len);
|
|
|
|
|
value->kind = axs_rvalue;
|
2010-03-19 23:00:17 +01:00
|
|
|
|
value->type = int_type;
|
2009-12-30 00:21:38 +01:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BINOP_LOGICAL_OR:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
/* Generate the obvious sequence of tests and jumps. */
|
|
|
|
|
gen_expr (exp, pc, ax, &value1);
|
|
|
|
|
gen_usual_unary (exp, ax, &value1);
|
|
|
|
|
if1 = ax_goto (ax, aop_if_goto);
|
|
|
|
|
gen_expr (exp, pc, ax, &value2);
|
|
|
|
|
gen_usual_unary (exp, ax, &value2);
|
|
|
|
|
if2 = ax_goto (ax, aop_if_goto);
|
|
|
|
|
ax_const_l (ax, 0);
|
|
|
|
|
end = ax_goto (ax, aop_goto);
|
|
|
|
|
ax_label (ax, if1, ax->len);
|
|
|
|
|
ax_label (ax, if2, ax->len);
|
|
|
|
|
ax_const_l (ax, 1);
|
|
|
|
|
ax_label (ax, end, ax->len);
|
|
|
|
|
value->kind = axs_rvalue;
|
2010-03-19 23:00:17 +01:00
|
|
|
|
value->type = int_type;
|
2009-12-30 00:21:38 +01:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TERNOP_COND:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
gen_expr (exp, pc, ax, &value1);
|
|
|
|
|
gen_usual_unary (exp, ax, &value1);
|
|
|
|
|
/* For (A ? B : C), it's easiest to generate subexpression
|
|
|
|
|
bytecodes in order, but if_goto jumps on true, so we invert
|
|
|
|
|
the sense of A. Then we can do B by dropping through, and
|
|
|
|
|
jump to do C. */
|
2010-03-19 23:00:17 +01:00
|
|
|
|
gen_logical_not (ax, &value1, int_type);
|
2009-12-30 00:21:38 +01:00
|
|
|
|
if1 = ax_goto (ax, aop_if_goto);
|
|
|
|
|
gen_expr (exp, pc, ax, &value2);
|
|
|
|
|
gen_usual_unary (exp, ax, &value2);
|
|
|
|
|
end = ax_goto (ax, aop_goto);
|
|
|
|
|
ax_label (ax, if1, ax->len);
|
|
|
|
|
gen_expr (exp, pc, ax, &value3);
|
|
|
|
|
gen_usual_unary (exp, ax, &value3);
|
|
|
|
|
ax_label (ax, end, ax->len);
|
|
|
|
|
/* This is arbitary - what if B and C are incompatible types? */
|
|
|
|
|
value->type = value2.type;
|
|
|
|
|
value->kind = value2.kind;
|
|
|
|
|
break;
|
|
|
|
|
|
2009-12-29 00:39:10 +01:00
|
|
|
|
case BINOP_ASSIGN:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
if ((*pc)[0].opcode == OP_INTERNALVAR)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
2009-12-29 00:39:10 +01:00
|
|
|
|
char *name = internalvar_name ((*pc)[1].internalvar);
|
|
|
|
|
struct trace_state_variable *tsv;
|
2010-05-18 21:23:37 +02:00
|
|
|
|
|
2009-12-29 00:39:10 +01:00
|
|
|
|
(*pc) += 3;
|
|
|
|
|
gen_expr (exp, pc, ax, value);
|
|
|
|
|
tsv = find_trace_state_variable (name);
|
|
|
|
|
if (tsv)
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
{
|
2009-12-29 00:39:10 +01:00
|
|
|
|
ax_tsv (ax, aop_setv, tsv->number);
|
|
|
|
|
if (trace_kludge)
|
|
|
|
|
ax_tsv (ax, aop_tracev, tsv->number);
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
2011-01-05 23:22:53 +01:00
|
|
|
|
error (_("$%s is not a trace state variable, "
|
|
|
|
|
"may not assign to it"), name);
|
2009-12-29 00:39:10 +01:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
error (_("May only assign to trace state variables"));
|
|
|
|
|
break;
|
2009-07-14 23:40:34 +02:00
|
|
|
|
|
2009-12-29 00:39:10 +01:00
|
|
|
|
case BINOP_ASSIGN_MODIFY:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
op2 = (*pc)[0].opcode;
|
|
|
|
|
(*pc)++;
|
|
|
|
|
(*pc)++;
|
|
|
|
|
if ((*pc)[0].opcode == OP_INTERNALVAR)
|
|
|
|
|
{
|
|
|
|
|
char *name = internalvar_name ((*pc)[1].internalvar);
|
|
|
|
|
struct trace_state_variable *tsv;
|
2010-05-18 21:23:37 +02:00
|
|
|
|
|
2009-12-29 00:39:10 +01:00
|
|
|
|
(*pc) += 3;
|
|
|
|
|
tsv = find_trace_state_variable (name);
|
|
|
|
|
if (tsv)
|
|
|
|
|
{
|
|
|
|
|
/* The tsv will be the left half of the binary operation. */
|
|
|
|
|
ax_tsv (ax, aop_getv, tsv->number);
|
|
|
|
|
if (trace_kludge)
|
|
|
|
|
ax_tsv (ax, aop_tracev, tsv->number);
|
|
|
|
|
/* Trace state variables are always 64-bit integers. */
|
|
|
|
|
value1.kind = axs_rvalue;
|
|
|
|
|
value1.type = builtin_type (exp->gdbarch)->builtin_long_long;
|
|
|
|
|
/* Now do right half of expression. */
|
|
|
|
|
gen_expr_binop_rest (exp, op2, pc, ax, value, &value1, &value2);
|
|
|
|
|
/* We have a result of the binary op, set the tsv. */
|
|
|
|
|
ax_tsv (ax, aop_setv, tsv->number);
|
|
|
|
|
if (trace_kludge)
|
|
|
|
|
ax_tsv (ax, aop_tracev, tsv->number);
|
|
|
|
|
}
|
|
|
|
|
else
|
2011-01-05 23:22:53 +01:00
|
|
|
|
error (_("$%s is not a trace state variable, "
|
|
|
|
|
"may not assign to it"), name);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
2009-12-29 00:39:10 +01:00
|
|
|
|
else
|
|
|
|
|
error (_("May only assign to trace state variables"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Note that we need to be a little subtle about generating code
|
1999-07-07 22:19:36 +02:00
|
|
|
|
for comma. In C, we can do some optimizations here because
|
|
|
|
|
we know the left operand is only being evaluated for effect.
|
|
|
|
|
However, if the tracing kludge is in effect, then we always
|
|
|
|
|
need to evaluate the left hand side fully, so that all the
|
|
|
|
|
variables it mentions get traced. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case BINOP_COMMA:
|
|
|
|
|
(*pc)++;
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (exp, pc, ax, &value1);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Don't just dispose of the left operand. We might be tracing,
|
1999-07-07 22:19:36 +02:00
|
|
|
|
in which case we want to emit code to trace it if it's an
|
|
|
|
|
lvalue. */
|
2010-03-17 23:04:43 +01:00
|
|
|
|
gen_traced_pop (exp->gdbarch, ax, &value1);
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (exp, pc, ax, value);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* It's the consumer's responsibility to trace the right operand. */
|
|
|
|
|
break;
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case OP_LONG: /* some integer constant */
|
|
|
|
|
{
|
|
|
|
|
struct type *type = (*pc)[1].type;
|
|
|
|
|
LONGEST k = (*pc)[2].longconst;
|
2010-05-18 21:23:37 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
(*pc) += 4;
|
|
|
|
|
gen_int_literal (ax, value, k, type);
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case OP_VAR_VALUE:
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_var_ref (exp->gdbarch, ax, value, (*pc)[2].symbol);
|
2010-03-17 23:04:43 +01:00
|
|
|
|
|
|
|
|
|
if (value->optimized_out)
|
|
|
|
|
error (_("`%s' has been optimized out, cannot use"),
|
|
|
|
|
SYMBOL_PRINT_NAME ((*pc)[2].symbol));
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
(*pc) += 4;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OP_REGISTER:
|
|
|
|
|
{
|
2007-06-13 19:11:09 +02:00
|
|
|
|
const char *name = &(*pc)[2].string;
|
|
|
|
|
int reg;
|
2010-05-18 21:23:37 +02:00
|
|
|
|
|
2007-06-13 19:11:09 +02:00
|
|
|
|
(*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1);
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
reg = user_reg_map_name_to_regnum (exp->gdbarch, name, strlen (name));
|
2007-06-13 19:11:09 +02:00
|
|
|
|
if (reg == -1)
|
|
|
|
|
internal_error (__FILE__, __LINE__,
|
|
|
|
|
_("Register $%s not available"), name);
|
2010-12-28 18:59:58 +01:00
|
|
|
|
/* No support for tracing user registers yet. */
|
|
|
|
|
if (reg >= gdbarch_num_regs (exp->gdbarch)
|
|
|
|
|
+ gdbarch_num_pseudo_regs (exp->gdbarch))
|
2010-12-29 13:47:19 +01:00
|
|
|
|
error (_("'%s' is a user-register; "
|
|
|
|
|
"GDB cannot yet trace user-register contents."),
|
2010-12-28 18:59:58 +01:00
|
|
|
|
name);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->kind = axs_lvalue_register;
|
|
|
|
|
value->u.reg = reg;
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
value->type = register_type (exp->gdbarch, reg);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case OP_INTERNALVAR:
|
2009-12-29 00:39:10 +01:00
|
|
|
|
{
|
|
|
|
|
const char *name = internalvar_name ((*pc)[1].internalvar);
|
|
|
|
|
struct trace_state_variable *tsv;
|
2010-05-18 21:23:37 +02:00
|
|
|
|
|
2009-12-29 00:39:10 +01:00
|
|
|
|
(*pc) += 3;
|
|
|
|
|
tsv = find_trace_state_variable (name);
|
|
|
|
|
if (tsv)
|
|
|
|
|
{
|
|
|
|
|
ax_tsv (ax, aop_getv, tsv->number);
|
|
|
|
|
if (trace_kludge)
|
|
|
|
|
ax_tsv (ax, aop_tracev, tsv->number);
|
|
|
|
|
/* Trace state variables are always 64-bit integers. */
|
|
|
|
|
value->kind = axs_rvalue;
|
|
|
|
|
value->type = builtin_type (exp->gdbarch)->builtin_long_long;
|
|
|
|
|
}
|
|
|
|
|
else
|
2011-01-05 23:22:53 +01:00
|
|
|
|
error (_("$%s is not a trace state variable; GDB agent "
|
|
|
|
|
"expressions cannot use convenience variables."), name);
|
2009-12-29 00:39:10 +01:00
|
|
|
|
}
|
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
/* Weirdo operator: see comments for gen_repeat for details. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case BINOP_REPEAT:
|
|
|
|
|
/* Note that gen_repeat handles its own argument evaluation. */
|
|
|
|
|
(*pc)++;
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_repeat (exp, pc, ax, value);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNOP_CAST:
|
|
|
|
|
{
|
|
|
|
|
struct type *type = (*pc)[1].type;
|
2010-05-18 21:23:37 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
(*pc) += 3;
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (exp, pc, ax, value);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_cast (ax, value, type);
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
case UNOP_MEMVAL:
|
|
|
|
|
{
|
|
|
|
|
struct type *type = check_typedef ((*pc)[1].type);
|
2010-05-18 21:23:37 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
(*pc) += 3;
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (exp, pc, ax, value);
|
2011-02-16 19:07:58 +01:00
|
|
|
|
|
|
|
|
|
/* If we have an axs_rvalue or an axs_lvalue_memory, then we
|
|
|
|
|
already have the right value on the stack. For
|
|
|
|
|
axs_lvalue_register, we must convert. */
|
|
|
|
|
if (value->kind == axs_lvalue_register)
|
|
|
|
|
require_rvalue (ax, value);
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
value->type = type;
|
|
|
|
|
value->kind = axs_lvalue_memory;
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2005-03-08 15:35:20 +01:00
|
|
|
|
case UNOP_PLUS:
|
|
|
|
|
(*pc)++;
|
2010-12-31 20:16:37 +01:00
|
|
|
|
/* + FOO is equivalent to 0 + FOO, which can be optimized. */
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (exp, pc, ax, value);
|
|
|
|
|
gen_usual_unary (exp, ax, value);
|
2005-03-08 15:35:20 +01:00
|
|
|
|
break;
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case UNOP_NEG:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
/* -FOO is equivalent to 0 - FOO. */
|
2009-07-02 14:20:18 +02:00
|
|
|
|
gen_int_literal (ax, &value1, 0,
|
|
|
|
|
builtin_type (exp->gdbarch)->builtin_int);
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_usual_unary (exp, ax, &value1); /* shouldn't do much */
|
|
|
|
|
gen_expr (exp, pc, ax, &value2);
|
|
|
|
|
gen_usual_unary (exp, ax, &value2);
|
|
|
|
|
gen_usual_arithmetic (exp, ax, &value1, &value2);
|
|
|
|
|
gen_binop (ax, value, &value1, &value2, aop_sub, aop_sub, 1, "negation");
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNOP_LOGICAL_NOT:
|
|
|
|
|
(*pc)++;
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (exp, pc, ax, value);
|
|
|
|
|
gen_usual_unary (exp, ax, value);
|
2010-03-19 23:00:17 +01:00
|
|
|
|
gen_logical_not (ax, value, int_type);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNOP_COMPLEMENT:
|
|
|
|
|
(*pc)++;
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (exp, pc, ax, value);
|
|
|
|
|
gen_usual_unary (exp, ax, value);
|
|
|
|
|
gen_integral_promotions (exp, ax, value);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_complement (ax, value);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNOP_IND:
|
|
|
|
|
(*pc)++;
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (exp, pc, ax, value);
|
|
|
|
|
gen_usual_unary (exp, ax, value);
|
2009-12-30 00:57:59 +01:00
|
|
|
|
if (!pointer_type (value->type))
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Argument of unary `*' is not a pointer."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_deref (ax, value);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNOP_ADDR:
|
|
|
|
|
(*pc)++;
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (exp, pc, ax, value);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
gen_address_of (ax, value);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNOP_SIZEOF:
|
|
|
|
|
(*pc)++;
|
|
|
|
|
/* Notice that gen_sizeof handles its own operand, unlike most
|
1999-07-07 22:19:36 +02:00
|
|
|
|
of the other unary operator functions. This is because we
|
|
|
|
|
have to throw away the code we generate. */
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_sizeof (exp, pc, ax, value,
|
|
|
|
|
builtin_type (exp->gdbarch)->builtin_int);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case STRUCTOP_STRUCT:
|
|
|
|
|
case STRUCTOP_PTR:
|
|
|
|
|
{
|
|
|
|
|
int length = (*pc)[1].longconst;
|
|
|
|
|
char *name = &(*pc)[2].string;
|
|
|
|
|
|
|
|
|
|
(*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1);
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (exp, pc, ax, value);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
if (op == STRUCTOP_STRUCT)
|
2009-06-17 20:40:53 +02:00
|
|
|
|
gen_struct_ref (exp, ax, value, name, ".", "structure or union");
|
1999-04-16 03:35:26 +02:00
|
|
|
|
else if (op == STRUCTOP_PTR)
|
2009-06-17 20:40:53 +02:00
|
|
|
|
gen_struct_ref (exp, ax, value, name, "->",
|
1999-04-16 03:35:26 +02:00
|
|
|
|
"pointer to a structure or union");
|
|
|
|
|
else
|
|
|
|
|
/* If this `if' chain doesn't handle it, then the case list
|
1999-07-07 22:19:36 +02:00
|
|
|
|
shouldn't mention it, and we shouldn't be here. */
|
2001-02-08 07:03:54 +01:00
|
|
|
|
internal_error (__FILE__, __LINE__,
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
_("gen_expr: unhandled struct case"));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
break;
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
2009-12-24 02:42:03 +01:00
|
|
|
|
case OP_THIS:
|
|
|
|
|
{
|
2009-12-28 17:49:14 +01:00
|
|
|
|
char *this_name;
|
2011-06-17 22:46:47 +02:00
|
|
|
|
struct symbol *sym, *func;
|
2009-12-24 02:42:03 +01:00
|
|
|
|
struct block *b;
|
2011-06-17 22:46:47 +02:00
|
|
|
|
const struct language_defn *lang;
|
2009-12-24 02:42:03 +01:00
|
|
|
|
|
2011-06-17 22:46:47 +02:00
|
|
|
|
b = block_for_pc (ax->scope);
|
|
|
|
|
func = block_linkage_function (b);
|
|
|
|
|
lang = language_def (SYMBOL_LANGUAGE (func));
|
2009-12-24 02:42:03 +01:00
|
|
|
|
|
2011-06-17 22:46:47 +02:00
|
|
|
|
sym = lookup_language_this (lang, b);
|
2009-12-24 02:42:03 +01:00
|
|
|
|
if (!sym)
|
2011-06-17 22:46:47 +02:00
|
|
|
|
error (_("no `%s' found"), lang->la_name_of_this);
|
2009-12-24 02:42:03 +01:00
|
|
|
|
|
|
|
|
|
gen_var_ref (exp->gdbarch, ax, value, sym);
|
2010-03-17 23:04:43 +01:00
|
|
|
|
|
|
|
|
|
if (value->optimized_out)
|
|
|
|
|
error (_("`%s' has been optimized out, cannot use"),
|
|
|
|
|
SYMBOL_PRINT_NAME (sym));
|
|
|
|
|
|
2009-12-24 02:42:03 +01:00
|
|
|
|
(*pc) += 2;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
2010-03-16 00:53:21 +01:00
|
|
|
|
case OP_SCOPE:
|
|
|
|
|
{
|
|
|
|
|
struct type *type = (*pc)[1].type;
|
|
|
|
|
int length = longest_to_int ((*pc)[2].longconst);
|
|
|
|
|
char *name = &(*pc)[3].string;
|
|
|
|
|
int found;
|
|
|
|
|
|
|
|
|
|
found = gen_aggregate_elt_ref (exp, ax, value, type, name,
|
|
|
|
|
"?", "??");
|
|
|
|
|
if (!found)
|
|
|
|
|
error (_("There is no field named %s"), name);
|
|
|
|
|
(*pc) += 5 + BYTES_TO_EXP_ELEM (length + 1);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
case OP_TYPE:
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("Attempt to use a type name as an expression."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
default:
|
2010-03-16 00:53:21 +01:00
|
|
|
|
error (_("Unsupported operator %s (%d) in expression."),
|
|
|
|
|
op_string (op), op);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
2009-12-29 00:39:10 +01:00
|
|
|
|
|
|
|
|
|
/* This handles the middle-to-right-side of code generation for binary
|
|
|
|
|
expressions, which is shared between regular binary operations and
|
|
|
|
|
assign-modify (+= and friends) expressions. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
gen_expr_binop_rest (struct expression *exp,
|
|
|
|
|
enum exp_opcode op, union exp_element **pc,
|
|
|
|
|
struct agent_expr *ax, struct axs_value *value,
|
|
|
|
|
struct axs_value *value1, struct axs_value *value2)
|
|
|
|
|
{
|
2010-03-19 23:00:17 +01:00
|
|
|
|
struct type *int_type = builtin_type (exp->gdbarch)->builtin_int;
|
|
|
|
|
|
2009-12-29 00:39:10 +01:00
|
|
|
|
gen_expr (exp, pc, ax, value2);
|
|
|
|
|
gen_usual_unary (exp, ax, value2);
|
|
|
|
|
gen_usual_arithmetic (exp, ax, value1, value2);
|
|
|
|
|
switch (op)
|
|
|
|
|
{
|
|
|
|
|
case BINOP_ADD:
|
|
|
|
|
if (TYPE_CODE (value1->type) == TYPE_CODE_INT
|
2009-12-30 00:57:59 +01:00
|
|
|
|
&& pointer_type (value2->type))
|
2009-12-29 00:39:10 +01:00
|
|
|
|
{
|
|
|
|
|
/* Swap the values and proceed normally. */
|
|
|
|
|
ax_simple (ax, aop_swap);
|
|
|
|
|
gen_ptradd (ax, value, value2, value1);
|
|
|
|
|
}
|
2009-12-30 00:57:59 +01:00
|
|
|
|
else if (pointer_type (value1->type)
|
2009-12-29 00:39:10 +01:00
|
|
|
|
&& TYPE_CODE (value2->type) == TYPE_CODE_INT)
|
|
|
|
|
gen_ptradd (ax, value, value1, value2);
|
|
|
|
|
else
|
|
|
|
|
gen_binop (ax, value, value1, value2,
|
|
|
|
|
aop_add, aop_add, 1, "addition");
|
|
|
|
|
break;
|
|
|
|
|
case BINOP_SUB:
|
2009-12-30 00:57:59 +01:00
|
|
|
|
if (pointer_type (value1->type)
|
2009-12-29 00:39:10 +01:00
|
|
|
|
&& TYPE_CODE (value2->type) == TYPE_CODE_INT)
|
|
|
|
|
gen_ptrsub (ax,value, value1, value2);
|
2009-12-30 00:57:59 +01:00
|
|
|
|
else if (pointer_type (value1->type)
|
|
|
|
|
&& pointer_type (value2->type))
|
2009-12-29 00:39:10 +01:00
|
|
|
|
/* FIXME --- result type should be ptrdiff_t */
|
|
|
|
|
gen_ptrdiff (ax, value, value1, value2,
|
|
|
|
|
builtin_type (exp->gdbarch)->builtin_long);
|
|
|
|
|
else
|
|
|
|
|
gen_binop (ax, value, value1, value2,
|
|
|
|
|
aop_sub, aop_sub, 1, "subtraction");
|
|
|
|
|
break;
|
|
|
|
|
case BINOP_MUL:
|
|
|
|
|
gen_binop (ax, value, value1, value2,
|
|
|
|
|
aop_mul, aop_mul, 1, "multiplication");
|
|
|
|
|
break;
|
|
|
|
|
case BINOP_DIV:
|
|
|
|
|
gen_binop (ax, value, value1, value2,
|
|
|
|
|
aop_div_signed, aop_div_unsigned, 1, "division");
|
|
|
|
|
break;
|
|
|
|
|
case BINOP_REM:
|
|
|
|
|
gen_binop (ax, value, value1, value2,
|
|
|
|
|
aop_rem_signed, aop_rem_unsigned, 1, "remainder");
|
|
|
|
|
break;
|
2010-03-13 00:13:19 +01:00
|
|
|
|
case BINOP_LSH:
|
|
|
|
|
gen_binop (ax, value, value1, value2,
|
|
|
|
|
aop_lsh, aop_lsh, 1, "left shift");
|
|
|
|
|
break;
|
|
|
|
|
case BINOP_RSH:
|
|
|
|
|
gen_binop (ax, value, value1, value2,
|
|
|
|
|
aop_rsh_signed, aop_rsh_unsigned, 1, "right shift");
|
|
|
|
|
break;
|
2009-12-29 00:39:10 +01:00
|
|
|
|
case BINOP_SUBSCRIPT:
|
2010-02-11 22:45:25 +01:00
|
|
|
|
{
|
|
|
|
|
struct type *type;
|
|
|
|
|
|
|
|
|
|
if (binop_types_user_defined_p (op, value1->type, value2->type))
|
|
|
|
|
{
|
2011-01-05 23:22:53 +01:00
|
|
|
|
error (_("cannot subscript requested type: "
|
|
|
|
|
"cannot call user defined functions"));
|
2010-02-11 22:45:25 +01:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* If the user attempts to subscript something that is not
|
|
|
|
|
an array or pointer type (like a plain int variable for
|
|
|
|
|
example), then report this as an error. */
|
|
|
|
|
type = check_typedef (value1->type);
|
|
|
|
|
if (TYPE_CODE (type) != TYPE_CODE_ARRAY
|
|
|
|
|
&& TYPE_CODE (type) != TYPE_CODE_PTR)
|
|
|
|
|
{
|
|
|
|
|
if (TYPE_NAME (type))
|
|
|
|
|
error (_("cannot subscript something of type `%s'"),
|
|
|
|
|
TYPE_NAME (type));
|
|
|
|
|
else
|
|
|
|
|
error (_("cannot subscript requested type"));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-02-12 00:03:22 +01:00
|
|
|
|
if (!is_integral_type (value2->type))
|
2011-01-05 23:22:53 +01:00
|
|
|
|
error (_("Argument to arithmetic operation "
|
|
|
|
|
"not a number or boolean."));
|
2010-02-12 00:03:22 +01:00
|
|
|
|
|
2010-02-11 22:45:25 +01:00
|
|
|
|
gen_ptradd (ax, value, value1, value2);
|
|
|
|
|
gen_deref (ax, value);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2009-12-29 00:39:10 +01:00
|
|
|
|
case BINOP_BITWISE_AND:
|
|
|
|
|
gen_binop (ax, value, value1, value2,
|
|
|
|
|
aop_bit_and, aop_bit_and, 0, "bitwise and");
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BINOP_BITWISE_IOR:
|
|
|
|
|
gen_binop (ax, value, value1, value2,
|
|
|
|
|
aop_bit_or, aop_bit_or, 0, "bitwise or");
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BINOP_BITWISE_XOR:
|
|
|
|
|
gen_binop (ax, value, value1, value2,
|
|
|
|
|
aop_bit_xor, aop_bit_xor, 0, "bitwise exclusive-or");
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BINOP_EQUAL:
|
2010-03-19 23:00:17 +01:00
|
|
|
|
gen_equal (ax, value, value1, value2, int_type);
|
2009-12-29 00:39:10 +01:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BINOP_NOTEQUAL:
|
2010-03-19 23:00:17 +01:00
|
|
|
|
gen_equal (ax, value, value1, value2, int_type);
|
|
|
|
|
gen_logical_not (ax, value, int_type);
|
2009-12-29 00:39:10 +01:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BINOP_LESS:
|
2010-03-19 23:00:17 +01:00
|
|
|
|
gen_less (ax, value, value1, value2, int_type);
|
2009-12-29 00:39:10 +01:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BINOP_GTR:
|
|
|
|
|
ax_simple (ax, aop_swap);
|
2010-03-19 23:00:17 +01:00
|
|
|
|
gen_less (ax, value, value1, value2, int_type);
|
2009-12-29 00:39:10 +01:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BINOP_LEQ:
|
|
|
|
|
ax_simple (ax, aop_swap);
|
2010-03-19 23:00:17 +01:00
|
|
|
|
gen_less (ax, value, value1, value2, int_type);
|
|
|
|
|
gen_logical_not (ax, value, int_type);
|
2009-12-29 00:39:10 +01:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BINOP_GEQ:
|
2010-03-19 23:00:17 +01:00
|
|
|
|
gen_less (ax, value, value1, value2, int_type);
|
|
|
|
|
gen_logical_not (ax, value, int_type);
|
2009-12-29 00:39:10 +01:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
/* We should only list operators in the outer case statement
|
|
|
|
|
that we actually handle in the inner case statement. */
|
|
|
|
|
internal_error (__FILE__, __LINE__,
|
|
|
|
|
_("gen_expr: op case sets don't match"));
|
|
|
|
|
}
|
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
2009-12-24 01:40:49 +01:00
|
|
|
|
/* Given a single variable and a scope, generate bytecodes to trace
|
|
|
|
|
its value. This is for use in situations where we have only a
|
|
|
|
|
variable's name, and no parsed expression; for instance, when the
|
|
|
|
|
name comes from a list of local variables of a function. */
|
|
|
|
|
|
|
|
|
|
struct agent_expr *
|
2010-03-17 23:04:43 +01:00
|
|
|
|
gen_trace_for_var (CORE_ADDR scope, struct gdbarch *gdbarch,
|
|
|
|
|
struct symbol *var)
|
2009-12-24 01:40:49 +01:00
|
|
|
|
{
|
|
|
|
|
struct cleanup *old_chain = 0;
|
2010-04-24 01:51:05 +02:00
|
|
|
|
struct agent_expr *ax = new_agent_expr (gdbarch, scope);
|
2009-12-24 01:40:49 +01:00
|
|
|
|
struct axs_value value;
|
|
|
|
|
|
|
|
|
|
old_chain = make_cleanup_free_agent_expr (ax);
|
|
|
|
|
|
|
|
|
|
trace_kludge = 1;
|
2010-03-17 23:04:43 +01:00
|
|
|
|
gen_var_ref (gdbarch, ax, &value, var);
|
|
|
|
|
|
|
|
|
|
/* If there is no actual variable to trace, flag it by returning
|
|
|
|
|
an empty agent expression. */
|
|
|
|
|
if (value.optimized_out)
|
|
|
|
|
{
|
|
|
|
|
do_cleanups (old_chain);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2009-12-24 01:40:49 +01:00
|
|
|
|
|
|
|
|
|
/* Make sure we record the final object, and get rid of it. */
|
2010-03-17 23:04:43 +01:00
|
|
|
|
gen_traced_pop (gdbarch, ax, &value);
|
2009-12-24 01:40:49 +01:00
|
|
|
|
|
|
|
|
|
/* Oh, and terminate. */
|
|
|
|
|
ax_simple (ax, aop_end);
|
|
|
|
|
|
|
|
|
|
/* We have successfully built the agent expr, so cancel the cleanup
|
|
|
|
|
request. If we add more cleanups that we always want done, this
|
|
|
|
|
will have to get more complicated. */
|
|
|
|
|
discard_cleanups (old_chain);
|
|
|
|
|
return ax;
|
|
|
|
|
}
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Generating bytecode from GDB expressions: driver */
|
|
|
|
|
|
|
|
|
|
/* Given a GDB expression EXPR, return bytecode to trace its value.
|
|
|
|
|
The result will use the `trace' and `trace_quick' bytecodes to
|
|
|
|
|
record the value of all memory touched by the expression. The
|
|
|
|
|
caller can then use the ax_reqs function to discover which
|
|
|
|
|
registers it relies upon. */
|
|
|
|
|
struct agent_expr *
|
2000-07-30 03:48:28 +02:00
|
|
|
|
gen_trace_for_expr (CORE_ADDR scope, struct expression *expr)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
struct cleanup *old_chain = 0;
|
2010-04-24 01:51:05 +02:00
|
|
|
|
struct agent_expr *ax = new_agent_expr (expr->gdbarch, scope);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
union exp_element *pc;
|
|
|
|
|
struct axs_value value;
|
|
|
|
|
|
2000-05-15 08:15:27 +02:00
|
|
|
|
old_chain = make_cleanup_free_agent_expr (ax);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
pc = expr->elts;
|
|
|
|
|
trace_kludge = 1;
|
2010-04-24 01:51:05 +02:00
|
|
|
|
value.optimized_out = 0;
|
* ax-gdb.c: Include "language.h".
(gen_frame_args_address): Add GDBARCH parameter; use it
instead of current_gdbarch.
(gen_frame_locals_address): Likewise.
(gen_var_ref): Add GDBARCH parameter. Update calls to
gen_frame_args_address and gen_frame_locals_address. Use
pointer type from gdbarch.
(gen_usual_unary): Add EXP parameter. Use integer type
from exp->gdbarch.
(gen_usual_arithmetic): Likewise.
(gen_integral_promotions): Likewise.
(gen_add, gen_sub): Remove.
(gen_ptradd, gen_ptrsub, gen_ptrdiff): New functions.
(gen_logical_not): Use passed-in boolean result type
instead of builtin_type_int.
(gen_complement): Do not call gen_usual_unary or
gen_integral_promotions.
(gen_struct_ref): Call require_rvalue instead of gen_usual_unary.
(gen_repeat): Add EXP parameter. Update call to gen_expr.
Use builtin_type_int32 as internal range type.
(gen_sizeof): Add EXP and SIZE_TYPE parameters. Use SIZE_TYPE
as result type. Update call to gen_expr.
(gen_expr): Add EXP parameter. Update calls to gen_expr,
gen_repeat, gen_var_ref, gen_usual_unary, gen_usual_arithmetic,
and gen_integral_promotions. Call gen_ptradd, gen_ptrsub,
gen_ptrdiff, or gen_binop instead of gen_add or gen_sub.
Use exp->gdbarch instead of current_gdbarch.
Call language_bool_type to determine result type of UNOP_LOGICAL_NOT.
2008-09-11 16:15:39 +02:00
|
|
|
|
gen_expr (expr, &pc, ax, &value);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Make sure we record the final object, and get rid of it. */
|
2010-03-17 23:04:43 +01:00
|
|
|
|
gen_traced_pop (expr->gdbarch, ax, &value);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* Oh, and terminate. */
|
|
|
|
|
ax_simple (ax, aop_end);
|
|
|
|
|
|
|
|
|
|
/* We have successfully built the agent expr, so cancel the cleanup
|
|
|
|
|
request. If we add more cleanups that we always want done, this
|
|
|
|
|
will have to get more complicated. */
|
|
|
|
|
discard_cleanups (old_chain);
|
|
|
|
|
return ax;
|
|
|
|
|
}
|
|
|
|
|
|
2009-07-14 23:40:34 +02:00
|
|
|
|
/* Given a GDB expression EXPR, return a bytecode sequence that will
|
|
|
|
|
evaluate and return a result. The bytecodes will do a direct
|
|
|
|
|
evaluation, using the current data on the target, rather than
|
|
|
|
|
recording blocks of memory and registers for later use, as
|
|
|
|
|
gen_trace_for_expr does. The generated bytecode sequence leaves
|
|
|
|
|
the result of expression evaluation on the top of the stack. */
|
|
|
|
|
|
|
|
|
|
struct agent_expr *
|
|
|
|
|
gen_eval_for_expr (CORE_ADDR scope, struct expression *expr)
|
|
|
|
|
{
|
|
|
|
|
struct cleanup *old_chain = 0;
|
2010-04-24 01:51:05 +02:00
|
|
|
|
struct agent_expr *ax = new_agent_expr (expr->gdbarch, scope);
|
2009-07-14 23:40:34 +02:00
|
|
|
|
union exp_element *pc;
|
|
|
|
|
struct axs_value value;
|
|
|
|
|
|
|
|
|
|
old_chain = make_cleanup_free_agent_expr (ax);
|
|
|
|
|
|
|
|
|
|
pc = expr->elts;
|
|
|
|
|
trace_kludge = 0;
|
2010-04-24 01:51:05 +02:00
|
|
|
|
value.optimized_out = 0;
|
2009-07-14 23:40:34 +02:00
|
|
|
|
gen_expr (expr, &pc, ax, &value);
|
|
|
|
|
|
2010-04-24 01:51:05 +02:00
|
|
|
|
require_rvalue (ax, &value);
|
|
|
|
|
|
2009-07-14 23:40:34 +02:00
|
|
|
|
/* Oh, and terminate. */
|
|
|
|
|
ax_simple (ax, aop_end);
|
|
|
|
|
|
|
|
|
|
/* We have successfully built the agent expr, so cancel the cleanup
|
|
|
|
|
request. If we add more cleanups that we always want done, this
|
|
|
|
|
will have to get more complicated. */
|
|
|
|
|
discard_cleanups (old_chain);
|
|
|
|
|
return ax;
|
|
|
|
|
}
|
|
|
|
|
|
2011-09-27 15:09:37 +02:00
|
|
|
|
struct agent_expr *
|
|
|
|
|
gen_trace_for_return_address (CORE_ADDR scope, struct gdbarch *gdbarch)
|
|
|
|
|
{
|
|
|
|
|
struct cleanup *old_chain = 0;
|
|
|
|
|
struct agent_expr *ax = new_agent_expr (gdbarch, scope);
|
|
|
|
|
struct axs_value value;
|
|
|
|
|
|
|
|
|
|
old_chain = make_cleanup_free_agent_expr (ax);
|
|
|
|
|
|
|
|
|
|
trace_kludge = 1;
|
|
|
|
|
|
|
|
|
|
gdbarch_gen_return_address (gdbarch, ax, &value, scope);
|
|
|
|
|
|
|
|
|
|
/* Make sure we record the final object, and get rid of it. */
|
|
|
|
|
gen_traced_pop (gdbarch, ax, &value);
|
|
|
|
|
|
|
|
|
|
/* Oh, and terminate. */
|
|
|
|
|
ax_simple (ax, aop_end);
|
|
|
|
|
|
|
|
|
|
/* We have successfully built the agent expr, so cancel the cleanup
|
|
|
|
|
request. If we add more cleanups that we always want done, this
|
|
|
|
|
will have to get more complicated. */
|
|
|
|
|
discard_cleanups (old_chain);
|
|
|
|
|
return ax;
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
static void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
agent_command (char *exp, int from_tty)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
struct cleanup *old_chain = 0;
|
|
|
|
|
struct expression *expr;
|
|
|
|
|
struct agent_expr *agent;
|
1999-09-28 23:55:21 +02:00
|
|
|
|
struct frame_info *fi = get_current_frame (); /* need current scope */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
/* We don't deal with overlay debugging at the moment. We need to
|
|
|
|
|
think more carefully about this. If you copy this code into
|
|
|
|
|
another command, change the error message; the user shouldn't
|
|
|
|
|
have to know anything about agent expressions. */
|
|
|
|
|
if (overlay_debugging)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error (_("GDB can't do agent expression translation with overlays."));
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
if (exp == 0)
|
2005-01-29 Baurzhan Ismagulov <ibr@radix50.net>
* ax-gdb.c, ax-general.c, bcache.c, bfd-target.c, bsd-kvm.c,
* buildsym.c, c-lang.c, c-typeprint.c, c-valprint.c, charset.c,
* coff-pe-read.c, coffread.c, complaints.c, copying.c: I18n markup.
2005-01-29 18:53:26 +01:00
|
|
|
|
error_no_arg (_("expression to translate"));
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
2011-09-27 15:09:37 +02:00
|
|
|
|
/* Recognize the return address collection directive specially. Note
|
|
|
|
|
that it is not really an expression of any sort. */
|
|
|
|
|
if (strcmp (exp, "$_ret") == 0)
|
|
|
|
|
{
|
|
|
|
|
agent = gen_trace_for_return_address (get_frame_pc (fi),
|
|
|
|
|
get_current_arch ());
|
|
|
|
|
old_chain = make_cleanup_free_agent_expr (agent);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
expr = parse_expression (exp);
|
|
|
|
|
old_chain = make_cleanup (free_current_contents, &expr);
|
|
|
|
|
agent = gen_trace_for_expr (get_frame_pc (fi), expr);
|
|
|
|
|
make_cleanup_free_agent_expr (agent);
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-24 01:51:05 +02:00
|
|
|
|
ax_reqs (agent);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
ax_print (gdb_stdout, agent);
|
1999-06-28 18:06:02 +02:00
|
|
|
|
|
|
|
|
|
/* It would be nice to call ax_reqs here to gather some general info
|
|
|
|
|
about the expression, and then print out the result. */
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
|
|
|
|
do_cleanups (old_chain);
|
|
|
|
|
dont_repeat ();
|
|
|
|
|
}
|
2009-07-14 23:40:34 +02:00
|
|
|
|
|
|
|
|
|
/* Parse the given expression, compile it into an agent expression
|
|
|
|
|
that does direct evaluation, and display the resulting
|
|
|
|
|
expression. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
agent_eval_command (char *exp, int from_tty)
|
|
|
|
|
{
|
|
|
|
|
struct cleanup *old_chain = 0;
|
|
|
|
|
struct expression *expr;
|
|
|
|
|
struct agent_expr *agent;
|
|
|
|
|
struct frame_info *fi = get_current_frame (); /* need current scope */
|
|
|
|
|
|
|
|
|
|
/* We don't deal with overlay debugging at the moment. We need to
|
|
|
|
|
think more carefully about this. If you copy this code into
|
|
|
|
|
another command, change the error message; the user shouldn't
|
|
|
|
|
have to know anything about agent expressions. */
|
|
|
|
|
if (overlay_debugging)
|
|
|
|
|
error (_("GDB can't do agent expression translation with overlays."));
|
|
|
|
|
|
|
|
|
|
if (exp == 0)
|
|
|
|
|
error_no_arg (_("expression to translate"));
|
|
|
|
|
|
|
|
|
|
expr = parse_expression (exp);
|
|
|
|
|
old_chain = make_cleanup (free_current_contents, &expr);
|
|
|
|
|
agent = gen_eval_for_expr (get_frame_pc (fi), expr);
|
|
|
|
|
make_cleanup_free_agent_expr (agent);
|
2010-04-24 01:51:05 +02:00
|
|
|
|
ax_reqs (agent);
|
2009-07-14 23:40:34 +02:00
|
|
|
|
ax_print (gdb_stdout, agent);
|
|
|
|
|
|
|
|
|
|
/* It would be nice to call ax_reqs here to gather some general info
|
|
|
|
|
about the expression, and then print out the result. */
|
|
|
|
|
|
|
|
|
|
do_cleanups (old_chain);
|
|
|
|
|
dont_repeat ();
|
|
|
|
|
}
|
1999-04-16 03:35:26 +02:00
|
|
|
|
|
1999-07-07 22:19:36 +02:00
|
|
|
|
|
1999-04-16 03:35:26 +02:00
|
|
|
|
/* Initialization code. */
|
|
|
|
|
|
2000-05-28 03:12:42 +02:00
|
|
|
|
void _initialize_ax_gdb (void);
|
1999-04-16 03:35:26 +02:00
|
|
|
|
void
|
2000-07-30 03:48:28 +02:00
|
|
|
|
_initialize_ax_gdb (void)
|
1999-04-16 03:35:26 +02:00
|
|
|
|
{
|
|
|
|
|
add_cmd ("agent", class_maintenance, agent_command,
|
2011-01-05 23:22:53 +01:00
|
|
|
|
_("Translate an expression into "
|
|
|
|
|
"remote agent bytecode for tracing."),
|
2009-07-14 23:40:34 +02:00
|
|
|
|
&maintenancelist);
|
|
|
|
|
|
|
|
|
|
add_cmd ("agent-eval", class_maintenance, agent_eval_command,
|
2011-01-05 23:22:53 +01:00
|
|
|
|
_("Translate an expression into remote "
|
|
|
|
|
"agent bytecode for evaluation."),
|
1999-04-16 03:35:26 +02:00
|
|
|
|
&maintenancelist);
|
|
|
|
|
}
|