1999-04-16 01:35:26 +00:00
|
|
|
|
/* Parse expressions for GDB.
|
2004-07-17 14:27:55 +00:00
|
|
|
|
|
2012-01-04 08:17:56 +00:00
|
|
|
|
Copyright (C) 1986, 1989-2001, 2004-2005, 2007-2012 Free Software
|
|
|
|
|
Foundation, Inc.
|
2004-07-17 14:27:55 +00:00
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
Modified from expread.y by the Department of Computer Science at the
|
|
|
|
|
State University of New York at Buffalo, 1991.
|
|
|
|
|
|
1999-07-07 20:19:36 +00:00
|
|
|
|
This file is part of GDB.
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
1999-07-07 20:19:36 +00: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 18:08:50 +00:00
|
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
1999-07-07 20:19:36 +00:00
|
|
|
|
(at your option) any later version.
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
1999-07-07 20:19:36 +00: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 01:35:26 +00:00
|
|
|
|
|
1999-07-07 20:19:36 +00:00
|
|
|
|
You should have received a copy of the GNU General Public License
|
2007-08-23 18:08:50 +00:00
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
/* Parse an expression from text in a string,
|
2011-09-16 14:36:55 +00:00
|
|
|
|
and return the result as a struct expression pointer.
|
1999-04-16 01:35:26 +00:00
|
|
|
|
That structure contains arithmetic operations in reverse polish,
|
|
|
|
|
with constants represented by operations that are followed by special data.
|
|
|
|
|
See expression.h for the details of the format.
|
|
|
|
|
What is important here is that it can be built up sequentially
|
|
|
|
|
during the process of parsing; the lower levels of the tree always
|
|
|
|
|
come first in the result. */
|
1999-07-07 20:19:36 +00:00
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
#include "defs.h"
|
2010-01-09 04:34:35 +00:00
|
|
|
|
#include <ctype.h>
|
2009-07-02 17:02:35 +00:00
|
|
|
|
#include "arch-utils.h"
|
1999-04-16 01:35:26 +00:00
|
|
|
|
#include "gdb_string.h"
|
|
|
|
|
#include "symtab.h"
|
|
|
|
|
#include "gdbtypes.h"
|
|
|
|
|
#include "frame.h"
|
|
|
|
|
#include "expression.h"
|
|
|
|
|
#include "value.h"
|
|
|
|
|
#include "command.h"
|
|
|
|
|
#include "language.h"
|
2005-09-20 06:25:34 +00:00
|
|
|
|
#include "f-lang.h"
|
1999-04-16 01:35:26 +00:00
|
|
|
|
#include "parser-defs.h"
|
|
|
|
|
#include "gdbcmd.h"
|
1999-07-07 20:19:36 +00:00
|
|
|
|
#include "symfile.h" /* for overlay functions */
|
2007-05-31 Markus Deuling <deuling@de.ibm.com>
* gdbarch.sh (NUM_REGS): Replace by gdbarch_num_regs.
* i386-tdep.c (i386_dbx_reg_to_regnum)
(i386_svr4_reg_to_regnum): Likewise.
* inf-ptrace.c (inf_ptrace_fetch_registers)
(inf_ptrace_store_registers): Likewise.
* corelow.c (get_core_registers): Likewise.
* i386-linux-nat.c (supply_gregset, fill_gregset)
(i386_linux_fetch_inferior_registers)
(i386_linux_store_inferior_registers): Likewise.
* remote.c (init_remote_state,packet_reg_from_regnum)
(packet_reg_from_pnum,process_g_packet,remote_fetch_registers)
(remote_prepare_to_store,store_registers_using_G)
(remote_store_registers,remote_arch_state): Likewise.
* tracepoint.c (encode_actions): Likewise.
* mi/mi-main.c (mi_cmd_data_list_register_names)
(mi_cmd_data_list_changed_registers,mi_cmd_data_list_register_values)
(mi_cmd_data_write_register_values): Likewise.
* tui/tui-regs.c (tui_show_register_group)
(tui_show_register_group): Likewise.
* xtensa-tdep.h (FP_ALIAS): Likewise.
* xtensa-tdep.c (xtensa_register_name,xtensa_register_type)
(xtensa_reg_to_regnum,xtensa_pseudo_register_read)
(xtensa_pseudo_register_write,xtensa_register_reggroup_p): Likewise.
* win32-nat.c (do_win32_fetch_inferior_registers)
(do_win32_store_inferior_registers,fetch_elf_core_registers
* user-regs.h: Likewise (comment).
* user-regs.c (user_reg, user_reg_map_name_to_regnum): Likewise.
* trad-frame.c (trad_frame_alloc_saved_regs): Likewise.
* target-descriptions.h: Likewise (comment).
* target-descriptions.c (tdesc_use_registers): Likewise (comment).
* target.c (debug_print_register): Likewise.
* stack.c (frame_info): Likewise.
* stabsread.c (define_symbol): Likewise.
* sh64-tdep.c (sh64_do_pseudo_register,sh64_print_register)
(sh64_media_print_registers_info)
(sh64_compact_print_registers_info): Likewise.
* rs6000-tdep.c (rs6000_register_sim_regno): Likewise.
* rs6000-nat.c (fetch_register,store_register): Likewise.
* remote-sim.c (one2one_register_sim_regno,gdbsim_fetch_register)
(gdbsim_fetch_register,gdbsim_store_register): Likewise.
* remote-mips.c (mips_fetch_registers,mips_store_registers): Likewise.
* remote-m32r-sdi.c (m32r_fetch_registers)
(m32r_store_registers): Likewise.
* reggroups.c (default_register_reggroup_p): Likewise.
* regcache.c (init_regcache_descr,register_size,regcache,regcache_save)
(regcache_restore,regcache_dump): Likewise.
* monitor.c (monitor_fetch_registers,monitor_store_registers): Likewise.
* mips-tdep.c (mips_xfer_register,mips_register_name)
(mips_register_reggroup_p,mips_pseudo_register_read)
(mips_pseudo_register_write,mips_convert_register_p,mips_register_type)
(mips_unwind_pc,mips_unwind_sp,mips_unwind_dummy_id,set_reg_offset)
(mips16_scan_prologue,mips_insn16_frame_cache,reset_saved_regs)
(mips32_scan_prologue,mips_insn32_frame_cache,read_next_frame_reg)
(mips_n32n64_return_value,mips_o32_return_value,mips_o64_return_value)
(print_gp_register_row,mips_print_registers_info)
(mips_stab_reg_to_regnum,mips_dwarf_dwarf2_ecoff_reg_to_regnum)
(mips_register_sim_regno): Likewise.
* mips-linux-tdep.c (mips_linux_o32_sigframe_init)
(mips_linux_n32n64_sigframe_init): Likewise.
* mips-linux-nat.c (mips_linux_register_addr)
(mips64_linux_register_addr): Likewise.
* findvar.c (value_of_register): Likewise.
* infcmd.c (default_print_registers_info,registers_info)
(print_vector_info,print_float_info): Likewise.
* mips64obsd-tdep.c (mips64obsd_sigframe_init): Likewise.
* inf-child.c (inf_child_fetch_inferior_registers): Likewise.
* m68k-tdep.c (m68k_dwarf_reg_to_regnum): Likewise.
* m68hc11-tdep.c (m68hc11_frame_unwind_cache(: Likewise.
* m32r-tdep.c (m32r_frame_unwind_cache): Likewise.
* ia64-linux-nat.c (ia64_register_addr,ia64_cannot_fetch_register)
(ia64_cannot_store_register,ia64_linux_fetch_registers)
(ia64_linux_store_registers): Likewise.
* hpux-thread.c (hpux_thread_fetch_registers)
(hpux_thread_store_registers): Likewise.
* h8300-tdep.c (E_PSEUDO_CCR_REGNUM,E_PSEUDO_EXR_REGNUM)
(h8300_init_frame_cache,h8300_frame_cache,h8300_frame_prev_register)
(h8300_register_type): Likewise.
* dwarf2-frame.c (dwarf2_frame_cache)
(dwarf2_frame_state_alloc_regs): Likewise.
* cris-tdep.c (cris_register_size,cris_cannot_fetch_register)
(cris_cannot_store_register,crisv32_cannot_fetch_register)
(crisv32_cannot_store_register,cris_register_name): Likewise.
* avr-tdep.c (avr_frame_unwind_cache): Likewise.
* arch-utils.c (legacy_register_sim_regno)
(legacy_virtual_frame_pointer): Likewise.
* arm-tdep.c (arm_make_prologue_cache,arm_register_sim_regno):Likewise.
* arm-tdep.h: Likewise (comment).
* frv-tdep.c (frv_register_sim_regno): Likewise.
* m68klinux-nat.c (old_fetch_inferior_registers)
(old_store_inferior_registers): Likewise.
* m32c-tdep.c (m32c_virtual_frame_pointer): Likewise.
* irix5-nat.c (fetch_core_registers): Likewise.
* hppa-tdep.c (hppa_frame_cache): Likewise.
* hppa-linux-nat.c (hppa_linux_register_addr)
(hppa_linux_fetch_inferior_registers)
(hppa_linux_store_inferior_registers): Likewise.
* hppa-hpux-nat.c (hppa_hpux_fetch_inferior_registers)
(hppa_hpux_store_inferior_registers): Likewise.
* amd64-nat.c (amd64_native_gregset_reg_offset)
(amd64_supply_native_gregset,amd64_collect_native_gregset): Likewise.
* dbug-rom.c (dbug_regname): Likewise.
* m68hc11-tdep.c (m68hc11_frame_unwind_cache)
(HARD_PAGE_REGNUM (comment)): Likewise.
* gdbarch.sh (NUM_PSEUDO_REGS): Replace by gdbarch_num_pseudo_regs.
* i386-tdep.c (i386_dbx_reg_to_regnum)
(i386_svr4_reg_to_regnum): Likewise.
* mi/mi-main.c (mi_cmd_data_list_register_names)
(mi_cmd_data_list_changed_registers,mi_cmd_data_list_register_values)
(mi_cmd_data_write_register_values): Likewise.
* gdbarch.c, gdbarch.h: Regenerate.
* tui/tui-regs.c (tui_show_register_group): Likewise.
* xtensa-tdep.h (FP_ALIAS): Likewise.
* user-regs.h: Likewise (comment).
* user-regs.c (user_reg, user_reg_map_name_to_regnum): Likewise.
* trad-frame.c (trad_frame_alloc_saved_regs): Likewise.
* target-descriptions.h: Likewise (comment).
* target.c (debug_print_register): Likewise.
* stack.c (frame_info): Likewise.
* stabsread.c (define_symbol): Likewise.
* sh64-tdep.c (sh64_print_register,sh64_media_print_registers_info)
(sh64_compact_print_registers_info): Likewise.
* rs6000-tdep.c (rs6000_register_sim_regno): Likewise.
* regcache.c (init_regcache_descr,register_size,regcache,regcache_save
(regcache_restore,regcache_dump): Likewise.
* mips-tdep.c (print_gp_register_row,mips_print_registers_info)
(mips_dwarf_dwarf2_ecoff_reg_to_regnum)
(mips_stab_reg_to_regnum): Likewise.
* findvar.c (value_of_register): Likewise.
* infcmd.c (default_print_registers_info,registers_info)
(print_vector_info,print_float_info): Likewise.
* m68k-tdep.c (m68k_dwarf_reg_to_regnum): Likewise.
* h8300-tdep.c (h8300_register_type): Likewise.
* dwarf2-frame.c (dwarf2_frame_cache): Likewise.
* frame.h (SIZEOF_FRAME_SAVED_REGS): Likewise.
* xtensa-tdep.c (xtensa_register_type,xtensa_reg_to_regnum)
(xtensa_pseudo_register_read,xtensa_pseudo_register_write): Likewise.
* parse.c: Remove comment.
* gdbarch.c, gdbarch.h: Regenerate
2007-05-31 17:32:22 +00:00
|
|
|
|
#include "inferior.h"
|
* defs.h (HOST_FLOAT_FORMAT, HOST_DOUBLE_FORMAT)
(HOST_FLOAT_FORMAT, HOST_DOUBLE_FORMAT)
(HOST_LONG_DOUBLE_FORMAT, DOUBLEST)
(floatformat_to_doublest, floatformat_from_doublest)
(floatformat_is_negative, floatformat_is_nan)
(floatformat_mantissa, store_floating)
(extract_floating): Move declaration from here.
* doublest.h: To here. New file.
* utils.c (get_field, floatformat_to_doublest, put_field)
(ldfrexp, floatformat_from_doublest, floatformat_is_negative)
(floatformat_is_nan, floatformat_mantissa)
(FLOATFORMAT_CHAR_BIT): Move from here.
* doublest.c: To here. New file.
* findvar.c (store_floating, extract_floating): Move from here.
* doublest.c: To here.
* Makefile.in (SFILES): Add doublest.c.
(COMMON_OBS): Add doublest.o.
(doublest.o): Specify dependencies.
(doublest_h): Define.
* config/m88k/tm-m88k.h: Include "doublest.h".
* config/i960/tm-i960.h: Ditto.
* config/i386/tm-symmetry.h: Ditto.
* rs6000-tdep.c, valarith.c: Ditto.
* valprint.c, stabsread.c, sh-tdep.c: Ditto.
* ia64-tdep.c, i387-tdep.c, i386-tdep.c: Ditto.
* values.c, arm-tdep.c, arm-linux-tdep.c: Ditto.
* alpha-tdep.c, ax.h, expression.h: Ditto.
* sh-tdep.c, parse.c, top.c, value.h: Ditto.
* Makefile.in (arm-tdep.o): Add $(doublest_h).
(i386-tdep.o, i387-tdep.o, ia64-tdep.o): Ditto.
(rs6000-tdep.o, stabsread.o, valarith.o): Ditto.
(values.o, valprint.o, arm-linux-tdep.o): Ditto.
(alpha-tdep.o, ax_h, parse.o, top.o, value_h): Ditto.
(parser_defs_h): Ditto.
(expression_h): Add $(doublest_h) and $(symtab_h).
2001-08-01 18:39:27 +00:00
|
|
|
|
#include "doublest.h"
|
2002-04-09 03:06:14 +00:00
|
|
|
|
#include "gdb_assert.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 00:01:07 +00:00
|
|
|
|
#include "block.h"
|
2006-01-24 15:20:10 +00:00
|
|
|
|
#include "source.h"
|
2006-10-10 03:17:53 +00:00
|
|
|
|
#include "objfiles.h"
|
2008-06-06 20:58:08 +00:00
|
|
|
|
#include "exceptions.h"
|
2008-08-21 20:13:08 +00:00
|
|
|
|
#include "user-regs.h"
|
2000-07-13 17:54:35 +00:00
|
|
|
|
|
* parser-defs.h (struct exp_descriptor): New definition, containing
language-specific info for printing, prefixifying, dumping, and
evaluating expressions.
(exp_descriptor_standard): Declare new variable.
(print_subexp): Make global and declare here (from expprint.c).
(dump_subexp): Ditto.
(dump_subexp_body_standard): Declare.
(operator_length_standard): Declare.
(op_name_standard): Declare.
(print_subexp): Declare.
(print_subexp_standard): Declare.
* language.h (struct language_defn): Add la_exp_desc field to hold
pointer to table for language-specific operators.
Remove evaluate_exp field, which is now in struct exp_descriptor.
* parse.c (operator_length): Move most code to new
operator_length_standard function. Use language-specific information.
(operator_length_standard): New function taking most code from
operator_length.
(exp_descriptor_standard): New constant.
* expression.h (enum exp_opcode): Add definitions of OP_EXTENDED0
and OP_EXTENDED_LAST.
* expprint.c (print_subexp): Use language-specific print_subexp.
Make global; remove static declaration.
Move most code to print_subexp_standard.
(print_subexp_standard): New function, containing code formerly in
print_subexp.
(op_name): Add expression to argument signature.
Use langauge-specific op_name.
Move most code to op_name_standard.
(op_name_standard): New function, containing code formerly in op_name.
(dump_subexp): Use new version of op_name function.
Use language-specific dump_subexp_body, and move most existing code to
dump_subexp_body_standard.
(dump_raw_expression): Use new op_name interface.
(dump_subexp_body): Move most code to dump_subexp_body_standard.
(dump_subexp_body_standard): New function, containing code formerly
in dump_subexp_body.
* language.c (unknown_language): Add default la_exp_desc field and
remove evaluate_exp field.
(auto_language): Ditto.
(local_language): Ditto.
* f-lang.c (f_language_defn): Ditto.
* c-lang.c (c_language_defn): Ditto.
(cplus_language_defn): Ditto.
(asm_language_defn): Ditto.
(minimal_language_defn): Ditto.
* p-lang.c (pascal_language_defn): Ditto.
* m2-lang.c (m2_language_defn): Ditto.
* objc-lang.c (objc_language_defn): Ditto.
* jv-lang.c (exp_descriptor_java): New variable, containing
Java-specific expression evaluator.
(java_language_defn): Add la_exp_desc field and remove evaluate_exp
field.
* scm-lang.c (exp_descriptor_scm): New variable, containing
Scheme-specific expression evaluator.
(scm_language_defn): Add la_exp_desc field and remove evaluate_exp
field.
* objc-lang.c (print_object_command): Take evaluate_exp from the
la_exp_desc field.
* Makefile.in (eval.o): Add dependency on parser-defs.h.
* eval.c: Include parser-defs.h for the full declaration of
la_exp_desc's type.
(evaluate_subexp): Get evaluate_exp out of la_exp_desc field.
2003-09-25 08:40:45 +00:00
|
|
|
|
/* Standard set of definitions for printing, dumping, prefixifying,
|
|
|
|
|
* and evaluating expressions. */
|
|
|
|
|
|
|
|
|
|
const struct exp_descriptor exp_descriptor_standard =
|
|
|
|
|
{
|
|
|
|
|
print_subexp_standard,
|
|
|
|
|
operator_length_standard,
|
2010-04-22 23:15:43 +00:00
|
|
|
|
operator_check_standard,
|
* parser-defs.h (struct exp_descriptor): New definition, containing
language-specific info for printing, prefixifying, dumping, and
evaluating expressions.
(exp_descriptor_standard): Declare new variable.
(print_subexp): Make global and declare here (from expprint.c).
(dump_subexp): Ditto.
(dump_subexp_body_standard): Declare.
(operator_length_standard): Declare.
(op_name_standard): Declare.
(print_subexp): Declare.
(print_subexp_standard): Declare.
* language.h (struct language_defn): Add la_exp_desc field to hold
pointer to table for language-specific operators.
Remove evaluate_exp field, which is now in struct exp_descriptor.
* parse.c (operator_length): Move most code to new
operator_length_standard function. Use language-specific information.
(operator_length_standard): New function taking most code from
operator_length.
(exp_descriptor_standard): New constant.
* expression.h (enum exp_opcode): Add definitions of OP_EXTENDED0
and OP_EXTENDED_LAST.
* expprint.c (print_subexp): Use language-specific print_subexp.
Make global; remove static declaration.
Move most code to print_subexp_standard.
(print_subexp_standard): New function, containing code formerly in
print_subexp.
(op_name): Add expression to argument signature.
Use langauge-specific op_name.
Move most code to op_name_standard.
(op_name_standard): New function, containing code formerly in op_name.
(dump_subexp): Use new version of op_name function.
Use language-specific dump_subexp_body, and move most existing code to
dump_subexp_body_standard.
(dump_raw_expression): Use new op_name interface.
(dump_subexp_body): Move most code to dump_subexp_body_standard.
(dump_subexp_body_standard): New function, containing code formerly
in dump_subexp_body.
* language.c (unknown_language): Add default la_exp_desc field and
remove evaluate_exp field.
(auto_language): Ditto.
(local_language): Ditto.
* f-lang.c (f_language_defn): Ditto.
* c-lang.c (c_language_defn): Ditto.
(cplus_language_defn): Ditto.
(asm_language_defn): Ditto.
(minimal_language_defn): Ditto.
* p-lang.c (pascal_language_defn): Ditto.
* m2-lang.c (m2_language_defn): Ditto.
* objc-lang.c (objc_language_defn): Ditto.
* jv-lang.c (exp_descriptor_java): New variable, containing
Java-specific expression evaluator.
(java_language_defn): Add la_exp_desc field and remove evaluate_exp
field.
* scm-lang.c (exp_descriptor_scm): New variable, containing
Scheme-specific expression evaluator.
(scm_language_defn): Add la_exp_desc field and remove evaluate_exp
field.
* objc-lang.c (print_object_command): Take evaluate_exp from the
la_exp_desc field.
* Makefile.in (eval.o): Add dependency on parser-defs.h.
* eval.c: Include parser-defs.h for the full declaration of
la_exp_desc's type.
(evaluate_subexp): Get evaluate_exp out of la_exp_desc field.
2003-09-25 08:40:45 +00:00
|
|
|
|
op_name_standard,
|
|
|
|
|
dump_subexp_body_standard,
|
|
|
|
|
evaluate_subexp_standard
|
|
|
|
|
};
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
/* Global variables declared in parser-defs.h (and commented there). */
|
|
|
|
|
struct expression *expout;
|
|
|
|
|
int expout_size;
|
|
|
|
|
int expout_ptr;
|
|
|
|
|
struct block *expression_context_block;
|
Expand preprocessor macros in C expressions.
* c-lang.h: #include "macroexp.h", for macro_lookup_ftype.
(scan_macro_expansion, scanning_macro_expansion,
finished_macro_expansion): New function declarations.
(expression_macro_lookup_func, expression_macro_lookup_baton): New
variable declarations.
* parser-defs.h (expression_context_pc): New declaration.
* parse.c (expression_context_pc): New variable.
(parse_exp_1): Set expression_context_pc, as well as
expression_context_block.
* c-exp.y (yylex): If we're not already reading the result of a
macro expansion, try to macro-expand the next token. When we're
done scanning a macro expansion, switch back to the mainline text.
Commas and `if's in a macro's expansion don't terminate the input.
* c-lang.c: #include "macroscope.h" and "gdb_assert.h".
(macro_original_text, macro_expanded_text,
expression_macro_lookup_func, expression_macro_lookup_baton): New
variables.
(scan_macro_expansion, scanning_macro_expansion,
finished_macro_expansion, scan_macro_cleanup, null_macro_lookup,
c_preprocess_and_parse): New functions.
(c_language_defn, cplus_language_defn, asm_language_defn): Call
c_preprocess_and_parse, instead of c_parse.
* Makefile.in (c_lang_h): Note that this #includes macroexp.h.
(c-lang.o): Note dependency on macroscope.h and gdb_assert.h.
2002-05-17 17:57:48 +00:00
|
|
|
|
CORE_ADDR expression_context_pc;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
struct block *innermost_block;
|
|
|
|
|
int arglist_len;
|
* parser-defs.h (type_stack, type_stack_size, type_stack_depth):
Remove.
(struct type_stack): New.
* parse.c (type_stack, type_stack_size, type_stack_depth):
Remove.
(type_stack): New global.
(parse_exp_in_context, check_type_stack_depth)
(insert_into_type_stack, insert_type, push_type, push_type_int)
(insert_type_address_space, pop_type, pop_type_int)
(_initialize_parse): Update.
2012-07-06 14:42:09 +00:00
|
|
|
|
static struct type_stack type_stack;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
char *lexptr;
|
2002-04-24 22:26:32 +00:00
|
|
|
|
char *prev_lexptr;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
int paren_depth;
|
|
|
|
|
int comma_terminates;
|
2005-04-29 00:04:06 +00:00
|
|
|
|
|
2008-06-06 20:58:08 +00:00
|
|
|
|
/* True if parsing an expression to find a field reference. This is
|
|
|
|
|
only used by completion. */
|
|
|
|
|
int in_parse_field;
|
|
|
|
|
|
|
|
|
|
/* The index of the last struct expression directly before a '.' or
|
|
|
|
|
'->'. This is set when parsing and is only used when completing a
|
|
|
|
|
field name. It is -1 if no dereference operation was found. */
|
|
|
|
|
static int expout_last_struct = -1;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
2012-08-02 09:36:40 +00:00
|
|
|
|
static unsigned int expressiondebug = 0;
|
2005-02-24 Andrew Cagney <cagney@gnu.org>
Add show_VARIABLE functions, update add_setshow call.
* varobj.c (_initialize_varobj, show_varobjdebug): Add and update.
* valprint.c (_initialize_valprint, show_print_max)
(show_stop_print_at_null, show_repeat_count_threshold)
(show_prettyprint_structs, show_unionprint)
(show_prettyprint_arrays, show_addressprint, show_input_radix)
(show_output_radix): Ditto.
* valops.c (_initialize_valops, show_overload_resolution): Ditto.
* utils.c (initialize_utils, show_chars_per_line)
(show_lines_per_page, show_demangle, show_pagination_enabled)
(show_sevenbit_strings, show_asm_demangle): Ditto
* tui/tui-win.c (_initialize_tui_win, show_tui_border_kind)
(show_tui_border_mode, show_tui_active_border_mode): Ditto.
* top.c (init_main, show_new_async_prompt)
(show_async_command_editing_p, show_write_history_p)
(show_history_size, show_history_filename, show_caution)
(show_annotation_level, init_main): Ditto.
* target.c (initialize_targets, show_targetdebug)
(show_trust_readonly): Ditto.
* symfile.c (_initialize_symfile, show_symbol_reloading)
(show_ext_args, show_download_write_size)
(show_debug_file_directory): Ditto.
* source.c (_initialize_source, show_lines_to_list): Ditto.
* solib.c (_initialize_solib, show_auto_solib_add)
(show_solib_search_path): Ditto.
* p-valprint.c (_initialize_pascal_valprint)
(show_pascal_static_field_print): Ditto.
* printcmd.c (_initialize_printcmd, show_max_symbolic_offset)
(show_print_symbol_filename): Add and update.
* parse.c (_initialize_parse, show_expressiondebug): Dito.
* observer.c (_initialize_observer, show_observer_debug): Dito.
* maint.c (_initialize_maint_cmds, show_watchdog)
(show_maintenance_profile_p): Dito.
* linux-nat.c (_initialize_linux_nat, show_debug_linux_nat): Dito.
* infrun.c (_initialize_infrun, show_debug_infrun)
(show_stop_on_solib_events, show_follow_fork_mode_string)
(show_scheduler_mode, show_step_stop_if_no_debug): Ditto.
* infcall.c (_initialize_infcall, show_coerce_float_to_double_p)
(show_unwind_on_signal_p): Ditto.
* gdbtypes.c (build_gdbtypes, show_opaque_type_resolution)
(_initialize_gdbtypes, show_overload_debug): Ditto.
* gdb-events.c, gdb-events.sh (_initialize_gdb_events)
(show_gdb_events_debug): Ditto.
* gdbarch.c, gdbarch.sh (show_gdbarch_debug)
(_initialize_gdbarch): Ditto.
* frame.c (_initialize_frame, show_backtrace_past_main)
(show_backtrace_past_entry, show_backtrace_limit)
(show_frame_debug): Ditto.
* exec.c (_initialize_exec, show_write_files): Ditto.
* dwarf2read.c (_initialize_dwarf2_read)
(show_dwarf2_max_cache_age): Ditto.
* demangle.c (_initialize_demangler)
(show_demangling_style_names): Ditto.
* dcache.c (_initialize_dcache, show_dcache_enabled_p): Ditto.
* cp-valprint.c (show_static_field_print)
(_initialize_cp_valprint, show_vtblprint, show_objectprint): Ditto.
* corefile.c (_initialize_core, show_gnutarget_string): Ditto.
* cli/cli-logging.c (_initialize_cli_logging)
(show_logging_overwrite, show_logging_redirect)
(show_logging_filename): Ditto.
* cli/cli-cmds.c (show_info_verbose, show_history_expansion_p)
(init_cli_cmds, show_baud_rate, show_remote_debug)
(show_remote_timeout, show_max_user_call_depth): Ditto.
* charset.c (show_host_charset_name, show_target_charset_name)
(initialize_charset): Ditto.
* breakpoint.c (show_can_use_hw_watchpoints)
(show_pending_break_support, _initialize_breakpoint): Ditto.
2005-02-24 13:51:36 +00:00
|
|
|
|
static void
|
|
|
|
|
show_expressiondebug (struct ui_file *file, int from_tty,
|
|
|
|
|
struct cmd_list_element *c, const char *value)
|
|
|
|
|
{
|
|
|
|
|
fprintf_filtered (file, _("Expression debugging is %s.\n"), value);
|
|
|
|
|
}
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
2010-02-10 18:57:21 +00:00
|
|
|
|
|
|
|
|
|
/* Non-zero if an expression parser should set yydebug. */
|
|
|
|
|
int parser_debug;
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
show_parserdebug (struct ui_file *file, int from_tty,
|
|
|
|
|
struct cmd_list_element *c, const char *value)
|
|
|
|
|
{
|
|
|
|
|
fprintf_filtered (file, _("Parser debugging is %s.\n"), value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2000-05-22 09:02:23 +00:00
|
|
|
|
static void free_funcalls (void *ignore);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
2008-06-06 20:58:08 +00:00
|
|
|
|
static int prefixify_subexp (struct expression *, struct expression *, int,
|
|
|
|
|
int);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
2012-06-27 18:08:41 +00:00
|
|
|
|
static struct expression *parse_exp_in_context (char **, CORE_ADDR,
|
|
|
|
|
struct block *, int,
|
2008-06-06 20:58:08 +00:00
|
|
|
|
int, int *);
|
2004-04-10 22:10:01 +00:00
|
|
|
|
|
2000-05-28 01:12:42 +00:00
|
|
|
|
void _initialize_parse (void);
|
1999-05-25 18:09:09 +00:00
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
/* Data structure for saving values of arglist_len for function calls whose
|
|
|
|
|
arguments contain other function calls. */
|
|
|
|
|
|
|
|
|
|
struct funcall
|
|
|
|
|
{
|
|
|
|
|
struct funcall *next;
|
|
|
|
|
int arglist_len;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct funcall *funcall_chain;
|
|
|
|
|
|
|
|
|
|
/* Begin counting arguments for a function call,
|
|
|
|
|
saving the data about any containing call. */
|
|
|
|
|
|
|
|
|
|
void
|
2000-07-30 01:48:28 +00:00
|
|
|
|
start_arglist (void)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2003-09-09 08:05:43 +00:00
|
|
|
|
struct funcall *new;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
new = (struct funcall *) xmalloc (sizeof (struct funcall));
|
|
|
|
|
new->next = funcall_chain;
|
|
|
|
|
new->arglist_len = arglist_len;
|
|
|
|
|
arglist_len = 0;
|
|
|
|
|
funcall_chain = new;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return the number of arguments in a function call just terminated,
|
|
|
|
|
and restore the data for the containing function call. */
|
|
|
|
|
|
|
|
|
|
int
|
2000-07-30 01:48:28 +00:00
|
|
|
|
end_arglist (void)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2003-09-09 08:05:43 +00:00
|
|
|
|
int val = arglist_len;
|
|
|
|
|
struct funcall *call = funcall_chain;
|
2010-05-16 01:27:02 +00:00
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
funcall_chain = call->next;
|
|
|
|
|
arglist_len = call->arglist_len;
|
2000-12-15 01:01:51 +00:00
|
|
|
|
xfree (call);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Free everything in the funcall chain.
|
|
|
|
|
Used when there is an error inside parsing. */
|
|
|
|
|
|
|
|
|
|
static void
|
2000-05-22 09:02:23 +00:00
|
|
|
|
free_funcalls (void *ignore)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2003-09-09 08:05:43 +00:00
|
|
|
|
struct funcall *call, *next;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
for (call = funcall_chain; call; call = next)
|
|
|
|
|
{
|
|
|
|
|
next = call->next;
|
2000-12-15 01:01:51 +00:00
|
|
|
|
xfree (call);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-09-16 14:36:55 +00:00
|
|
|
|
/* This page contains the functions for adding data to the struct expression
|
1999-04-16 01:35:26 +00:00
|
|
|
|
being constructed. */
|
|
|
|
|
|
2012-04-27 20:47:57 +00:00
|
|
|
|
/* See definition in parser-defs.h. */
|
2012-01-18 12:47:35 +00:00
|
|
|
|
|
2012-04-27 20:47:57 +00:00
|
|
|
|
void
|
2012-01-18 12:47:35 +00:00
|
|
|
|
initialize_expout (int initial_size, const struct language_defn *lang,
|
|
|
|
|
struct gdbarch *gdbarch)
|
|
|
|
|
{
|
|
|
|
|
expout_size = initial_size;
|
|
|
|
|
expout_ptr = 0;
|
|
|
|
|
expout = xmalloc (sizeof (struct expression)
|
|
|
|
|
+ EXP_ELEM_TO_BYTES (expout_size));
|
|
|
|
|
expout->language_defn = lang;
|
|
|
|
|
expout->gdbarch = gdbarch;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-27 20:47:57 +00:00
|
|
|
|
/* See definition in parser-defs.h. */
|
2012-01-18 12:47:35 +00:00
|
|
|
|
|
2012-04-27 20:47:57 +00:00
|
|
|
|
void
|
2012-01-18 12:47:35 +00:00
|
|
|
|
reallocate_expout (void)
|
|
|
|
|
{
|
|
|
|
|
/* Record the actual number of expression elements, and then
|
|
|
|
|
reallocate the expression memory so that we free up any
|
|
|
|
|
excess elements. */
|
|
|
|
|
|
|
|
|
|
expout->nelts = expout_ptr;
|
|
|
|
|
expout = xrealloc ((char *) expout,
|
|
|
|
|
sizeof (struct expression)
|
|
|
|
|
+ EXP_ELEM_TO_BYTES (expout_ptr));
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
/* Add one element to the end of the expression. */
|
|
|
|
|
|
|
|
|
|
/* To avoid a bug in the Sun 4 compiler, we pass things that can fit into
|
2011-01-10 20:38:51 +00:00
|
|
|
|
a register through here. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
2011-09-16 14:36:55 +00:00
|
|
|
|
static void
|
|
|
|
|
write_exp_elt (const union exp_element *expelt)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
|
|
|
|
if (expout_ptr >= expout_size)
|
|
|
|
|
{
|
|
|
|
|
expout_size *= 2;
|
|
|
|
|
expout = (struct expression *)
|
|
|
|
|
xrealloc ((char *) expout, sizeof (struct expression)
|
|
|
|
|
+ EXP_ELEM_TO_BYTES (expout_size));
|
|
|
|
|
}
|
2011-09-16 14:36:55 +00:00
|
|
|
|
expout->elts[expout_ptr++] = *expelt;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2000-07-30 01:48:28 +00:00
|
|
|
|
write_exp_elt_opcode (enum exp_opcode expelt)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
|
|
|
|
union exp_element tmp;
|
|
|
|
|
|
2010-05-16 01:27:02 +00:00
|
|
|
|
memset (&tmp, 0, sizeof (union exp_element));
|
1999-04-16 01:35:26 +00:00
|
|
|
|
tmp.opcode = expelt;
|
2011-09-16 14:36:55 +00:00
|
|
|
|
write_exp_elt (&tmp);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2000-07-30 01:48:28 +00:00
|
|
|
|
write_exp_elt_sym (struct symbol *expelt)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
|
|
|
|
union exp_element tmp;
|
|
|
|
|
|
2010-05-16 01:27:02 +00:00
|
|
|
|
memset (&tmp, 0, sizeof (union exp_element));
|
1999-04-16 01:35:26 +00:00
|
|
|
|
tmp.symbol = expelt;
|
2011-09-16 14:36:55 +00:00
|
|
|
|
write_exp_elt (&tmp);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2000-07-30 01:48:28 +00:00
|
|
|
|
write_exp_elt_block (struct block *b)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
|
|
|
|
union exp_element tmp;
|
2010-05-16 01:27:02 +00:00
|
|
|
|
|
2006-07-06 14:00:48 +00:00
|
|
|
|
memset (&tmp, 0, sizeof (union exp_element));
|
1999-04-16 01:35:26 +00:00
|
|
|
|
tmp.block = b;
|
2011-09-16 14:36:55 +00:00
|
|
|
|
write_exp_elt (&tmp);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
2006-10-10 03:17:53 +00:00
|
|
|
|
void
|
|
|
|
|
write_exp_elt_objfile (struct objfile *objfile)
|
|
|
|
|
{
|
|
|
|
|
union exp_element tmp;
|
2010-05-16 01:27:02 +00:00
|
|
|
|
|
2006-10-10 03:17:53 +00:00
|
|
|
|
memset (&tmp, 0, sizeof (union exp_element));
|
|
|
|
|
tmp.objfile = objfile;
|
2011-09-16 14:36:55 +00:00
|
|
|
|
write_exp_elt (&tmp);
|
2006-10-10 03:17:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
void
|
2000-07-30 01:48:28 +00:00
|
|
|
|
write_exp_elt_longcst (LONGEST expelt)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
|
|
|
|
union exp_element tmp;
|
|
|
|
|
|
2010-05-16 01:27:02 +00:00
|
|
|
|
memset (&tmp, 0, sizeof (union exp_element));
|
1999-04-16 01:35:26 +00:00
|
|
|
|
tmp.longconst = expelt;
|
2011-09-16 14:36:55 +00:00
|
|
|
|
write_exp_elt (&tmp);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2000-07-30 01:48:28 +00:00
|
|
|
|
write_exp_elt_dblcst (DOUBLEST expelt)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
|
|
|
|
union exp_element tmp;
|
|
|
|
|
|
2010-05-16 01:27:02 +00:00
|
|
|
|
memset (&tmp, 0, sizeof (union exp_element));
|
1999-04-16 01:35:26 +00:00
|
|
|
|
tmp.doubleconst = expelt;
|
2011-09-16 14:36:55 +00:00
|
|
|
|
write_exp_elt (&tmp);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
2007-10-25 18:01:58 +00:00
|
|
|
|
void
|
|
|
|
|
write_exp_elt_decfloatcst (gdb_byte expelt[16])
|
|
|
|
|
{
|
|
|
|
|
union exp_element tmp;
|
|
|
|
|
int index;
|
|
|
|
|
|
|
|
|
|
for (index = 0; index < 16; index++)
|
|
|
|
|
tmp.decfloatconst[index] = expelt[index];
|
|
|
|
|
|
2011-09-16 14:36:55 +00:00
|
|
|
|
write_exp_elt (&tmp);
|
2007-10-25 18:01:58 +00:00
|
|
|
|
}
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
void
|
2000-07-30 01:48:28 +00:00
|
|
|
|
write_exp_elt_type (struct type *expelt)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
|
|
|
|
union exp_element tmp;
|
|
|
|
|
|
2010-05-16 01:27:02 +00:00
|
|
|
|
memset (&tmp, 0, sizeof (union exp_element));
|
1999-04-16 01:35:26 +00:00
|
|
|
|
tmp.type = expelt;
|
2011-09-16 14:36:55 +00:00
|
|
|
|
write_exp_elt (&tmp);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2000-07-30 01:48:28 +00:00
|
|
|
|
write_exp_elt_intern (struct internalvar *expelt)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
|
|
|
|
union exp_element tmp;
|
|
|
|
|
|
2010-05-16 01:27:02 +00:00
|
|
|
|
memset (&tmp, 0, sizeof (union exp_element));
|
1999-04-16 01:35:26 +00:00
|
|
|
|
tmp.internalvar = expelt;
|
2011-09-16 14:36:55 +00:00
|
|
|
|
write_exp_elt (&tmp);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Add a string constant to the end of the expression.
|
|
|
|
|
|
|
|
|
|
String constants are stored by first writing an expression element
|
|
|
|
|
that contains the length of the string, then stuffing the string
|
|
|
|
|
constant itself into however many expression elements are needed
|
|
|
|
|
to hold it, and then writing another expression element that contains
|
2011-01-10 20:38:51 +00:00
|
|
|
|
the length of the string. I.e. an expression element at each end of
|
1999-04-16 01:35:26 +00:00
|
|
|
|
the string records the string length, so you can skip over the
|
|
|
|
|
expression elements containing the actual string bytes from either
|
|
|
|
|
end of the string. Note that this also allows gdb to handle
|
|
|
|
|
strings with embedded null bytes, as is required for some languages.
|
|
|
|
|
|
|
|
|
|
Don't be fooled by the fact that the string is null byte terminated,
|
gdb/
2009-03-05 Tom Tromey <tromey@redhat.com>
Add support for convenience functions in Python.
* Makefile.in (SUBDIR_PYTHON_OBS): Add python-function.o.
(SUBDIR_PYTHON_SRCS): Add python-function.c.
(python-function.o): New target.
* eval.c: Include "python/python.h" and <ctype.h>.
(evaluate_subexp_standard): Handle values of type
TYPE_CODE_INTERNAL_FUNCTION.
* gdbtypes.h (type_code): Add TYPE_CODE_INTERNAL_FUNCTION.
* parse.c (write_exp_string): Remove duplicate word in comment.
* python/python-function.c: New file.
* python/python-internal.h (gdbpy_initialize_functions): Add
prototype.
* python/python.c (_initialize_python): Call
gdbpy_initialize_functions.
* valprint.c (value_check_printable): Handle values of type
TYPE_CODE_INTERNAL_FUNCTION.
* value.c: Include "cli/cli-decode.h".
(internal_function): New struct.
(functionlist, internal_fn_type): New static variables.
(lookup_only_internalvar,
lookup_internalvar): Add const qualifier to name argument.
(create_internalvar): Likewise. Initialize new field.
(set_internal_var): Fix typo in comment. Don't allow assignment
to canonical variable.
(value_create_internal_function, value_internal_function_name,
call_internal_function, function_command, function_destroyer,
add_internal_function): New functions.
(_initialize_values): Create `function' placeholder command.
Initialize internal_fn_type.
* value.h (lookup_only_internalvar, create_internalvar,
lookup_internalvar): Add const qualifier to name argument.
(internal_function_fn, add_internal_function, call_internal_function,
value_internal_function_name): Add prototypes.
(struct internalvar) <canonical>: New field.
gdb/doc/
2008-03-05 Tom Tromey <tromey@redhat.com>
* gdb.texinfo (Convenience Vars): Document convenience functions.
(Functions In Python): New node.
(Python API): Update.
gdb/testsuite/
2009-03-05 Thiago Jung Bauermann <bauerman@br.ibm.com>
* gdb.python/python-function.exp: New file.
2009-03-21 03:03:56 +00:00
|
|
|
|
this is strictly for the convenience of debugging gdb itself.
|
1999-04-16 01:35:26 +00:00
|
|
|
|
Gdb does not depend up the string being null terminated, since the
|
|
|
|
|
actual length is recorded in expression elements at each end of the
|
|
|
|
|
string. The null byte is taken into consideration when computing how
|
|
|
|
|
many expression elements are required to hold the string constant, of
|
2011-01-10 20:38:51 +00:00
|
|
|
|
course. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
2000-07-30 01:48:28 +00:00
|
|
|
|
write_exp_string (struct stoken str)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2003-09-09 08:05:43 +00:00
|
|
|
|
int len = str.length;
|
|
|
|
|
int lenelt;
|
|
|
|
|
char *strdata;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
/* Compute the number of expression elements required to hold the string
|
|
|
|
|
(including a null byte terminator), along with one expression element
|
|
|
|
|
at each end to record the actual string length (not including the
|
2011-01-10 20:38:51 +00:00
|
|
|
|
null byte terminator). */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1);
|
|
|
|
|
|
|
|
|
|
/* Ensure that we have enough available expression elements to store
|
2011-01-10 20:38:51 +00:00
|
|
|
|
everything. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
if ((expout_ptr + lenelt) >= expout_size)
|
|
|
|
|
{
|
|
|
|
|
expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
|
|
|
|
|
expout = (struct expression *)
|
|
|
|
|
xrealloc ((char *) expout, (sizeof (struct expression)
|
|
|
|
|
+ EXP_ELEM_TO_BYTES (expout_size)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Write the leading length expression element (which advances the current
|
|
|
|
|
expression element index), then write the string constant followed by a
|
|
|
|
|
terminating null byte, and then write the trailing length expression
|
2011-01-10 20:38:51 +00:00
|
|
|
|
element. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
write_exp_elt_longcst ((LONGEST) len);
|
|
|
|
|
strdata = (char *) &expout->elts[expout_ptr];
|
|
|
|
|
memcpy (strdata, str.ptr, len);
|
|
|
|
|
*(strdata + len) = '\0';
|
|
|
|
|
expout_ptr += lenelt - 2;
|
|
|
|
|
write_exp_elt_longcst ((LONGEST) len);
|
|
|
|
|
}
|
|
|
|
|
|
gdb:
2009-03-19 Tom Tromey <tromey@redhat.com>
Julian Brown <julian@codesourcery.com>
PR i18n/7220, PR i18n/7821, PR exp/8815, PR exp/9103,
PR i18n/9401, PR exp/9613:
* NEWS: Update
* value.h (value_typed_string): Declare.
(val_print_string): Update.
* valprint.h (print_char_chars): Update.
* valprint.c (print_char_chars): Add type argument. Update.
(val_print_string): Likewise.
* valops.c (value_typed_string): New function.
* utils.c (host_char_to_target): New function.
(parse_escape): Use host_char_to_target, host_hex_value. Update.
Remove '^' case.
(no_control_char_error): Remove.
* typeprint.c (print_type_scalar): Update.
* scm-valprint.c (scm_scmval_print): Update.
* scm-lang.h (scm_printchar, scm_printstr): Update.
* scm-lang.c (scm_printchar): Add type argument.
(scm_printstr): Likewise.
* printcmd.c (print_formatted): Update.
(print_scalar_formatted): Update.
(printf_command) <wide_string_arg, wide_char_arg>: New constants.
Handle '%lc' and '%ls'.
* parser-defs.h (struct typed_stoken): New type.
(struct stoken_vector): Likewise.
(write_exp_string_vector): Declare.
* parse.c (write_exp_string_vector): New function.
* p-valprint.c (pascal_val_print): Update.
* p-lang.h (is_pascal_string_type, pascal_printchar,
pascal_printstr): Update.
* p-lang.c (is_pascal_string_type): Remove 'char_size' argument.
Add 'char_type' argument.
(pascal_emit_char): Add type argument.
(pascal_printchar): Likewise.
(pascal_printstr): Likewise.
* objc-lang.c (objc_emit_char): Add type argument.
(objc_printchar): Likewise.
(objc_printstr): Likewise.
* macroexp.c (get_character_constant): Handle unicode characters.
Use c_parse_escape.
(get_string_literal): Handle unicode strings. Use
c_parse_escape.
* m2-valprint.c (print_unpacked_pointer): Update.
(m2_print_array_contents): Update.
(m2_val_print): Update.
* m2-lang.c (m2_emit_char): Add type argument.
(m2_printchar): Likewise.
(m2_printstr): Likewise.
* language.h (struct language_defn) <la_printchar>: Add type
argument.
<la_printstr, la_emitchar>: Likewise.
(LA_PRINT_CHAR): Likewise.
(LA_PRINT_STRING): Likewise.
(LA_EMIT_CHAR): Likewise.
* language.c (unk_lang_emit_char): Add type argument.
(unk_lang_printchar): Likewise.
(unk_lang_printstr): Likewise.
* jv-valprint.c (java_val_print): Update.
* jv-lang.c (java_emit_char): Add type argument.
* f-valprint.c (f_val_print): Update.
* f-lang.c (f_emit_char): Add type argument.
(f_printchar): Likewise.
(f_printstr): Likewise.
* expprint.c (print_subexp_standard): Update.
* charset.h (target_wide_charset): Declare.
(c_target_char_has_backslash_escape, c_parse_backslash,
host_char_print_literally, host_char_to_target,
target_char_to_host, target_char_to_control_char): Remove.
(enum transliterations): New type.
(convert_between_encodings): Declare.
(HOST_ESCAPE_CHAR): New define.
(host_letter_to_control_character, host_hex_value): Declare.
(enum wchar_iterate_result): New enum.
(struct wchar_iterator): Declare.
(make_wchar_iterator, make_cleanup_wchar_iterator, wchar_iterator,
wchar_push_back): Declare.
* charset-list.h: New file.
* c-valprint.c (textual_name): New function.
(textual_element_type): Handle wide character types.
(c_val_print): Pass original type to textual_element_type. Handle
wide character types.
(c_value_print): Use textual_element_type. Pass original type of
value to val_print.
* c-lang.h (enum c_string_type): New type.
(c_printchar, c_printstr): Update.
* c-lang.c (classify_type): New function.
(print_wchar): Likewise.
(c_emit_char): Add type argument. Handle wide characters.
(c_printchar): Likewise.
(c_printstr): Add type argument. Handle wide and multibyte
character sets.
(convert_ucn): New function.
(emit_numeric_character): Likewise.
(convert_octal): Likewise.
(convert_hex): Likewise.
(ADVANCE): New macro.
(convert_escape): New function.
(parse_one_string): Likewise.
(evaluate_subexp_c): Likewise.
(exp_descriptor_c): New global.
(c_language_defn): Use exp_descriptor_c.
(cplus_language_defn): Likewise.
(asm_language_defn): Likewise.
(minimal_language_defn): Likewise.
(charset_for_string_type): New function.
* c-exp.y (%union): Add 'svec' and 'tsval'.
(CHAR): New token.
(exp): Add CHAR production.
(string_exp): Rewrite.
(exp) <string_exp>: Rewrite.
(tempbuf): Now global.
(tempbuf_init): New global.
(parse_string_or_char): New function.
(yylex) <tempbuf>: Now global.
<tokptr, tempbufindex, tempbufsize, token_string, class_prefix>:
Remove.
Handle 'u', 'U', and 'L' prefixes. Call parse_string_or_char.
(c_parse_escape): New function.
* auxv.c (fprint_target_auxv): Update.
* ada-valprint.c (ada_emit_char): Add type argument.
(ada_printchar): Likewise.
(ada_print_scalar): Update.
(printstr): Add type argument. Update calls to ada_emit_char.
(ada_printstr): Add type argument.
(ada_val_print_array): Update.
(ada_val_print_1): Likewise.
* ada-lang.c (emit_char): Add type argument.
* ada-lang.h (ada_emit_char, ada_printchar, ada_printstr): Add
type arguments.
* gdb_locale.h: Include langinfo.h.
* charset.c (_initialize_charset): Set default host charset from
the locale. Don't register charsets. Add target-wide-charset
commands. Call find_charset_names.
(struct charset, struct translation): Remove.
(GDB_DEFAULT_HOST_CHARSET): Remove.
(GDB_DEFAULT_TARGET_WIDE_CHARSET): New define.
(target_wide_charset_name): New global.
(show_host_charset_name): Handle "auto".
(show_target_wide_charset_name): New function.
(host_charset_enum, target_charset_enum): Remove.
(charset_enum): New global.
(all_charsets, register_charset, lookup_charset, all_translations,
register_translation, lookup_translation): Remove.
(simple_charset, ascii_print_literally, ascii_to_control): Remove.
(iso_8859_print_literally, iso_8859_to_control,
iso_8859_family_charset): Remove.
(ebcdic_print_literally, ebcdic_to_control,
ebcdic_family_charset): Remove.
(struct cached_iconv, check_iconv_cache, cached_iconv_convert,
register_iconv_charsets): Remove.
(target_wide_charset_be_name, target_wide_charset_le_name): New
globals.
(identity_either_char_to_other): Remove.
(set_be_le_names, validate): New functions.
(backslashable, backslashed, represented): Remove.
(default_c_target_char_has_backslash_escape): Remove.
(default_c_parse_backslash, iconv_convert): Remove.
(ascii_to_iso_8859_1_table, ascii_to_ebcdic_us_table,
ascii_to_ibm1047_table, iso_8859_1_to_ascii_table,
iso_8859_1_to_ebcdic_us_table, iso_8859_1_to_ibm1047_table,
ebcdic_us_to_ascii_table, ebcdic_us_to_iso_8859_1_table,
ebcdic_us_to_ibm1047_table, ibm1047_to_ascii_table,
ibm1047_to_iso_8859_1_table, ibm1047_to_ebcdic_us_table): Remove.
(table_convert_char, table_translation, simple_table_translation):
Remove.
(current_host_charset, current_target_charset,
c_target_char_has_backslash_escape_func,
c_target_char_has_backslash_escape_baton): Remove.
(c_parse_backslash_func, c_parse_backslash_baton): Remove.
(host_char_to_target_func, host_char_to_target_baton): Remove.
(target_char_to_host_func, target_char_to_host_baton): Remove.
(cached_iconv_host_to_target, cached_iconv_target_to_host):
Remove.
(lookup_charset_or_error, check_valid_host_charset): Remove.
(set_host_and_target_charsets): Remove.
(set_host_charset, set_target_charset): Remove.
(set_host_charset_sfunc, set_target_charset_sfunc): Rewrite.
(set_target_wide_charset_sfunc): New function.
(show_charset): Print target wide character set.
(host_charset, target_charset): Rewrite.
(target_wide_charset): New function.
(c_target_char_has_backslash_escape): Remove.
(c_parse_backslash): Remove.
(host_letter_to_control_character): New function.
(host_char_print_literally): Remove.
(host_hex_value): New function.
(target_char_to_control_char): Remove.
(cleanup_iconv): New function.
(convert_between_encodings): New function.
(target_char_to_host): Remove.
(struct wchar_iterator): Define.
(make_wchar_iterator, make_cleanup_wchar_iterator, wchar_iterator,
wchar_push_back): New functions.
(do_cleanup_iterator): New function.
(char_ptr): New typedef.
(charsets): New global.
(add_one, find_charset_names): New functions.
(default_charset_names): New global.
(auto_host_charset_name): Likewise.
* aclocal.m4, config.in, configure: Rebuild.
* configure.ac: Call AM_LANGINFO_CODESET.
(GDB_DEFAULT_HOST_CHARSET): Default to UTF-8.
(AM_ICONV): Invoke earlier.
* acinclude.m4: Include codeset.m4. Subst LIBICONV_INCLUDE and
LIBICONV_LIBDIR. Check for libiconv in build tree.
* Makefile.in (LIBICONV_LIBDIR, LIBICONV_INCLUDE): New macros.
(INTERNAL_CFLAGS_BASE): Add LIBICONV_INCLUDE.
(INTERNAL_LDFLAGS): Add LIBICONV_LIBDIR.
* gdb_obstack.h (obstack_grow_wstr): New define.
* gdb_wchar.h: New file.
* defs.h: Include it.
gdb/testsuite:
* gdb.base/store.exp: Update for change to escape output.
* gdb.base/callfuncs.exp (fetch_all_registers): Update for change
to escape output.
* gdb.base/pointers.exp: Update for change to escape output.
* gdb.base/long_long.exp (gdb_test_long_long): Update for change
to escape output.
* gdb.base/constvars.exp (do_constvar_tests): Update for change to
escape output.
* gdb.base/call-rt-st.exp (print_struct_call): Update for change
to escape output.
* gdb.cp/ref-types.exp (gdb_start_again): Update for change to
escape output.
* gdb.base/setvar.exp: Update for change to escape output.
* lib/gdb.exp (default_gdb_start): Set LC_CTYPE to C.
* gdb.base/printcmds.exp (test_print_all_chars): Update for change
to escape output.
(test_print_string_constants): Likewise.
* gdb.base/charset.exp (valid_host_charset): Check size of
wchar_t. Handle UCS-2 and UCS-4. Add tests for wide and unicode
cases. Handle "auto"-related output.
* gdb.base/charset.c (char16_t, char32_t): New typedefs.
(uvar, Uvar): New globals.
gdb/doc:
* gdb.texinfo (Character Sets): Remove obsolete text. Document
set target-wide-charset.
(Requirements): Mention iconv.
2009-03-20 23:04:40 +00:00
|
|
|
|
/* Add a vector of string constants to the end of the expression.
|
|
|
|
|
|
|
|
|
|
This adds an OP_STRING operation, but encodes the contents
|
|
|
|
|
differently from write_exp_string. The language is expected to
|
|
|
|
|
handle evaluation of this expression itself.
|
|
|
|
|
|
|
|
|
|
After the usual OP_STRING header, TYPE is written into the
|
|
|
|
|
expression as a long constant. The interpretation of this field is
|
|
|
|
|
up to the language evaluator.
|
|
|
|
|
|
|
|
|
|
Next, each string in VEC is written. The length is written as a
|
|
|
|
|
long constant, followed by the contents of the string. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
write_exp_string_vector (int type, struct stoken_vector *vec)
|
|
|
|
|
{
|
|
|
|
|
int i, n_slots, len;
|
|
|
|
|
|
|
|
|
|
/* Compute the size. We compute the size in number of slots to
|
|
|
|
|
avoid issues with string padding. */
|
|
|
|
|
n_slots = 0;
|
|
|
|
|
for (i = 0; i < vec->len; ++i)
|
|
|
|
|
{
|
|
|
|
|
/* One slot for the length of this element, plus the number of
|
|
|
|
|
slots needed for this string. */
|
|
|
|
|
n_slots += 1 + BYTES_TO_EXP_ELEM (vec->tokens[i].length);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* One more slot for the type of the string. */
|
|
|
|
|
++n_slots;
|
|
|
|
|
|
|
|
|
|
/* Now compute a phony string length. */
|
|
|
|
|
len = EXP_ELEM_TO_BYTES (n_slots) - 1;
|
|
|
|
|
|
|
|
|
|
n_slots += 4;
|
|
|
|
|
if ((expout_ptr + n_slots) >= expout_size)
|
|
|
|
|
{
|
|
|
|
|
expout_size = max (expout_size * 2, expout_ptr + n_slots + 10);
|
|
|
|
|
expout = (struct expression *)
|
|
|
|
|
xrealloc ((char *) expout, (sizeof (struct expression)
|
|
|
|
|
+ EXP_ELEM_TO_BYTES (expout_size)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
write_exp_elt_opcode (OP_STRING);
|
|
|
|
|
write_exp_elt_longcst (len);
|
|
|
|
|
write_exp_elt_longcst (type);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < vec->len; ++i)
|
|
|
|
|
{
|
|
|
|
|
write_exp_elt_longcst (vec->tokens[i].length);
|
|
|
|
|
memcpy (&expout->elts[expout_ptr], vec->tokens[i].ptr,
|
|
|
|
|
vec->tokens[i].length);
|
|
|
|
|
expout_ptr += BYTES_TO_EXP_ELEM (vec->tokens[i].length);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
write_exp_elt_longcst (len);
|
|
|
|
|
write_exp_elt_opcode (OP_STRING);
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
/* Add a bitstring constant to the end of the expression.
|
|
|
|
|
|
|
|
|
|
Bitstring constants are stored by first writing an expression element
|
|
|
|
|
that contains the length of the bitstring (in bits), then stuffing the
|
|
|
|
|
bitstring constant itself into however many expression elements are
|
|
|
|
|
needed to hold it, and then writing another expression element that
|
2011-01-10 20:38:51 +00:00
|
|
|
|
contains the length of the bitstring. I.e. an expression element at
|
1999-04-16 01:35:26 +00:00
|
|
|
|
each end of the bitstring records the bitstring length, so you can skip
|
|
|
|
|
over the expression elements containing the actual bitstring bytes from
|
2011-01-10 20:38:51 +00:00
|
|
|
|
either end of the bitstring. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
void
|
2000-07-30 01:48:28 +00:00
|
|
|
|
write_exp_bitstring (struct stoken str)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2003-09-09 08:05:43 +00:00
|
|
|
|
int bits = str.length; /* length in bits */
|
|
|
|
|
int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT;
|
|
|
|
|
int lenelt;
|
|
|
|
|
char *strdata;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
/* Compute the number of expression elements required to hold the bitstring,
|
|
|
|
|
along with one expression element at each end to record the actual
|
2011-01-10 20:38:51 +00:00
|
|
|
|
bitstring length in bits. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
lenelt = 2 + BYTES_TO_EXP_ELEM (len);
|
|
|
|
|
|
|
|
|
|
/* Ensure that we have enough available expression elements to store
|
2011-01-10 20:38:51 +00:00
|
|
|
|
everything. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
if ((expout_ptr + lenelt) >= expout_size)
|
|
|
|
|
{
|
|
|
|
|
expout_size = max (expout_size * 2, expout_ptr + lenelt + 10);
|
|
|
|
|
expout = (struct expression *)
|
|
|
|
|
xrealloc ((char *) expout, (sizeof (struct expression)
|
|
|
|
|
+ EXP_ELEM_TO_BYTES (expout_size)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Write the leading length expression element (which advances the current
|
|
|
|
|
expression element index), then write the bitstring constant, and then
|
2011-01-10 20:38:51 +00:00
|
|
|
|
write the trailing length expression element. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
write_exp_elt_longcst ((LONGEST) bits);
|
|
|
|
|
strdata = (char *) &expout->elts[expout_ptr];
|
|
|
|
|
memcpy (strdata, str.ptr, len);
|
|
|
|
|
expout_ptr += lenelt - 2;
|
|
|
|
|
write_exp_elt_longcst ((LONGEST) bits);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Add the appropriate elements for a minimal symbol to the end of
|
2008-09-11 14:08:33 +00:00
|
|
|
|
the expression. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
void
|
2008-09-11 14:08:33 +00:00
|
|
|
|
write_exp_msymbol (struct minimal_symbol *msymbol)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2008-05-03 00:37:35 +00:00
|
|
|
|
struct objfile *objfile = msymbol_objfile (msymbol);
|
|
|
|
|
struct gdbarch *gdbarch = get_objfile_arch (objfile);
|
|
|
|
|
|
|
|
|
|
CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (msymbol);
|
* breakpoint.h (struct bp_location): Change type of section
member to "struct obj_section *".
* tracepoint.h (struct tracepoint): Likewise.
* symtab.h (struct general_symbol_info): Replace bfd_section
member with obj_section.
(struct symtab_and_line): Change type of section member to
"struct obj_section *".
(SYMBOL_BFD_SECTION): Remove macro, replace by ...
(SYMBOL_OBJ_SECTION): ... this.
* minsym.c (prim_record_minimal_symbol_and_info): Record symbol
section as obj_section instead of bfd_section.
* ada-lang.c (ada_decode_symbol): Use gsymbol->obj_section
directly instead of looking of obj_section from bfd_section.
* objfiles.h (find_pc_sect_section): Remove.
* objfiles.c (find_pc_sect_section): Remove.
(find_pc_section): Inline find_pc_sect_section code.
* symfile.h (find_pc_overlay): Return struct obj_section *.
(find_pc_mapped_section): Likewise.
(section_is_overlay, section_is_mapped): Change type of section
argument to struct obj_section *.
(pc_in_mapped_range, pc_in_unmapped_range): Likewise.
(overlay_mapped_address, overlay_unmapped_address): Likewise.
(symbol_overlayed_address): Likewise.
* symtab.h (symbol_overlayed_address): Likewise.
* symfile.c (overlay_is_mapped): Remove.
(section_is_mapped): Inline overlay_is_mapped code. Update.
(overlay_invalidate_all): Update.
(section_is_overlay): Change section argument to type
"struct obj_section *". Use bfd_ methods.
(pc_in_unmapped_range): Likewise. Handle relocated sections.
(pc_in_mapped_range): Likewise. Handle relocated sections.
(sections_overlap): Likewise.
(overlay_unmapped_address): Likewise.
(overlay_mapped_address): Likewise.
(symbol_overlayed_address): Likewise.
(find_pc_overlay): Return struct obj_section *.
(find_pc_mapped_section): Likewise.
(list_overlays_command): Update.
(map_overlay_command, unmap_overlay_command): Update.
(simple_overlay_update): Update.
* block.h (blockvector_for_pc_sect): Change section argument
to type "struct obj_section *".
(block_for_pc_sect): Likewise.
* block.c (blockvector_for_pc_sect): Change section argument
to type "struct obj_section *".
(block_for_pc_sect): Likewise.
* symtab.h (find_pc_sect_function, find_pc_sect_psymtab,
find_pc_sect_symtab, find_pc_sect_psymbol, find_pc_sect_line,
lookup_minimal_symbol_by_pc_section, find_function_start_pc): Likewise.
(matching_bfd_sections): Rename to ...
(matching_obj_sections): ... this. Update argument types.
* blockframe.c (find_pc_sect_function): Likewise.
* breakpoint.c (describe_other_breakpoints): Likewise.
(breakpoint_has_pc, check_duplicates_for): Likewise.
* minsyms.c (lookup_minimal_symbol_by_pc_section_1): Likewise.
(lookup_minimal_symbol_by_pc_section): Likewise.
* symtab.c (find_pc_sect_psymtab_closer): Likewise.
(find_pc_sect_psymtab, find_pc_sect_psymbol, find_pc_sect_symtab,
find_pc_sect_line, find_function_start_pc): Likewise.
(matching_bfd_sections): Rename to ...
(matching_obj_sections): ... this. Update argument types.
* blockframe.c (find_pc_partial_function): Update to section
type changes. No longer call find_pc_sect_section.
(cache_pc_function_section): Change to type "struct obj_section *".
* breakpoint.c (resolve_sal_pc): Update to section type changes.
* exec.c (xfer_memory): Likewise.
* findvar.c (read_var_value): Likewise.
* infcmd.c (jump_command): Likewise.
* linespec.c (minsym_found): Likewise.
* maint.c (maintenance_translate_address): Likewise.
* minsyms.c (lookup_minimal_symbol_by_pc_section_1): Likewise.
(lookup_solib_trampoline_symbol_by_pc): Likewise.
* parse.c (write_exp_msymbol): Likewise.
* printcmd.c (build_address_symbolic): Likewise.
(address_info, sym_info): Likewise.
* symmisc.c (dump_msymbols, print_symbol): Likewise.
* symtab.c (fixup_section): Likewise.
(fixup_symbol_section, fixup_psymbol_section): Likewise.
(find_pc_line, find_function_start_sal): Likewise.
* target.c (memory_xfer_partial): Likewise.
* hppa-hpux-tdep.c (hppa64_hpux_in_solib_call_trampoline): Likewise.
* spu-tdep.c (spu_overlay_update): Likewise.
2008-09-05 11:37:18 +00:00
|
|
|
|
struct obj_section *section = SYMBOL_OBJ_SECTION (msymbol);
|
2008-10-01 16:56:52 +00:00
|
|
|
|
enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
|
2008-05-03 00:37:35 +00:00
|
|
|
|
CORE_ADDR pc;
|
|
|
|
|
|
|
|
|
|
/* The minimal symbol might point to a function descriptor;
|
|
|
|
|
resolve it to the actual code address instead. */
|
|
|
|
|
pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, ¤t_target);
|
|
|
|
|
if (pc != addr)
|
|
|
|
|
{
|
2011-03-28 20:21:04 +00:00
|
|
|
|
struct minimal_symbol *ifunc_msym = lookup_minimal_symbol_by_pc (pc);
|
|
|
|
|
|
2008-05-03 00:37:35 +00:00
|
|
|
|
/* In this case, assume we have a code symbol instead of
|
|
|
|
|
a data symbol. */
|
2011-03-28 20:21:04 +00:00
|
|
|
|
|
|
|
|
|
if (ifunc_msym != NULL && MSYMBOL_TYPE (ifunc_msym) == mst_text_gnu_ifunc
|
|
|
|
|
&& SYMBOL_VALUE_ADDRESS (ifunc_msym) == pc)
|
|
|
|
|
{
|
|
|
|
|
/* A function descriptor has been resolved but PC is still in the
|
|
|
|
|
STT_GNU_IFUNC resolver body (such as because inferior does not
|
|
|
|
|
run to be able to call it). */
|
|
|
|
|
|
|
|
|
|
type = mst_text_gnu_ifunc;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
type = mst_text;
|
* breakpoint.h (struct bp_location): Change type of section
member to "struct obj_section *".
* tracepoint.h (struct tracepoint): Likewise.
* symtab.h (struct general_symbol_info): Replace bfd_section
member with obj_section.
(struct symtab_and_line): Change type of section member to
"struct obj_section *".
(SYMBOL_BFD_SECTION): Remove macro, replace by ...
(SYMBOL_OBJ_SECTION): ... this.
* minsym.c (prim_record_minimal_symbol_and_info): Record symbol
section as obj_section instead of bfd_section.
* ada-lang.c (ada_decode_symbol): Use gsymbol->obj_section
directly instead of looking of obj_section from bfd_section.
* objfiles.h (find_pc_sect_section): Remove.
* objfiles.c (find_pc_sect_section): Remove.
(find_pc_section): Inline find_pc_sect_section code.
* symfile.h (find_pc_overlay): Return struct obj_section *.
(find_pc_mapped_section): Likewise.
(section_is_overlay, section_is_mapped): Change type of section
argument to struct obj_section *.
(pc_in_mapped_range, pc_in_unmapped_range): Likewise.
(overlay_mapped_address, overlay_unmapped_address): Likewise.
(symbol_overlayed_address): Likewise.
* symtab.h (symbol_overlayed_address): Likewise.
* symfile.c (overlay_is_mapped): Remove.
(section_is_mapped): Inline overlay_is_mapped code. Update.
(overlay_invalidate_all): Update.
(section_is_overlay): Change section argument to type
"struct obj_section *". Use bfd_ methods.
(pc_in_unmapped_range): Likewise. Handle relocated sections.
(pc_in_mapped_range): Likewise. Handle relocated sections.
(sections_overlap): Likewise.
(overlay_unmapped_address): Likewise.
(overlay_mapped_address): Likewise.
(symbol_overlayed_address): Likewise.
(find_pc_overlay): Return struct obj_section *.
(find_pc_mapped_section): Likewise.
(list_overlays_command): Update.
(map_overlay_command, unmap_overlay_command): Update.
(simple_overlay_update): Update.
* block.h (blockvector_for_pc_sect): Change section argument
to type "struct obj_section *".
(block_for_pc_sect): Likewise.
* block.c (blockvector_for_pc_sect): Change section argument
to type "struct obj_section *".
(block_for_pc_sect): Likewise.
* symtab.h (find_pc_sect_function, find_pc_sect_psymtab,
find_pc_sect_symtab, find_pc_sect_psymbol, find_pc_sect_line,
lookup_minimal_symbol_by_pc_section, find_function_start_pc): Likewise.
(matching_bfd_sections): Rename to ...
(matching_obj_sections): ... this. Update argument types.
* blockframe.c (find_pc_sect_function): Likewise.
* breakpoint.c (describe_other_breakpoints): Likewise.
(breakpoint_has_pc, check_duplicates_for): Likewise.
* minsyms.c (lookup_minimal_symbol_by_pc_section_1): Likewise.
(lookup_minimal_symbol_by_pc_section): Likewise.
* symtab.c (find_pc_sect_psymtab_closer): Likewise.
(find_pc_sect_psymtab, find_pc_sect_psymbol, find_pc_sect_symtab,
find_pc_sect_line, find_function_start_pc): Likewise.
(matching_bfd_sections): Rename to ...
(matching_obj_sections): ... this. Update argument types.
* blockframe.c (find_pc_partial_function): Update to section
type changes. No longer call find_pc_sect_section.
(cache_pc_function_section): Change to type "struct obj_section *".
* breakpoint.c (resolve_sal_pc): Update to section type changes.
* exec.c (xfer_memory): Likewise.
* findvar.c (read_var_value): Likewise.
* infcmd.c (jump_command): Likewise.
* linespec.c (minsym_found): Likewise.
* maint.c (maintenance_translate_address): Likewise.
* minsyms.c (lookup_minimal_symbol_by_pc_section_1): Likewise.
(lookup_solib_trampoline_symbol_by_pc): Likewise.
* parse.c (write_exp_msymbol): Likewise.
* printcmd.c (build_address_symbolic): Likewise.
(address_info, sym_info): Likewise.
* symmisc.c (dump_msymbols, print_symbol): Likewise.
* symtab.c (fixup_section): Likewise.
(fixup_symbol_section, fixup_psymbol_section): Likewise.
(find_pc_line, find_function_start_sal): Likewise.
* target.c (memory_xfer_partial): Likewise.
* hppa-hpux-tdep.c (hppa64_hpux_in_solib_call_trampoline): Likewise.
* spu-tdep.c (spu_overlay_update): Likewise.
2008-09-05 11:37:18 +00:00
|
|
|
|
section = NULL;
|
2008-05-03 00:37:35 +00:00
|
|
|
|
addr = pc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (overlay_debugging)
|
* breakpoint.h (struct bp_location): Change type of section
member to "struct obj_section *".
* tracepoint.h (struct tracepoint): Likewise.
* symtab.h (struct general_symbol_info): Replace bfd_section
member with obj_section.
(struct symtab_and_line): Change type of section member to
"struct obj_section *".
(SYMBOL_BFD_SECTION): Remove macro, replace by ...
(SYMBOL_OBJ_SECTION): ... this.
* minsym.c (prim_record_minimal_symbol_and_info): Record symbol
section as obj_section instead of bfd_section.
* ada-lang.c (ada_decode_symbol): Use gsymbol->obj_section
directly instead of looking of obj_section from bfd_section.
* objfiles.h (find_pc_sect_section): Remove.
* objfiles.c (find_pc_sect_section): Remove.
(find_pc_section): Inline find_pc_sect_section code.
* symfile.h (find_pc_overlay): Return struct obj_section *.
(find_pc_mapped_section): Likewise.
(section_is_overlay, section_is_mapped): Change type of section
argument to struct obj_section *.
(pc_in_mapped_range, pc_in_unmapped_range): Likewise.
(overlay_mapped_address, overlay_unmapped_address): Likewise.
(symbol_overlayed_address): Likewise.
* symtab.h (symbol_overlayed_address): Likewise.
* symfile.c (overlay_is_mapped): Remove.
(section_is_mapped): Inline overlay_is_mapped code. Update.
(overlay_invalidate_all): Update.
(section_is_overlay): Change section argument to type
"struct obj_section *". Use bfd_ methods.
(pc_in_unmapped_range): Likewise. Handle relocated sections.
(pc_in_mapped_range): Likewise. Handle relocated sections.
(sections_overlap): Likewise.
(overlay_unmapped_address): Likewise.
(overlay_mapped_address): Likewise.
(symbol_overlayed_address): Likewise.
(find_pc_overlay): Return struct obj_section *.
(find_pc_mapped_section): Likewise.
(list_overlays_command): Update.
(map_overlay_command, unmap_overlay_command): Update.
(simple_overlay_update): Update.
* block.h (blockvector_for_pc_sect): Change section argument
to type "struct obj_section *".
(block_for_pc_sect): Likewise.
* block.c (blockvector_for_pc_sect): Change section argument
to type "struct obj_section *".
(block_for_pc_sect): Likewise.
* symtab.h (find_pc_sect_function, find_pc_sect_psymtab,
find_pc_sect_symtab, find_pc_sect_psymbol, find_pc_sect_line,
lookup_minimal_symbol_by_pc_section, find_function_start_pc): Likewise.
(matching_bfd_sections): Rename to ...
(matching_obj_sections): ... this. Update argument types.
* blockframe.c (find_pc_sect_function): Likewise.
* breakpoint.c (describe_other_breakpoints): Likewise.
(breakpoint_has_pc, check_duplicates_for): Likewise.
* minsyms.c (lookup_minimal_symbol_by_pc_section_1): Likewise.
(lookup_minimal_symbol_by_pc_section): Likewise.
* symtab.c (find_pc_sect_psymtab_closer): Likewise.
(find_pc_sect_psymtab, find_pc_sect_psymbol, find_pc_sect_symtab,
find_pc_sect_line, find_function_start_pc): Likewise.
(matching_bfd_sections): Rename to ...
(matching_obj_sections): ... this. Update argument types.
* blockframe.c (find_pc_partial_function): Update to section
type changes. No longer call find_pc_sect_section.
(cache_pc_function_section): Change to type "struct obj_section *".
* breakpoint.c (resolve_sal_pc): Update to section type changes.
* exec.c (xfer_memory): Likewise.
* findvar.c (read_var_value): Likewise.
* infcmd.c (jump_command): Likewise.
* linespec.c (minsym_found): Likewise.
* maint.c (maintenance_translate_address): Likewise.
* minsyms.c (lookup_minimal_symbol_by_pc_section_1): Likewise.
(lookup_solib_trampoline_symbol_by_pc): Likewise.
* parse.c (write_exp_msymbol): Likewise.
* printcmd.c (build_address_symbolic): Likewise.
(address_info, sym_info): Likewise.
* symmisc.c (dump_msymbols, print_symbol): Likewise.
* symtab.c (fixup_section): Likewise.
(fixup_symbol_section, fixup_psymbol_section): Likewise.
(find_pc_line, find_function_start_sal): Likewise.
* target.c (memory_xfer_partial): Likewise.
* hppa-hpux-tdep.c (hppa64_hpux_in_solib_call_trampoline): Likewise.
* spu-tdep.c (spu_overlay_update): Likewise.
2008-09-05 11:37:18 +00:00
|
|
|
|
addr = symbol_overlayed_address (addr, section);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
write_exp_elt_opcode (OP_LONG);
|
2001-02-20 00:10:18 +00:00
|
|
|
|
/* Let's make the type big enough to hold a 64-bit address. */
|
* gdbtypes.h (struct builtin_type): Remove builtin_core_addr,
nodebug_text_symbol, nodebug_data_symbol, nodebug_unknown_symbol,
and nodebug_tls_symbol members.
(struct objfile_type): New data structure.
(objfile_type): Add prototype.
* gdbtypes.c (gdbtypes_post_init): Remove initialization code
for types no longer in struct builtin_type.
(objfile_type_data): New static variable.
(_initialize_gdbtypes): Initialize it.
(objfile_type): New function.
* gdbtypes.h (builtin_type_error): Remove.
* gdbtypes.c (build_complex): Do not use builtin_type_error.
* symtab.c (builtin_type_error): Remove.
(_initialize_symtab): Remove initialization.
* stabsread.c (dbx_lookup_type, define_symbol, error_type,
rs6000_builtin_type, read_range_type): Use per-objfile types
instead of global or per-architecture builtin types.
* coffread.c (decode_type): Likewise.
* dwarf2read.c (read_array_type, read_tag_string_type,
new_symbol, die_type): Likewise.
* mdebugread.c (parse_symbol, basic_type, upgrade_type,
parse_procedure, psymtab_to_symtab_1): Likewise.
* xcoffread.c (process_xcoff_symbol): Likewise.
* parse.c (write_exp_msymbol): Likewise.
* stabsread.c (rs6000_builtin_type_data): New static variable.
(_initialize_stabsread): Initialize it.
(rs6000_builtin_type): Add OBJFILE argument. Allocate builtin
types per-objfile instead of globally.
* stabsread.c (dbx_lookup_type): Add OBJFILE argument. Use it
instead of current_objfile; pass it to rs6000_builtin_type.
(dbx_alloc_type, read_type, read_range_type): Update calls.
(cleanup_undefined_types_noname): Add OBJFILE argument and
pass it to dbx_lookup_type.
(cleanup_undefined_types): Add OBJFILE argument and pass it
to cleanup_undefined_types_noname.
* stabsread.h (cleanup_undefined_types): Add OBJFILE argument.
* buildsym.c (end_symtab): Update call.
2009-06-29 13:18:37 +00:00
|
|
|
|
write_exp_elt_type (objfile_type (objfile)->builtin_core_addr);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
write_exp_elt_longcst ((LONGEST) addr);
|
|
|
|
|
write_exp_elt_opcode (OP_LONG);
|
|
|
|
|
|
* breakpoint.h (struct bp_location): Change type of section
member to "struct obj_section *".
* tracepoint.h (struct tracepoint): Likewise.
* symtab.h (struct general_symbol_info): Replace bfd_section
member with obj_section.
(struct symtab_and_line): Change type of section member to
"struct obj_section *".
(SYMBOL_BFD_SECTION): Remove macro, replace by ...
(SYMBOL_OBJ_SECTION): ... this.
* minsym.c (prim_record_minimal_symbol_and_info): Record symbol
section as obj_section instead of bfd_section.
* ada-lang.c (ada_decode_symbol): Use gsymbol->obj_section
directly instead of looking of obj_section from bfd_section.
* objfiles.h (find_pc_sect_section): Remove.
* objfiles.c (find_pc_sect_section): Remove.
(find_pc_section): Inline find_pc_sect_section code.
* symfile.h (find_pc_overlay): Return struct obj_section *.
(find_pc_mapped_section): Likewise.
(section_is_overlay, section_is_mapped): Change type of section
argument to struct obj_section *.
(pc_in_mapped_range, pc_in_unmapped_range): Likewise.
(overlay_mapped_address, overlay_unmapped_address): Likewise.
(symbol_overlayed_address): Likewise.
* symtab.h (symbol_overlayed_address): Likewise.
* symfile.c (overlay_is_mapped): Remove.
(section_is_mapped): Inline overlay_is_mapped code. Update.
(overlay_invalidate_all): Update.
(section_is_overlay): Change section argument to type
"struct obj_section *". Use bfd_ methods.
(pc_in_unmapped_range): Likewise. Handle relocated sections.
(pc_in_mapped_range): Likewise. Handle relocated sections.
(sections_overlap): Likewise.
(overlay_unmapped_address): Likewise.
(overlay_mapped_address): Likewise.
(symbol_overlayed_address): Likewise.
(find_pc_overlay): Return struct obj_section *.
(find_pc_mapped_section): Likewise.
(list_overlays_command): Update.
(map_overlay_command, unmap_overlay_command): Update.
(simple_overlay_update): Update.
* block.h (blockvector_for_pc_sect): Change section argument
to type "struct obj_section *".
(block_for_pc_sect): Likewise.
* block.c (blockvector_for_pc_sect): Change section argument
to type "struct obj_section *".
(block_for_pc_sect): Likewise.
* symtab.h (find_pc_sect_function, find_pc_sect_psymtab,
find_pc_sect_symtab, find_pc_sect_psymbol, find_pc_sect_line,
lookup_minimal_symbol_by_pc_section, find_function_start_pc): Likewise.
(matching_bfd_sections): Rename to ...
(matching_obj_sections): ... this. Update argument types.
* blockframe.c (find_pc_sect_function): Likewise.
* breakpoint.c (describe_other_breakpoints): Likewise.
(breakpoint_has_pc, check_duplicates_for): Likewise.
* minsyms.c (lookup_minimal_symbol_by_pc_section_1): Likewise.
(lookup_minimal_symbol_by_pc_section): Likewise.
* symtab.c (find_pc_sect_psymtab_closer): Likewise.
(find_pc_sect_psymtab, find_pc_sect_psymbol, find_pc_sect_symtab,
find_pc_sect_line, find_function_start_pc): Likewise.
(matching_bfd_sections): Rename to ...
(matching_obj_sections): ... this. Update argument types.
* blockframe.c (find_pc_partial_function): Update to section
type changes. No longer call find_pc_sect_section.
(cache_pc_function_section): Change to type "struct obj_section *".
* breakpoint.c (resolve_sal_pc): Update to section type changes.
* exec.c (xfer_memory): Likewise.
* findvar.c (read_var_value): Likewise.
* infcmd.c (jump_command): Likewise.
* linespec.c (minsym_found): Likewise.
* maint.c (maintenance_translate_address): Likewise.
* minsyms.c (lookup_minimal_symbol_by_pc_section_1): Likewise.
(lookup_solib_trampoline_symbol_by_pc): Likewise.
* parse.c (write_exp_msymbol): Likewise.
* printcmd.c (build_address_symbolic): Likewise.
(address_info, sym_info): Likewise.
* symmisc.c (dump_msymbols, print_symbol): Likewise.
* symtab.c (fixup_section): Likewise.
(fixup_symbol_section, fixup_psymbol_section): Likewise.
(find_pc_line, find_function_start_sal): Likewise.
* target.c (memory_xfer_partial): Likewise.
* hppa-hpux-tdep.c (hppa64_hpux_in_solib_call_trampoline): Likewise.
* spu-tdep.c (spu_overlay_update): Likewise.
2008-09-05 11:37:18 +00:00
|
|
|
|
if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL)
|
2006-10-10 03:17:53 +00:00
|
|
|
|
{
|
|
|
|
|
write_exp_elt_opcode (UNOP_MEMVAL_TLS);
|
2008-05-03 00:37:35 +00:00
|
|
|
|
write_exp_elt_objfile (objfile);
|
* gdbtypes.h (struct builtin_type): Remove builtin_core_addr,
nodebug_text_symbol, nodebug_data_symbol, nodebug_unknown_symbol,
and nodebug_tls_symbol members.
(struct objfile_type): New data structure.
(objfile_type): Add prototype.
* gdbtypes.c (gdbtypes_post_init): Remove initialization code
for types no longer in struct builtin_type.
(objfile_type_data): New static variable.
(_initialize_gdbtypes): Initialize it.
(objfile_type): New function.
* gdbtypes.h (builtin_type_error): Remove.
* gdbtypes.c (build_complex): Do not use builtin_type_error.
* symtab.c (builtin_type_error): Remove.
(_initialize_symtab): Remove initialization.
* stabsread.c (dbx_lookup_type, define_symbol, error_type,
rs6000_builtin_type, read_range_type): Use per-objfile types
instead of global or per-architecture builtin types.
* coffread.c (decode_type): Likewise.
* dwarf2read.c (read_array_type, read_tag_string_type,
new_symbol, die_type): Likewise.
* mdebugread.c (parse_symbol, basic_type, upgrade_type,
parse_procedure, psymtab_to_symtab_1): Likewise.
* xcoffread.c (process_xcoff_symbol): Likewise.
* parse.c (write_exp_msymbol): Likewise.
* stabsread.c (rs6000_builtin_type_data): New static variable.
(_initialize_stabsread): Initialize it.
(rs6000_builtin_type): Add OBJFILE argument. Allocate builtin
types per-objfile instead of globally.
* stabsread.c (dbx_lookup_type): Add OBJFILE argument. Use it
instead of current_objfile; pass it to rs6000_builtin_type.
(dbx_alloc_type, read_type, read_range_type): Update calls.
(cleanup_undefined_types_noname): Add OBJFILE argument and
pass it to dbx_lookup_type.
(cleanup_undefined_types): Add OBJFILE argument and pass it
to cleanup_undefined_types_noname.
* stabsread.h (cleanup_undefined_types): Add OBJFILE argument.
* buildsym.c (end_symtab): Update call.
2009-06-29 13:18:37 +00:00
|
|
|
|
write_exp_elt_type (objfile_type (objfile)->nodebug_tls_symbol);
|
2006-10-10 03:17:53 +00:00
|
|
|
|
write_exp_elt_opcode (UNOP_MEMVAL_TLS);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
write_exp_elt_opcode (UNOP_MEMVAL);
|
2008-05-03 00:37:35 +00:00
|
|
|
|
switch (type)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
|
|
|
|
case mst_text:
|
|
|
|
|
case mst_file_text:
|
|
|
|
|
case mst_solib_trampoline:
|
* gdbtypes.h (struct builtin_type): Remove builtin_core_addr,
nodebug_text_symbol, nodebug_data_symbol, nodebug_unknown_symbol,
and nodebug_tls_symbol members.
(struct objfile_type): New data structure.
(objfile_type): Add prototype.
* gdbtypes.c (gdbtypes_post_init): Remove initialization code
for types no longer in struct builtin_type.
(objfile_type_data): New static variable.
(_initialize_gdbtypes): Initialize it.
(objfile_type): New function.
* gdbtypes.h (builtin_type_error): Remove.
* gdbtypes.c (build_complex): Do not use builtin_type_error.
* symtab.c (builtin_type_error): Remove.
(_initialize_symtab): Remove initialization.
* stabsread.c (dbx_lookup_type, define_symbol, error_type,
rs6000_builtin_type, read_range_type): Use per-objfile types
instead of global or per-architecture builtin types.
* coffread.c (decode_type): Likewise.
* dwarf2read.c (read_array_type, read_tag_string_type,
new_symbol, die_type): Likewise.
* mdebugread.c (parse_symbol, basic_type, upgrade_type,
parse_procedure, psymtab_to_symtab_1): Likewise.
* xcoffread.c (process_xcoff_symbol): Likewise.
* parse.c (write_exp_msymbol): Likewise.
* stabsread.c (rs6000_builtin_type_data): New static variable.
(_initialize_stabsread): Initialize it.
(rs6000_builtin_type): Add OBJFILE argument. Allocate builtin
types per-objfile instead of globally.
* stabsread.c (dbx_lookup_type): Add OBJFILE argument. Use it
instead of current_objfile; pass it to rs6000_builtin_type.
(dbx_alloc_type, read_type, read_range_type): Update calls.
(cleanup_undefined_types_noname): Add OBJFILE argument and
pass it to dbx_lookup_type.
(cleanup_undefined_types): Add OBJFILE argument and pass it
to cleanup_undefined_types_noname.
* stabsread.h (cleanup_undefined_types): Add OBJFILE argument.
* buildsym.c (end_symtab): Update call.
2009-06-29 13:18:37 +00:00
|
|
|
|
write_exp_elt_type (objfile_type (objfile)->nodebug_text_symbol);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2011-03-28 20:21:04 +00:00
|
|
|
|
case mst_text_gnu_ifunc:
|
|
|
|
|
write_exp_elt_type (objfile_type (objfile)
|
|
|
|
|
->nodebug_text_gnu_ifunc_symbol);
|
|
|
|
|
break;
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
case mst_data:
|
|
|
|
|
case mst_file_data:
|
|
|
|
|
case mst_bss:
|
|
|
|
|
case mst_file_bss:
|
* gdbtypes.h (struct builtin_type): Remove builtin_core_addr,
nodebug_text_symbol, nodebug_data_symbol, nodebug_unknown_symbol,
and nodebug_tls_symbol members.
(struct objfile_type): New data structure.
(objfile_type): Add prototype.
* gdbtypes.c (gdbtypes_post_init): Remove initialization code
for types no longer in struct builtin_type.
(objfile_type_data): New static variable.
(_initialize_gdbtypes): Initialize it.
(objfile_type): New function.
* gdbtypes.h (builtin_type_error): Remove.
* gdbtypes.c (build_complex): Do not use builtin_type_error.
* symtab.c (builtin_type_error): Remove.
(_initialize_symtab): Remove initialization.
* stabsread.c (dbx_lookup_type, define_symbol, error_type,
rs6000_builtin_type, read_range_type): Use per-objfile types
instead of global or per-architecture builtin types.
* coffread.c (decode_type): Likewise.
* dwarf2read.c (read_array_type, read_tag_string_type,
new_symbol, die_type): Likewise.
* mdebugread.c (parse_symbol, basic_type, upgrade_type,
parse_procedure, psymtab_to_symtab_1): Likewise.
* xcoffread.c (process_xcoff_symbol): Likewise.
* parse.c (write_exp_msymbol): Likewise.
* stabsread.c (rs6000_builtin_type_data): New static variable.
(_initialize_stabsread): Initialize it.
(rs6000_builtin_type): Add OBJFILE argument. Allocate builtin
types per-objfile instead of globally.
* stabsread.c (dbx_lookup_type): Add OBJFILE argument. Use it
instead of current_objfile; pass it to rs6000_builtin_type.
(dbx_alloc_type, read_type, read_range_type): Update calls.
(cleanup_undefined_types_noname): Add OBJFILE argument and
pass it to dbx_lookup_type.
(cleanup_undefined_types): Add OBJFILE argument and pass it
to cleanup_undefined_types_noname.
* stabsread.h (cleanup_undefined_types): Add OBJFILE argument.
* buildsym.c (end_symtab): Update call.
2009-06-29 13:18:37 +00:00
|
|
|
|
write_exp_elt_type (objfile_type (objfile)->nodebug_data_symbol);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2011-03-28 20:21:04 +00:00
|
|
|
|
case mst_slot_got_plt:
|
|
|
|
|
write_exp_elt_type (objfile_type (objfile)->nodebug_got_plt_symbol);
|
|
|
|
|
break;
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
default:
|
* gdbtypes.h (struct builtin_type): Remove builtin_core_addr,
nodebug_text_symbol, nodebug_data_symbol, nodebug_unknown_symbol,
and nodebug_tls_symbol members.
(struct objfile_type): New data structure.
(objfile_type): Add prototype.
* gdbtypes.c (gdbtypes_post_init): Remove initialization code
for types no longer in struct builtin_type.
(objfile_type_data): New static variable.
(_initialize_gdbtypes): Initialize it.
(objfile_type): New function.
* gdbtypes.h (builtin_type_error): Remove.
* gdbtypes.c (build_complex): Do not use builtin_type_error.
* symtab.c (builtin_type_error): Remove.
(_initialize_symtab): Remove initialization.
* stabsread.c (dbx_lookup_type, define_symbol, error_type,
rs6000_builtin_type, read_range_type): Use per-objfile types
instead of global or per-architecture builtin types.
* coffread.c (decode_type): Likewise.
* dwarf2read.c (read_array_type, read_tag_string_type,
new_symbol, die_type): Likewise.
* mdebugread.c (parse_symbol, basic_type, upgrade_type,
parse_procedure, psymtab_to_symtab_1): Likewise.
* xcoffread.c (process_xcoff_symbol): Likewise.
* parse.c (write_exp_msymbol): Likewise.
* stabsread.c (rs6000_builtin_type_data): New static variable.
(_initialize_stabsread): Initialize it.
(rs6000_builtin_type): Add OBJFILE argument. Allocate builtin
types per-objfile instead of globally.
* stabsread.c (dbx_lookup_type): Add OBJFILE argument. Use it
instead of current_objfile; pass it to rs6000_builtin_type.
(dbx_alloc_type, read_type, read_range_type): Update calls.
(cleanup_undefined_types_noname): Add OBJFILE argument and
pass it to dbx_lookup_type.
(cleanup_undefined_types): Add OBJFILE argument and pass it
to cleanup_undefined_types_noname.
* stabsread.h (cleanup_undefined_types): Add OBJFILE argument.
* buildsym.c (end_symtab): Update call.
2009-06-29 13:18:37 +00:00
|
|
|
|
write_exp_elt_type (objfile_type (objfile)->nodebug_unknown_symbol);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
write_exp_elt_opcode (UNOP_MEMVAL);
|
|
|
|
|
}
|
2008-06-06 20:58:08 +00:00
|
|
|
|
|
|
|
|
|
/* Mark the current index as the starting location of a structure
|
|
|
|
|
expression. This is used when completing on field names. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
mark_struct_expression (void)
|
|
|
|
|
{
|
|
|
|
|
expout_last_struct = expout_ptr;
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
/* Recognize tokens that start with '$'. These include:
|
|
|
|
|
|
1999-07-07 20:19:36 +00:00
|
|
|
|
$regname A native register name or a "standard
|
|
|
|
|
register name".
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
1999-07-07 20:19:36 +00:00
|
|
|
|
$variable A convenience variable with a name chosen
|
|
|
|
|
by the user.
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
1999-07-07 20:19:36 +00:00
|
|
|
|
$digits Value history with index <digits>, starting
|
|
|
|
|
from the first value which has index 1.
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
1999-07-07 20:19:36 +00:00
|
|
|
|
$$digits Value history with index <digits> relative
|
2011-01-10 20:38:51 +00:00
|
|
|
|
to the last value. I.e. $$0 is the last
|
1999-07-07 20:19:36 +00:00
|
|
|
|
value, $$1 is the one previous to that, $$2
|
|
|
|
|
is the one previous to $$1, etc.
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
1999-07-07 20:19:36 +00:00
|
|
|
|
$ | $0 | $$0 The last value in the value history.
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
1999-07-07 20:19:36 +00:00
|
|
|
|
$$ An abbreviation for the second to the last
|
2011-01-10 20:38:51 +00:00
|
|
|
|
value in the value history, I.e. $$1 */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
void
|
2000-07-30 01:48:28 +00:00
|
|
|
|
write_dollar_variable (struct stoken str)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2004-11-13 02:27:41 +00:00
|
|
|
|
struct symbol *sym = NULL;
|
|
|
|
|
struct minimal_symbol *msym = NULL;
|
2007-10-01 01:39:52 +00:00
|
|
|
|
struct internalvar *isym = NULL;
|
2004-11-13 02:27:41 +00:00
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
/* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
|
2011-01-10 20:38:51 +00:00
|
|
|
|
and $$digits (equivalent to $<-digits> if you could type that). */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
int negate = 0;
|
|
|
|
|
int i = 1;
|
|
|
|
|
/* Double dollar means negate the number and add -1 as well.
|
|
|
|
|
Thus $$ alone means -1. */
|
|
|
|
|
if (str.length >= 2 && str.ptr[1] == '$')
|
|
|
|
|
{
|
|
|
|
|
negate = 1;
|
|
|
|
|
i = 2;
|
|
|
|
|
}
|
|
|
|
|
if (i == str.length)
|
|
|
|
|
{
|
2011-01-10 20:38:51 +00:00
|
|
|
|
/* Just dollars (one or two). */
|
1999-07-07 20:19:36 +00:00
|
|
|
|
i = -negate;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
goto handle_last;
|
|
|
|
|
}
|
|
|
|
|
/* Is the rest of the token digits? */
|
|
|
|
|
for (; i < str.length; i++)
|
|
|
|
|
if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9'))
|
|
|
|
|
break;
|
|
|
|
|
if (i == str.length)
|
|
|
|
|
{
|
|
|
|
|
i = atoi (str.ptr + 1 + negate);
|
|
|
|
|
if (negate)
|
1999-07-07 20:19:36 +00:00
|
|
|
|
i = -i;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
goto handle_last;
|
|
|
|
|
}
|
1999-07-07 20:19:36 +00:00
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
/* Handle tokens that refer to machine registers:
|
|
|
|
|
$ followed by a register name. */
|
2009-06-17 18:43:24 +00:00
|
|
|
|
i = user_reg_map_name_to_regnum (parse_gdbarch,
|
2008-08-21 20:13:08 +00:00
|
|
|
|
str.ptr + 1, str.length - 1);
|
1999-07-07 20:19:36 +00:00
|
|
|
|
if (i >= 0)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
goto handle_register;
|
|
|
|
|
|
2007-10-01 01:39:52 +00:00
|
|
|
|
/* Any names starting with $ are probably debugger internal variables. */
|
|
|
|
|
|
|
|
|
|
isym = lookup_only_internalvar (copy_name (str) + 1);
|
|
|
|
|
if (isym)
|
|
|
|
|
{
|
|
|
|
|
write_exp_elt_opcode (OP_INTERNALVAR);
|
|
|
|
|
write_exp_elt_intern (isym);
|
|
|
|
|
write_exp_elt_opcode (OP_INTERNALVAR);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2004-11-13 02:27:41 +00:00
|
|
|
|
/* On some systems, such as HP-UX and hppa-linux, certain system routines
|
2011-01-10 20:38:51 +00:00
|
|
|
|
have names beginning with $ or $$. Check for those, first. */
|
2004-11-13 02:27:41 +00:00
|
|
|
|
|
|
|
|
|
sym = lookup_symbol (copy_name (str), (struct block *) NULL,
|
* symtab.h (lookup_symbol_in_language): Remove SYMTAB parameter.
(lookup_symbol): Likewise.
* symtab.c (lookup_symbol_in_language): Remove SYMTAB parameter.
(lookup_symbol): Likewise.
(search_symbols): Update.
* linespec.c (find_methods, collect_methods): Update.
(add_matching_methods, add_constructors): Update.
(decode_compound, decode_dollar, decode_variable): Update.
(lookup_prefix_sym): Update.
(symbol_found): Remove SYM_SYMTAB parameter.
Use SYMBOL_SYMTAB (sym) instead.
* gdbtypes.c (lookup_typename): Update.
(lookup_struct, lookup_union, lookup_enum): Update.
(lookup_template_type): Update.
(check_typedef): Update.
* language.c (lang_bool_type): Update.
* mdebugread.c (parse_procedure): Update.
* mi/mi-cmd-stack.c (list_args_or_locals): Update.
* parse.c (write_dollar_variable): Update.
* printcmd.c (address_info): Update.
* source.c (select_source_symtab): Update.
* stack.c (print_frame_args, print_frame_arg_vars): Update.
* valops.c (find_function_in_inferior): Update.
(value_struct_elt_for_reference): Update.
* value.c (value_static_field, value_fn_field): Update.
* alpha-mdebug-tdep.c (find_proc_desc): Update.
* arm-tdep.c (arm_skip_prologue): Update.
* mt-tdep.c (mt_skip_prologue): Update.
* xstormy16-tdep.c (xstormy16_skip_prologue): Update.
* ada-lang.h (struct ada_symbol_info): Remove SYMTAB member.
* ada-lang.c (ada_add_block_symbols): Remove SYMTAB parameter.
(add_defn_to_vec): Likewise.
(ada_add_block_symbols): Likewise.
(lookup_cached_symbol, cache_symbol): Likewise.
(standard_lookup): Update.
(ada_lookup_symbol_list): Update.
* c-valprint.c (c_val_print): Update.
* cp-support.c (cp_lookup_rtti_type): Update.
* jv-lang.c (java_lookup_class, get_java_object_type): Update.
* objc-lang.c (lookup_struct_typedef, find_imps): Update.
* p-valprint.c (pascal_val_print): Update.
* scm-lang.c (scm_lookup_name): Update.
* c-exp.y: Update.
* f-exp.y: Update.
* jv-exp.y: Update.
* m2-exp.y: Update.
* objc-exp.y: Update.
* p-exp.y: Update.
2008-05-19 15:50:10 +00:00
|
|
|
|
VAR_DOMAIN, (int *) NULL);
|
2004-11-13 02:27:41 +00:00
|
|
|
|
if (sym)
|
|
|
|
|
{
|
|
|
|
|
write_exp_elt_opcode (OP_VAR_VALUE);
|
|
|
|
|
write_exp_elt_block (block_found); /* set by lookup_symbol */
|
|
|
|
|
write_exp_elt_sym (sym);
|
|
|
|
|
write_exp_elt_opcode (OP_VAR_VALUE);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
msym = lookup_minimal_symbol (copy_name (str), NULL, NULL);
|
|
|
|
|
if (msym)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2008-09-11 14:08:33 +00:00
|
|
|
|
write_exp_msymbol (msym);
|
2004-11-13 02:27:41 +00:00
|
|
|
|
return;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
1999-07-07 20:19:36 +00:00
|
|
|
|
|
2007-10-01 01:39:52 +00:00
|
|
|
|
/* Any other names are assumed to be debugger internal variables. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
write_exp_elt_opcode (OP_INTERNALVAR);
|
2007-10-01 01:39:52 +00:00
|
|
|
|
write_exp_elt_intern (create_internalvar (copy_name (str) + 1));
|
1999-07-07 20:19:36 +00:00
|
|
|
|
write_exp_elt_opcode (OP_INTERNALVAR);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
return;
|
1999-07-07 20:19:36 +00:00
|
|
|
|
handle_last:
|
1999-04-16 01:35:26 +00:00
|
|
|
|
write_exp_elt_opcode (OP_LAST);
|
|
|
|
|
write_exp_elt_longcst ((LONGEST) i);
|
|
|
|
|
write_exp_elt_opcode (OP_LAST);
|
|
|
|
|
return;
|
1999-07-07 20:19:36 +00:00
|
|
|
|
handle_register:
|
1999-04-16 01:35:26 +00:00
|
|
|
|
write_exp_elt_opcode (OP_REGISTER);
|
2007-06-13 17:11:09 +00:00
|
|
|
|
str.length--;
|
|
|
|
|
str.ptr++;
|
|
|
|
|
write_exp_string (str);
|
1999-07-07 20:19:36 +00:00
|
|
|
|
write_exp_elt_opcode (OP_REGISTER);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
char *
|
2000-07-30 01:48:28 +00:00
|
|
|
|
find_template_name_end (char *p)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
|
|
|
|
int depth = 1;
|
|
|
|
|
int just_seen_right = 0;
|
|
|
|
|
int just_seen_colon = 0;
|
|
|
|
|
int just_seen_space = 0;
|
1999-07-07 20:19:36 +00:00
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
if (!p || (*p != '<'))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
while (*++p)
|
|
|
|
|
{
|
|
|
|
|
switch (*p)
|
1999-07-07 20:19:36 +00:00
|
|
|
|
{
|
|
|
|
|
case '\'':
|
|
|
|
|
case '\"':
|
|
|
|
|
case '{':
|
|
|
|
|
case '}':
|
2011-01-10 20:38:51 +00:00
|
|
|
|
/* In future, may want to allow these?? */
|
1999-07-07 20:19:36 +00:00
|
|
|
|
return 0;
|
|
|
|
|
case '<':
|
|
|
|
|
depth++; /* start nested template */
|
|
|
|
|
if (just_seen_colon || just_seen_right || just_seen_space)
|
|
|
|
|
return 0; /* but not after : or :: or > or space */
|
|
|
|
|
break;
|
|
|
|
|
case '>':
|
|
|
|
|
if (just_seen_colon || just_seen_right)
|
|
|
|
|
return 0; /* end a (nested?) template */
|
|
|
|
|
just_seen_right = 1; /* but not after : or :: */
|
|
|
|
|
if (--depth == 0) /* also disallow >>, insist on > > */
|
|
|
|
|
return ++p; /* if outermost ended, return */
|
|
|
|
|
break;
|
|
|
|
|
case ':':
|
|
|
|
|
if (just_seen_space || (just_seen_colon > 1))
|
|
|
|
|
return 0; /* nested class spec coming up */
|
|
|
|
|
just_seen_colon++; /* we allow :: but not :::: */
|
|
|
|
|
break;
|
|
|
|
|
case ' ':
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */
|
|
|
|
|
(*p >= 'A' && *p <= 'Z') ||
|
|
|
|
|
(*p >= '0' && *p <= '9') ||
|
|
|
|
|
(*p == '_') || (*p == ',') || /* commas for template args */
|
|
|
|
|
(*p == '&') || (*p == '*') || /* pointer and ref types */
|
|
|
|
|
(*p == '(') || (*p == ')') || /* function types */
|
|
|
|
|
(*p == '[') || (*p == ']'))) /* array types */
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
1999-04-16 01:35:26 +00:00
|
|
|
|
if (*p != ' ')
|
1999-07-07 20:19:36 +00:00
|
|
|
|
just_seen_space = 0;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
if (*p != ':')
|
1999-07-07 20:19:36 +00:00
|
|
|
|
just_seen_colon = 0;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
if (*p != '>')
|
1999-07-07 20:19:36 +00:00
|
|
|
|
just_seen_right = 0;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
1999-07-07 20:19:36 +00:00
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
2012-01-09 17:27:20 +00:00
|
|
|
|
/* Return a null-terminated temporary copy of the name of a string token.
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
2012-01-09 17:27:20 +00:00
|
|
|
|
Tokens that refer to names do so with explicit pointer and length,
|
|
|
|
|
so they can share the storage that lexptr is parsing.
|
|
|
|
|
When it is necessary to pass a name to a function that expects
|
|
|
|
|
a null-terminated string, the substring is copied out
|
|
|
|
|
into a separate block of storage.
|
|
|
|
|
|
|
|
|
|
N.B. A single buffer is reused on each call. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
char *
|
2000-07-30 01:48:28 +00:00
|
|
|
|
copy_name (struct stoken token)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2012-01-09 17:27:20 +00:00
|
|
|
|
/* A temporary buffer for identifiers, so we can null-terminate them.
|
|
|
|
|
We allocate this with xrealloc. parse_exp_1 used to allocate with
|
|
|
|
|
alloca, using the size of the whole expression as a conservative
|
|
|
|
|
estimate of the space needed. However, macro expansion can
|
|
|
|
|
introduce names longer than the original expression; there's no
|
|
|
|
|
practical way to know beforehand how large that might be. */
|
|
|
|
|
static char *namecopy;
|
|
|
|
|
static size_t namecopy_size;
|
|
|
|
|
|
2005-04-29 00:04:06 +00:00
|
|
|
|
/* Make sure there's enough space for the token. */
|
|
|
|
|
if (namecopy_size < token.length + 1)
|
|
|
|
|
{
|
|
|
|
|
namecopy_size = token.length + 1;
|
|
|
|
|
namecopy = xrealloc (namecopy, token.length + 1);
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
memcpy (namecopy, token.ptr, token.length);
|
|
|
|
|
namecopy[token.length] = 0;
|
2005-04-29 00:04:06 +00:00
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
return namecopy;
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-27 20:47:57 +00:00
|
|
|
|
|
|
|
|
|
/* See comments on parser-defs.h. */
|
|
|
|
|
|
|
|
|
|
int
|
2003-09-09 08:05:43 +00:00
|
|
|
|
prefixify_expression (struct expression *expr)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2007-10-26 22:13:41 +00:00
|
|
|
|
int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts);
|
2003-09-09 08:05:43 +00:00
|
|
|
|
struct expression *temp;
|
|
|
|
|
int inpos = expr->nelts, outpos = 0;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
temp = (struct expression *) alloca (len);
|
|
|
|
|
|
|
|
|
|
/* Copy the original expression into temp. */
|
|
|
|
|
memcpy (temp, expr, len);
|
|
|
|
|
|
2008-06-06 20:58:08 +00:00
|
|
|
|
return prefixify_subexp (temp, expr, inpos, outpos);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
2003-09-24 08:29:42 +00:00
|
|
|
|
/* Return the number of exp_elements in the postfix subexpression
|
|
|
|
|
of EXPR whose operator is at index ENDPOS - 1 in EXPR. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
int
|
2003-09-09 08:05:43 +00:00
|
|
|
|
length_of_subexp (struct expression *expr, int endpos)
|
2003-09-24 08:29:42 +00:00
|
|
|
|
{
|
2010-05-06 22:29:49 +00:00
|
|
|
|
int oplen, args;
|
2003-09-24 08:29:42 +00:00
|
|
|
|
|
|
|
|
|
operator_length (expr, endpos, &oplen, &args);
|
|
|
|
|
|
|
|
|
|
while (args > 0)
|
|
|
|
|
{
|
|
|
|
|
oplen += length_of_subexp (expr, endpos - oplen);
|
|
|
|
|
args--;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return oplen;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Sets *OPLENP to the length of the operator whose (last) index is
|
|
|
|
|
ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that
|
|
|
|
|
operator takes. */
|
|
|
|
|
|
|
|
|
|
void
|
2010-06-04 21:39:47 +00:00
|
|
|
|
operator_length (const struct expression *expr, int endpos, int *oplenp,
|
|
|
|
|
int *argsp)
|
* parser-defs.h (struct exp_descriptor): New definition, containing
language-specific info for printing, prefixifying, dumping, and
evaluating expressions.
(exp_descriptor_standard): Declare new variable.
(print_subexp): Make global and declare here (from expprint.c).
(dump_subexp): Ditto.
(dump_subexp_body_standard): Declare.
(operator_length_standard): Declare.
(op_name_standard): Declare.
(print_subexp): Declare.
(print_subexp_standard): Declare.
* language.h (struct language_defn): Add la_exp_desc field to hold
pointer to table for language-specific operators.
Remove evaluate_exp field, which is now in struct exp_descriptor.
* parse.c (operator_length): Move most code to new
operator_length_standard function. Use language-specific information.
(operator_length_standard): New function taking most code from
operator_length.
(exp_descriptor_standard): New constant.
* expression.h (enum exp_opcode): Add definitions of OP_EXTENDED0
and OP_EXTENDED_LAST.
* expprint.c (print_subexp): Use language-specific print_subexp.
Make global; remove static declaration.
Move most code to print_subexp_standard.
(print_subexp_standard): New function, containing code formerly in
print_subexp.
(op_name): Add expression to argument signature.
Use langauge-specific op_name.
Move most code to op_name_standard.
(op_name_standard): New function, containing code formerly in op_name.
(dump_subexp): Use new version of op_name function.
Use language-specific dump_subexp_body, and move most existing code to
dump_subexp_body_standard.
(dump_raw_expression): Use new op_name interface.
(dump_subexp_body): Move most code to dump_subexp_body_standard.
(dump_subexp_body_standard): New function, containing code formerly
in dump_subexp_body.
* language.c (unknown_language): Add default la_exp_desc field and
remove evaluate_exp field.
(auto_language): Ditto.
(local_language): Ditto.
* f-lang.c (f_language_defn): Ditto.
* c-lang.c (c_language_defn): Ditto.
(cplus_language_defn): Ditto.
(asm_language_defn): Ditto.
(minimal_language_defn): Ditto.
* p-lang.c (pascal_language_defn): Ditto.
* m2-lang.c (m2_language_defn): Ditto.
* objc-lang.c (objc_language_defn): Ditto.
* jv-lang.c (exp_descriptor_java): New variable, containing
Java-specific expression evaluator.
(java_language_defn): Add la_exp_desc field and remove evaluate_exp
field.
* scm-lang.c (exp_descriptor_scm): New variable, containing
Scheme-specific expression evaluator.
(scm_language_defn): Add la_exp_desc field and remove evaluate_exp
field.
* objc-lang.c (print_object_command): Take evaluate_exp from the
la_exp_desc field.
* Makefile.in (eval.o): Add dependency on parser-defs.h.
* eval.c: Include parser-defs.h for the full declaration of
la_exp_desc's type.
(evaluate_subexp): Get evaluate_exp out of la_exp_desc field.
2003-09-25 08:40:45 +00:00
|
|
|
|
{
|
|
|
|
|
expr->language_defn->la_exp_desc->operator_length (expr, endpos,
|
|
|
|
|
oplenp, argsp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Default value for operator_length in exp_descriptor vectors. */
|
|
|
|
|
|
|
|
|
|
void
|
2010-06-04 21:39:47 +00:00
|
|
|
|
operator_length_standard (const struct expression *expr, int endpos,
|
* parser-defs.h (struct exp_descriptor): New definition, containing
language-specific info for printing, prefixifying, dumping, and
evaluating expressions.
(exp_descriptor_standard): Declare new variable.
(print_subexp): Make global and declare here (from expprint.c).
(dump_subexp): Ditto.
(dump_subexp_body_standard): Declare.
(operator_length_standard): Declare.
(op_name_standard): Declare.
(print_subexp): Declare.
(print_subexp_standard): Declare.
* language.h (struct language_defn): Add la_exp_desc field to hold
pointer to table for language-specific operators.
Remove evaluate_exp field, which is now in struct exp_descriptor.
* parse.c (operator_length): Move most code to new
operator_length_standard function. Use language-specific information.
(operator_length_standard): New function taking most code from
operator_length.
(exp_descriptor_standard): New constant.
* expression.h (enum exp_opcode): Add definitions of OP_EXTENDED0
and OP_EXTENDED_LAST.
* expprint.c (print_subexp): Use language-specific print_subexp.
Make global; remove static declaration.
Move most code to print_subexp_standard.
(print_subexp_standard): New function, containing code formerly in
print_subexp.
(op_name): Add expression to argument signature.
Use langauge-specific op_name.
Move most code to op_name_standard.
(op_name_standard): New function, containing code formerly in op_name.
(dump_subexp): Use new version of op_name function.
Use language-specific dump_subexp_body, and move most existing code to
dump_subexp_body_standard.
(dump_raw_expression): Use new op_name interface.
(dump_subexp_body): Move most code to dump_subexp_body_standard.
(dump_subexp_body_standard): New function, containing code formerly
in dump_subexp_body.
* language.c (unknown_language): Add default la_exp_desc field and
remove evaluate_exp field.
(auto_language): Ditto.
(local_language): Ditto.
* f-lang.c (f_language_defn): Ditto.
* c-lang.c (c_language_defn): Ditto.
(cplus_language_defn): Ditto.
(asm_language_defn): Ditto.
(minimal_language_defn): Ditto.
* p-lang.c (pascal_language_defn): Ditto.
* m2-lang.c (m2_language_defn): Ditto.
* objc-lang.c (objc_language_defn): Ditto.
* jv-lang.c (exp_descriptor_java): New variable, containing
Java-specific expression evaluator.
(java_language_defn): Add la_exp_desc field and remove evaluate_exp
field.
* scm-lang.c (exp_descriptor_scm): New variable, containing
Scheme-specific expression evaluator.
(scm_language_defn): Add la_exp_desc field and remove evaluate_exp
field.
* objc-lang.c (print_object_command): Take evaluate_exp from the
la_exp_desc field.
* Makefile.in (eval.o): Add dependency on parser-defs.h.
* eval.c: Include parser-defs.h for the full declaration of
la_exp_desc's type.
(evaluate_subexp): Get evaluate_exp out of la_exp_desc field.
2003-09-25 08:40:45 +00:00
|
|
|
|
int *oplenp, int *argsp)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2003-09-09 08:05:43 +00:00
|
|
|
|
int oplen = 1;
|
|
|
|
|
int args = 0;
|
2005-09-20 06:25:34 +00:00
|
|
|
|
enum f90_range_type range_type;
|
2003-09-09 08:05:43 +00:00
|
|
|
|
int i;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
if (endpos < 1)
|
2005-02-10 Andrew Cagney <cagney@gnu.org>
Mark up all error and warning messages.
* ada-lang.c, amd64-tdep.c, arch-utils.c, breakpoint.c: Update.
* bsd-kvm.c, bsd-uthread.c, coff-solib.h, coffread.c: Update.
* core-aout.c, core-regset.c, corefile.c, corelow.c: Update.
* cp-abi.c, cp-support.c, cp-valprint.c, cris-tdep.c: Update.
* dbxread.c, demangle.c, doublest.c, dsrec.c: Update.
* dve3900-rom.c, dwarf2expr.c, dwarf2loc.c: Update.
* dwarf2read.c, dwarfread.c, elfread.c, eval.c: Update.
* event-top.c, exec.c, expprint.c, f-lang.c: Update.
* f-typeprint.c, f-valprint.c, fbsd-nat.c, findvar.c: Update.
* frame.c, frv-linux-tdep.c, gcore.c, gdbtypes.c: Update.
* gnu-nat.c, gnu-v2-abi.c, gnu-v3-abi.c, go32-nat.c: Update.
* hpacc-abi.c, hppa-hpux-nat.c, hppa-hpux-tdep.c: Update.
* hppa-linux-nat.c, hppa-linux-tdep.c, hppa-tdep.c: Update.
* hpread.c, hpux-thread.c, i386-linux-nat.c: Update.
* i386-linux-tdep.c, i386-tdep.c, i386bsd-nat.c: Update.
* i386gnu-nat.c, i387-tdep.c, ia64-linux-nat.c: Update.
* ia64-tdep.c, inf-child.c, inf-ptrace.c, inf-ttrace.c: Update.
* infcall.c, infcmd.c, inflow.c, infptrace.c, infrun.c: Update.
* inftarg.c, interps.c, irix5-nat.c, jv-lang.c: Update.
* kod-cisco.c, kod.c, language.c, libunwind-frame.c: Update.
* linespec.c, linux-nat.c, linux-thread-db.c, m2-lang.c: Update.
* m32r-rom.c, m68hc11-tdep.c, m68k-tdep.c: Update.
* m68klinux-nat.c, macrocmd.c, macroexp.c, main.c: Update.
* maint.c, mdebugread.c, mem-break.c, memattr.c: Update.
* mips-linux-tdep.c, mips-tdep.c, mipsread.c, monitor.c: Update.
* nlmread.c, nto-procfs.c, objc-lang.c, objfiles.c: Update.
* observer.c, ocd.c, p-lang.c, p-typeprint.c: Update.
* p-valprint.c, pa64solib.c, parse.c, ppc-linux-tdep.c: Update.
* ppcnbsd-tdep.c, printcmd.c, procfs.c, remote-e7000.c: Update.
* remote-fileio.c, remote-m32r-sdi.c, remote-rdi.c: Update.
* remote-rdp.c, remote-sim.c, remote-st.c: Update.
* remote-utils.c, remote-utils.h, remote.c: Update.
* rom68k-rom.c, rs6000-nat.c, s390-tdep.c, scm-lang.c: Update.
* ser-e7kpc.c, ser-tcp.c, ser-unix.c, sh-tdep.c: Update.
* sh3-rom.c, shnbsd-tdep.c, sol-thread.c, solib-aix5.c: Update.
* solib-frv.c, solib-irix.c, solib-osf.c, solib-pa64.c: Update.
* solib-som.c, solib-sunos.c, solib-svr4.c, solib.c: Update.
* somread.c, somsolib.c, source.c, stabsread.c: Update.
* stack.c, std-regs.c, symfile-mem.c, symfile.c: Update.
* symmisc.c, symtab.c, target.c, thread.c, top.c: Update.
* tracepoint.c, trad-frame.c, typeprint.c, utils.c: Update.
* uw-thread.c, valarith.c, valops.c, valprint.c: Update.
* value.c, varobj.c, version.in, win32-nat.c, wince.c: Update.
* xcoffread.c, xcoffsolib.c, cli/cli-cmds.c: Update.
* cli/cli-decode.c, cli/cli-dump.c, cli/cli-logging.c: Update.
* cli/cli-script.c, cli/cli-setshow.c, mi/mi-cmd-break.c: Update.
* mi/mi-cmd-disas.c, mi/mi-cmd-env.c, mi/mi-cmd-file.c: Update.
* mi/mi-cmd-stack.c, mi/mi-cmd-var.c, mi/mi-getopt.c: Update.
* mi/mi-symbol-cmds.c, tui/tui-layout.c, tui/tui-stack.c: Update.
* tui/tui-win.c: Update.
2005-02-11 04:06:14 +00:00
|
|
|
|
error (_("?error in operator_length_standard"));
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
i = (int) expr->elts[endpos - 1].opcode;
|
|
|
|
|
|
|
|
|
|
switch (i)
|
|
|
|
|
{
|
|
|
|
|
/* C++ */
|
|
|
|
|
case OP_SCOPE:
|
|
|
|
|
oplen = longest_to_int (expr->elts[endpos - 2].longconst);
|
|
|
|
|
oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OP_LONG:
|
|
|
|
|
case OP_DOUBLE:
|
2007-10-25 18:01:58 +00:00
|
|
|
|
case OP_DECFLOAT:
|
1999-04-16 01:35:26 +00:00
|
|
|
|
case OP_VAR_VALUE:
|
|
|
|
|
oplen = 4;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OP_TYPE:
|
|
|
|
|
case OP_BOOL:
|
|
|
|
|
case OP_LAST:
|
|
|
|
|
case OP_INTERNALVAR:
|
2011-10-09 19:41:17 +00:00
|
|
|
|
case OP_VAR_ENTRY_VALUE:
|
1999-04-16 01:35:26 +00:00
|
|
|
|
oplen = 3;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OP_COMPLEX:
|
2008-09-11 14:12:15 +00:00
|
|
|
|
oplen = 3;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
args = 2;
|
1999-07-07 20:19:36 +00:00
|
|
|
|
break;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
case OP_FUNCALL:
|
|
|
|
|
case OP_F77_UNDETERMINED_ARGLIST:
|
|
|
|
|
oplen = 3;
|
|
|
|
|
args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
|
|
|
|
|
break;
|
|
|
|
|
|
2009-11-10 22:17:58 +00:00
|
|
|
|
case TYPE_INSTANCE:
|
|
|
|
|
oplen = 4 + longest_to_int (expr->elts[endpos - 2].longconst);
|
|
|
|
|
args = 1;
|
|
|
|
|
break;
|
|
|
|
|
|
2011-01-10 20:38:51 +00:00
|
|
|
|
case OP_OBJC_MSGCALL: /* Objective C message (method) call. */
|
2002-10-14 01:50:44 +00:00
|
|
|
|
oplen = 4;
|
|
|
|
|
args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
|
|
|
|
|
break;
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
case UNOP_MAX:
|
|
|
|
|
case UNOP_MIN:
|
|
|
|
|
oplen = 3;
|
|
|
|
|
break;
|
|
|
|
|
|
* ax-gdb.c (gen_expr): Handle UNOP_CAST_TYPE, UNOP_MEMVAL_TYPE.
* breakpoint.c (watchpoint_exp_is_const): Handle UNOP_CAST_TYPE,
UNOP_REINTERPRET_CAST, UNOP_DYNAMIC_CAST.
* c-exp.y (exp): Emit UNOP_MEMVAL_TYPE, UNOP_CAST_TYPE. Update
for changes to UNOP_REINTERPRET_CAST, UNOP_DYNAMIC_CAST. Use
type_exp production where appropriate.
* eval.c (evaluate_subexp_standard) <UNOP_CAST_TYPE>: New case.
<UNOP_DYNAMIC_CAST, UNOP_REINTERPRET_CAST>: Update.
<UNOP_MEMVAL_TYPE>: New case.
(evaluate_subexp_for_address) <UNOP_MEMVAL_TYPE>: New case.
(evaluate_subexp_for_sizeof) <UNOP_MEMVAL_TYPE>: New case.
* expprint.c (print_subexp_standard) <UNOP_CAST_TYPE>: New case.
<UNOP_MEMVAL_TYPE>: New case.
(dump_subexp_body_standard) <UNOP_DYNAMIC_CAST,
UNOP_REINTERPRET_CAST>: Update.
<UNOP_CAST_TYPE, UNOP_MEMVAL_TYPE>: New cases.
* parse.c (operator_length_standard) <UNOP_DYNAMIC_CAST,
UNOP_REINTERPRET_CAST>: Update.
<UNOP_CAST_TYPE, UNOP_MEMVAL_TYPE>: New cases.
* stack.c (return_command): Also check for UNOP_CAST_TYPE.
* std-operator.def (UNOP_CAST_TYPE, UNOP_MEMVAL_TYPE): New
constants.
2012-07-19 15:33:25 +00:00
|
|
|
|
case UNOP_CAST_TYPE:
|
2010-01-18 20:54:35 +00:00
|
|
|
|
case UNOP_DYNAMIC_CAST:
|
|
|
|
|
case UNOP_REINTERPRET_CAST:
|
* ax-gdb.c (gen_expr): Handle UNOP_CAST_TYPE, UNOP_MEMVAL_TYPE.
* breakpoint.c (watchpoint_exp_is_const): Handle UNOP_CAST_TYPE,
UNOP_REINTERPRET_CAST, UNOP_DYNAMIC_CAST.
* c-exp.y (exp): Emit UNOP_MEMVAL_TYPE, UNOP_CAST_TYPE. Update
for changes to UNOP_REINTERPRET_CAST, UNOP_DYNAMIC_CAST. Use
type_exp production where appropriate.
* eval.c (evaluate_subexp_standard) <UNOP_CAST_TYPE>: New case.
<UNOP_DYNAMIC_CAST, UNOP_REINTERPRET_CAST>: Update.
<UNOP_MEMVAL_TYPE>: New case.
(evaluate_subexp_for_address) <UNOP_MEMVAL_TYPE>: New case.
(evaluate_subexp_for_sizeof) <UNOP_MEMVAL_TYPE>: New case.
* expprint.c (print_subexp_standard) <UNOP_CAST_TYPE>: New case.
<UNOP_MEMVAL_TYPE>: New case.
(dump_subexp_body_standard) <UNOP_DYNAMIC_CAST,
UNOP_REINTERPRET_CAST>: Update.
<UNOP_CAST_TYPE, UNOP_MEMVAL_TYPE>: New cases.
* parse.c (operator_length_standard) <UNOP_DYNAMIC_CAST,
UNOP_REINTERPRET_CAST>: Update.
<UNOP_CAST_TYPE, UNOP_MEMVAL_TYPE>: New cases.
* stack.c (return_command): Also check for UNOP_CAST_TYPE.
* std-operator.def (UNOP_CAST_TYPE, UNOP_MEMVAL_TYPE): New
constants.
2012-07-19 15:33:25 +00:00
|
|
|
|
case UNOP_MEMVAL_TYPE:
|
|
|
|
|
oplen = 1;
|
|
|
|
|
args = 2;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BINOP_VAL:
|
|
|
|
|
case UNOP_CAST:
|
1999-07-07 20:19:36 +00:00
|
|
|
|
case UNOP_MEMVAL:
|
1999-04-16 01:35:26 +00:00
|
|
|
|
oplen = 3;
|
|
|
|
|
args = 1;
|
|
|
|
|
break;
|
|
|
|
|
|
2006-10-10 03:17:53 +00:00
|
|
|
|
case UNOP_MEMVAL_TLS:
|
|
|
|
|
oplen = 4;
|
|
|
|
|
args = 1;
|
|
|
|
|
break;
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
case UNOP_ABS:
|
|
|
|
|
case UNOP_CAP:
|
|
|
|
|
case UNOP_CHR:
|
|
|
|
|
case UNOP_FLOAT:
|
|
|
|
|
case UNOP_HIGH:
|
|
|
|
|
case UNOP_ODD:
|
|
|
|
|
case UNOP_ORD:
|
|
|
|
|
case UNOP_TRUNC:
|
PR exp/13206:
* ax-gdb.c (gen_expr) <OP_TYPEOF, OP_DECLTYPE>: New cases.
* breakpoint.c (watchpoint_exp_is_const) <OP_TYPEOF,
OP_DECLTYPE>: New cases.
* c-exp.y (TYPEOF, DECLTYPE): New tokens.
(type_exp): Add new productions.
(ident_tokens): Add __typeof__, typeof, __typeof, __decltype,
and decltype.
* eval.c (evaluate_subexp_standard) <OP_TYPEOF, OP_DECLTYPE>:
New case.
* expprint.c (dump_subexp_body_standard) <OP_TYPEOF,
OP_DECLTYPE>: New case.
* parse.c (operator_length_standard) <OP_TYPEOF, OP_DECLTYPE>:
New case.
* std-operator.def (OP_TYPEOF, OP_DECLTYPE): New constants.
* varobj.c (varobj_create): Handle OP_TYPEOF, OP_DECLTYPE.
gdb/testsuite
* gdb.cp/casts.exp: Add tests for typeof and decltype.
* gdb.cp/casts.cc (decltype): New function.
(main): Use it.
2012-07-19 15:38:18 +00:00
|
|
|
|
case OP_TYPEOF:
|
|
|
|
|
case OP_DECLTYPE:
|
1999-04-16 01:35:26 +00:00
|
|
|
|
oplen = 1;
|
|
|
|
|
args = 1;
|
|
|
|
|
break;
|
|
|
|
|
|
2010-05-07 14:46:28 +00:00
|
|
|
|
case OP_ADL_FUNC:
|
|
|
|
|
oplen = longest_to_int (expr->elts[endpos - 2].longconst);
|
|
|
|
|
oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
|
|
|
|
|
oplen++;
|
|
|
|
|
oplen++;
|
|
|
|
|
break;
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
case STRUCTOP_STRUCT:
|
|
|
|
|
case STRUCTOP_PTR:
|
|
|
|
|
args = 1;
|
|
|
|
|
/* fall through */
|
2007-06-13 17:11:09 +00:00
|
|
|
|
case OP_REGISTER:
|
1999-04-16 01:35:26 +00:00
|
|
|
|
case OP_M2_STRING:
|
|
|
|
|
case OP_STRING:
|
2011-01-05 22:22:53 +00:00
|
|
|
|
case OP_OBJC_NSSTRING: /* Objective C Foundation Class
|
2011-01-10 20:38:51 +00:00
|
|
|
|
NSString constant. */
|
|
|
|
|
case OP_OBJC_SELECTOR: /* Objective C "@selector" pseudo-op. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
case OP_NAME:
|
|
|
|
|
oplen = longest_to_int (expr->elts[endpos - 2].longconst);
|
|
|
|
|
oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OP_ARRAY:
|
|
|
|
|
oplen = 4;
|
|
|
|
|
args = longest_to_int (expr->elts[endpos - 2].longconst);
|
|
|
|
|
args -= longest_to_int (expr->elts[endpos - 3].longconst);
|
|
|
|
|
args += 1;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TERNOP_COND:
|
|
|
|
|
case TERNOP_SLICE:
|
|
|
|
|
args = 3;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Modula-2 */
|
1999-07-07 20:19:36 +00:00
|
|
|
|
case MULTI_SUBSCRIPT:
|
1999-04-16 01:35:26 +00:00
|
|
|
|
oplen = 3;
|
1999-07-07 20:19:36 +00:00
|
|
|
|
args = 1 + longest_to_int (expr->elts[endpos - 2].longconst);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case BINOP_ASSIGN_MODIFY:
|
|
|
|
|
oplen = 3;
|
|
|
|
|
args = 2;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* C++ */
|
|
|
|
|
case OP_THIS:
|
|
|
|
|
oplen = 2;
|
|
|
|
|
break;
|
|
|
|
|
|
2005-09-20 06:25:34 +00:00
|
|
|
|
case OP_F90_RANGE:
|
|
|
|
|
oplen = 3;
|
|
|
|
|
|
|
|
|
|
range_type = longest_to_int (expr->elts[endpos - 2].longconst);
|
|
|
|
|
switch (range_type)
|
|
|
|
|
{
|
|
|
|
|
case LOW_BOUND_DEFAULT:
|
|
|
|
|
case HIGH_BOUND_DEFAULT:
|
|
|
|
|
args = 1;
|
|
|
|
|
break;
|
|
|
|
|
case BOTH_BOUND_DEFAULT:
|
|
|
|
|
args = 0;
|
|
|
|
|
break;
|
|
|
|
|
case NONE_BOUND_DEFAULT:
|
|
|
|
|
args = 2;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
default:
|
|
|
|
|
args = 1 + (i < (int) BINOP_END);
|
|
|
|
|
}
|
|
|
|
|
|
2003-09-24 08:29:42 +00:00
|
|
|
|
*oplenp = oplen;
|
|
|
|
|
*argsp = args;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Copy the subexpression ending just before index INEND in INEXPR
|
|
|
|
|
into OUTEXPR, starting at index OUTBEG.
|
2008-06-06 20:58:08 +00:00
|
|
|
|
In the process, convert it from suffix to prefix form.
|
|
|
|
|
If EXPOUT_LAST_STRUCT is -1, then this function always returns -1.
|
|
|
|
|
Otherwise, it returns the index of the subexpression which is the
|
|
|
|
|
left-hand-side of the expression at EXPOUT_LAST_STRUCT. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
2008-06-06 20:58:08 +00:00
|
|
|
|
static int
|
2003-09-09 08:05:43 +00:00
|
|
|
|
prefixify_subexp (struct expression *inexpr,
|
|
|
|
|
struct expression *outexpr, int inend, int outbeg)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2003-09-24 08:29:42 +00:00
|
|
|
|
int oplen;
|
|
|
|
|
int args;
|
2003-09-09 08:05:43 +00:00
|
|
|
|
int i;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
int *arglens;
|
2008-06-06 20:58:08 +00:00
|
|
|
|
int result = -1;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
2003-09-24 08:29:42 +00:00
|
|
|
|
operator_length (inexpr, inend, &oplen, &args);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
/* Copy the final operator itself, from the end of the input
|
|
|
|
|
to the beginning of the output. */
|
|
|
|
|
inend -= oplen;
|
|
|
|
|
memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend],
|
|
|
|
|
EXP_ELEM_TO_BYTES (oplen));
|
|
|
|
|
outbeg += oplen;
|
|
|
|
|
|
2008-06-06 20:58:08 +00:00
|
|
|
|
if (expout_last_struct == inend)
|
|
|
|
|
result = outbeg - oplen;
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
/* Find the lengths of the arg subexpressions. */
|
|
|
|
|
arglens = (int *) alloca (args * sizeof (int));
|
|
|
|
|
for (i = args - 1; i >= 0; i--)
|
|
|
|
|
{
|
|
|
|
|
oplen = length_of_subexp (inexpr, inend);
|
|
|
|
|
arglens[i] = oplen;
|
|
|
|
|
inend -= oplen;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Now copy each subexpression, preserving the order of
|
|
|
|
|
the subexpressions, but prefixifying each one.
|
|
|
|
|
In this loop, inend starts at the beginning of
|
|
|
|
|
the expression this level is working on
|
|
|
|
|
and marches forward over the arguments.
|
|
|
|
|
outbeg does similarly in the output. */
|
|
|
|
|
for (i = 0; i < args; i++)
|
|
|
|
|
{
|
2008-06-06 20:58:08 +00:00
|
|
|
|
int r;
|
2010-05-16 01:27:02 +00:00
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
oplen = arglens[i];
|
|
|
|
|
inend += oplen;
|
2008-06-06 20:58:08 +00:00
|
|
|
|
r = prefixify_subexp (inexpr, outexpr, inend, outbeg);
|
|
|
|
|
if (r != -1)
|
|
|
|
|
{
|
|
|
|
|
/* Return immediately. We probably have only parsed a
|
|
|
|
|
partial expression, so we don't want to try to reverse
|
|
|
|
|
the other operands. */
|
|
|
|
|
return r;
|
|
|
|
|
}
|
1999-04-16 01:35:26 +00:00
|
|
|
|
outbeg += oplen;
|
|
|
|
|
}
|
2008-06-06 20:58:08 +00:00
|
|
|
|
|
|
|
|
|
return result;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Read an expression from the string *STRINGPTR points to,
|
2011-09-16 14:36:55 +00:00
|
|
|
|
parse it, and return a pointer to a struct expression that we malloc.
|
1999-04-16 01:35:26 +00:00
|
|
|
|
Use block BLOCK as the lexical context for variable names;
|
|
|
|
|
if BLOCK is zero, use the block of the selected stack frame.
|
|
|
|
|
Meanwhile, advance *STRINGPTR to point after the expression,
|
|
|
|
|
at the first nonwhite character that is not part of the expression
|
|
|
|
|
(possibly a null character).
|
|
|
|
|
|
|
|
|
|
If COMMA is nonzero, stop if a comma is reached. */
|
|
|
|
|
|
|
|
|
|
struct expression *
|
2012-06-27 18:08:41 +00:00
|
|
|
|
parse_exp_1 (char **stringptr, CORE_ADDR pc, struct block *block, int comma)
|
2004-04-10 22:10:01 +00:00
|
|
|
|
{
|
2012-06-27 18:08:41 +00:00
|
|
|
|
return parse_exp_in_context (stringptr, pc, block, comma, 0, NULL);
|
2004-04-10 22:10:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* As for parse_exp_1, except that if VOID_CONTEXT_P, then
|
2008-06-06 20:58:08 +00:00
|
|
|
|
no value is expected from the expression.
|
|
|
|
|
OUT_SUBEXP is set when attempting to complete a field name; in this
|
|
|
|
|
case it is set to the index of the subexpression on the
|
|
|
|
|
left-hand-side of the struct op. If not doing such completion, it
|
|
|
|
|
is left untouched. */
|
2004-04-10 22:10:01 +00:00
|
|
|
|
|
|
|
|
|
static struct expression *
|
2012-06-27 18:08:41 +00:00
|
|
|
|
parse_exp_in_context (char **stringptr, CORE_ADDR pc, struct block *block,
|
|
|
|
|
int comma, int void_context_p, int *out_subexp)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2008-06-06 20:58:08 +00:00
|
|
|
|
volatile struct gdb_exception except;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
struct cleanup *old_chain;
|
2010-05-17 17:23:33 +00:00
|
|
|
|
const struct language_defn *lang = NULL;
|
2008-06-06 20:58:08 +00:00
|
|
|
|
int subexp;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
lexptr = *stringptr;
|
2002-04-24 22:26:32 +00:00
|
|
|
|
prev_lexptr = NULL;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
paren_depth = 0;
|
* parser-defs.h (type_stack, type_stack_size, type_stack_depth):
Remove.
(struct type_stack): New.
* parse.c (type_stack, type_stack_size, type_stack_depth):
Remove.
(type_stack): New global.
(parse_exp_in_context, check_type_stack_depth)
(insert_into_type_stack, insert_type, push_type, push_type_int)
(insert_type_address_space, pop_type, pop_type_int)
(_initialize_parse): Update.
2012-07-06 14:42:09 +00:00
|
|
|
|
type_stack.depth = 0;
|
2008-06-06 20:58:08 +00:00
|
|
|
|
expout_last_struct = -1;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
comma_terminates = comma;
|
|
|
|
|
|
|
|
|
|
if (lexptr == 0 || *lexptr == 0)
|
2005-02-11 Andrew Cagney <cagney@gnu.org>
Mark up error_no_arg, query, perror_with_name, complaint, and
internal_error.
* breakpoint.c, cp-abi.c, cp-namespace.c, cp-support.c: Update.
* cris-tdep.c, dbxread.c, dictionary.c, dsrec.c: Update.
* dummy-frame.c, dve3900-rom.c, dwarf2-frame.c, dwarf2expr.c: Update.
* dwarf2read.c, dwarfread.c, elfread.c, event-loop.c: Update.
* exceptions.c, exec.c, f-lang.c, findvar.c, fork-child.c: Update.
* frame-unwind.c, frame.c, frv-linux-tdep.c, frv-tdep.c: Update.
* gdb_assert.h, gdbarch.c, gdbtypes.c, gnu-nat.c: Update.
* go32-nat.c, hppa-tdep.c, hppabsd-nat.c, hpread.c: Update.
* i386-linux-nat.c, i386-nat.c, i386-tdep.c, i386bsd-nat.c: Update.
* i386fbsd-nat.c, inf-ptrace.c, inf-ttrace.c, infcall.c: Update.
* infcmd.c, inflow.c, infptrace.c, infrun.c, inftarg.c: Update.
* interps.c, language.c, linespec.c, linux-nat.c: Update.
* m32r-linux-nat.c, m68k-tdep.c, m68kbsd-nat.c: Update.
* m68klinux-nat.c, m88kbsd-nat.c, macroexp.c, macroscope.c: Update.
* macrotab.c, maint.c, mdebugread.c, memattr.c: Update.
* mips-linux-tdep.c, mips-tdep.c, mips64obsd-nat.c: Update.
* mipsnbsd-nat.c, mn10300-tdep.c, monitor.c, nto-procfs.c: Update.
* objc-lang.c, objfiles.c, objfiles.h, ocd.c, osabi.c: Update.
* parse.c, ppc-bdm.c, ppc-linux-nat.c, ppc-sysv-tdep.c: Update.
* ppcnbsd-nat.c, ppcobsd-nat.c, printcmd.c, procfs.c: Update.
* regcache.c, reggroups.c, remote-e7000.c, remote-mips.c: Update.
* remote-rdp.c, remote-sds.c, remote-sim.c, remote-st.c: Update.
* remote-utils.c, remote.c, rs6000-nat.c, rs6000-tdep.c: Update.
* s390-nat.c, s390-tdep.c, sentinel-frame.c, serial.c: Update.
* sh-tdep.c, sh3-rom.c, sh64-tdep.c, shnbsd-nat.c: Update.
* solib-aix5.c, solib-svr4.c, solib.c, source.c: Update.
* sparc-nat.c, stabsread.c, stack.c, symfile.c, symtab.c: Update.
* symtab.h, target.c, tracepoint.c, ui-file.c, ui-out.c: Update.
* utils.c, valops.c, valprint.c, vax-nat.c, vaxbsd-nat.c: Update.
* win32-nat.c, xcoffread.c, xstormy16-tdep.c: Update.
* cli/cli-cmds.c, cli/cli-logging.c, cli/cli-script.c: Update.
* cli/cli-setshow.c, mi/mi-cmd-break.c, mi/mi-cmds.c: Update.
* mi/mi-console.c, mi/mi-getopt.c, mi/mi-out.c: Update.
* tui/tui-file.c, tui/tui-interp.c: Update.
2005-02-11 18:13:55 +00:00
|
|
|
|
error_no_arg (_("expression to compute"));
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
2000-05-22 09:02:23 +00:00
|
|
|
|
old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
funcall_chain = 0;
|
|
|
|
|
|
2008-05-03 22:30:51 +00:00
|
|
|
|
expression_context_block = block;
|
2006-01-24 15:20:10 +00:00
|
|
|
|
|
2008-05-03 22:30:51 +00:00
|
|
|
|
/* If no context specified, try using the current frame, if any. */
|
|
|
|
|
if (!expression_context_block)
|
|
|
|
|
expression_context_block = get_selected_block (&expression_context_pc);
|
2012-06-27 18:08:41 +00:00
|
|
|
|
else if (pc == 0)
|
2008-05-03 22:30:51 +00:00
|
|
|
|
expression_context_pc = BLOCK_START (expression_context_block);
|
2012-06-27 18:08:41 +00:00
|
|
|
|
else
|
|
|
|
|
expression_context_pc = pc;
|
2006-01-24 15:20:10 +00:00
|
|
|
|
|
2008-05-03 22:30:51 +00:00
|
|
|
|
/* Fall back to using the current source static context, if any. */
|
2006-01-24 15:20:10 +00:00
|
|
|
|
|
2008-05-03 22:30:51 +00:00
|
|
|
|
if (!expression_context_block)
|
2006-01-24 15:20:10 +00:00
|
|
|
|
{
|
|
|
|
|
struct symtab_and_line cursal = get_current_source_symtab_and_line ();
|
|
|
|
|
if (cursal.symtab)
|
2008-05-03 22:30:51 +00:00
|
|
|
|
expression_context_block
|
|
|
|
|
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK);
|
|
|
|
|
if (expression_context_block)
|
|
|
|
|
expression_context_pc = BLOCK_START (expression_context_block);
|
Expand preprocessor macros in C expressions.
* c-lang.h: #include "macroexp.h", for macro_lookup_ftype.
(scan_macro_expansion, scanning_macro_expansion,
finished_macro_expansion): New function declarations.
(expression_macro_lookup_func, expression_macro_lookup_baton): New
variable declarations.
* parser-defs.h (expression_context_pc): New declaration.
* parse.c (expression_context_pc): New variable.
(parse_exp_1): Set expression_context_pc, as well as
expression_context_block.
* c-exp.y (yylex): If we're not already reading the result of a
macro expansion, try to macro-expand the next token. When we're
done scanning a macro expansion, switch back to the mainline text.
Commas and `if's in a macro's expansion don't terminate the input.
* c-lang.c: #include "macroscope.h" and "gdb_assert.h".
(macro_original_text, macro_expanded_text,
expression_macro_lookup_func, expression_macro_lookup_baton): New
variables.
(scan_macro_expansion, scanning_macro_expansion,
finished_macro_expansion, scan_macro_cleanup, null_macro_lookup,
c_preprocess_and_parse): New functions.
(c_language_defn, cplus_language_defn, asm_language_defn): Call
c_preprocess_and_parse, instead of c_parse.
* Makefile.in (c_lang_h): Note that this #includes macroexp.h.
(c-lang.o): Note dependency on macroscope.h and gdb_assert.h.
2002-05-17 17:57:48 +00:00
|
|
|
|
}
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
2010-05-17 17:23:33 +00:00
|
|
|
|
if (language_mode == language_mode_auto && block != NULL)
|
|
|
|
|
{
|
|
|
|
|
/* Find the language associated to the given context block.
|
|
|
|
|
Default to the current language if it can not be determined.
|
|
|
|
|
|
|
|
|
|
Note that using the language corresponding to the current frame
|
|
|
|
|
can sometimes give unexpected results. For instance, this
|
|
|
|
|
routine is often called several times during the inferior
|
|
|
|
|
startup phase to re-parse breakpoint expressions after
|
|
|
|
|
a new shared library has been loaded. The language associated
|
|
|
|
|
to the current frame at this moment is not relevant for
|
2011-01-10 20:38:51 +00:00
|
|
|
|
the breakpoint. Using it would therefore be silly, so it seems
|
2010-05-17 17:23:33 +00:00
|
|
|
|
better to rely on the current language rather than relying on
|
2011-01-10 20:38:51 +00:00
|
|
|
|
the current frame language to parse the expression. That's why
|
2010-05-17 17:23:33 +00:00
|
|
|
|
we do the following language detection only if the context block
|
|
|
|
|
has been specifically provided. */
|
|
|
|
|
struct symbol *func = block_linkage_function (block);
|
|
|
|
|
|
|
|
|
|
if (func != NULL)
|
|
|
|
|
lang = language_def (SYMBOL_LANGUAGE (func));
|
|
|
|
|
if (lang == NULL || lang->la_language == language_unknown)
|
|
|
|
|
lang = current_language;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
lang = current_language;
|
|
|
|
|
|
2012-01-18 12:47:35 +00:00
|
|
|
|
initialize_expout (10, lang, get_current_arch ());
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
2008-06-06 20:58:08 +00:00
|
|
|
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
|
|
|
|
{
|
2010-05-17 17:23:33 +00:00
|
|
|
|
if (lang->la_parser ())
|
|
|
|
|
lang->la_error (NULL);
|
2008-06-06 20:58:08 +00:00
|
|
|
|
}
|
|
|
|
|
if (except.reason < 0)
|
|
|
|
|
{
|
|
|
|
|
if (! in_parse_field)
|
|
|
|
|
{
|
|
|
|
|
xfree (expout);
|
|
|
|
|
throw_exception (except);
|
|
|
|
|
}
|
|
|
|
|
}
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
discard_cleanups (old_chain);
|
|
|
|
|
|
2012-01-18 12:47:35 +00:00
|
|
|
|
reallocate_expout ();
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
/* Convert expression from postfix form as generated by yacc
|
2011-01-10 20:38:51 +00:00
|
|
|
|
parser, to a prefix form. */
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
if (expressiondebug)
|
2003-09-24 08:29:42 +00:00
|
|
|
|
dump_raw_expression (expout, gdb_stdlog,
|
|
|
|
|
"before conversion to prefix form");
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
2008-06-06 20:58:08 +00:00
|
|
|
|
subexp = prefixify_expression (expout);
|
|
|
|
|
if (out_subexp)
|
|
|
|
|
*out_subexp = subexp;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
2010-05-17 17:23:33 +00:00
|
|
|
|
lang->la_post_parser (&expout, void_context_p);
|
2004-04-10 22:10:01 +00:00
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
if (expressiondebug)
|
2003-09-24 08:29:42 +00:00
|
|
|
|
dump_prefix_expression (expout, gdb_stdlog);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
*stringptr = lexptr;
|
|
|
|
|
return expout;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Parse STRING as an expression, and complain if this fails
|
|
|
|
|
to use up all of the contents of STRING. */
|
|
|
|
|
|
|
|
|
|
struct expression *
|
2000-07-30 01:48:28 +00:00
|
|
|
|
parse_expression (char *string)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2003-09-09 08:05:43 +00:00
|
|
|
|
struct expression *exp;
|
2010-05-16 01:27:02 +00:00
|
|
|
|
|
2012-06-27 18:08:41 +00:00
|
|
|
|
exp = parse_exp_1 (&string, 0, 0, 0);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
if (*string)
|
2005-02-10 Andrew Cagney <cagney@gnu.org>
Mark up all error and warning messages.
* ada-lang.c, amd64-tdep.c, arch-utils.c, breakpoint.c: Update.
* bsd-kvm.c, bsd-uthread.c, coff-solib.h, coffread.c: Update.
* core-aout.c, core-regset.c, corefile.c, corelow.c: Update.
* cp-abi.c, cp-support.c, cp-valprint.c, cris-tdep.c: Update.
* dbxread.c, demangle.c, doublest.c, dsrec.c: Update.
* dve3900-rom.c, dwarf2expr.c, dwarf2loc.c: Update.
* dwarf2read.c, dwarfread.c, elfread.c, eval.c: Update.
* event-top.c, exec.c, expprint.c, f-lang.c: Update.
* f-typeprint.c, f-valprint.c, fbsd-nat.c, findvar.c: Update.
* frame.c, frv-linux-tdep.c, gcore.c, gdbtypes.c: Update.
* gnu-nat.c, gnu-v2-abi.c, gnu-v3-abi.c, go32-nat.c: Update.
* hpacc-abi.c, hppa-hpux-nat.c, hppa-hpux-tdep.c: Update.
* hppa-linux-nat.c, hppa-linux-tdep.c, hppa-tdep.c: Update.
* hpread.c, hpux-thread.c, i386-linux-nat.c: Update.
* i386-linux-tdep.c, i386-tdep.c, i386bsd-nat.c: Update.
* i386gnu-nat.c, i387-tdep.c, ia64-linux-nat.c: Update.
* ia64-tdep.c, inf-child.c, inf-ptrace.c, inf-ttrace.c: Update.
* infcall.c, infcmd.c, inflow.c, infptrace.c, infrun.c: Update.
* inftarg.c, interps.c, irix5-nat.c, jv-lang.c: Update.
* kod-cisco.c, kod.c, language.c, libunwind-frame.c: Update.
* linespec.c, linux-nat.c, linux-thread-db.c, m2-lang.c: Update.
* m32r-rom.c, m68hc11-tdep.c, m68k-tdep.c: Update.
* m68klinux-nat.c, macrocmd.c, macroexp.c, main.c: Update.
* maint.c, mdebugread.c, mem-break.c, memattr.c: Update.
* mips-linux-tdep.c, mips-tdep.c, mipsread.c, monitor.c: Update.
* nlmread.c, nto-procfs.c, objc-lang.c, objfiles.c: Update.
* observer.c, ocd.c, p-lang.c, p-typeprint.c: Update.
* p-valprint.c, pa64solib.c, parse.c, ppc-linux-tdep.c: Update.
* ppcnbsd-tdep.c, printcmd.c, procfs.c, remote-e7000.c: Update.
* remote-fileio.c, remote-m32r-sdi.c, remote-rdi.c: Update.
* remote-rdp.c, remote-sim.c, remote-st.c: Update.
* remote-utils.c, remote-utils.h, remote.c: Update.
* rom68k-rom.c, rs6000-nat.c, s390-tdep.c, scm-lang.c: Update.
* ser-e7kpc.c, ser-tcp.c, ser-unix.c, sh-tdep.c: Update.
* sh3-rom.c, shnbsd-tdep.c, sol-thread.c, solib-aix5.c: Update.
* solib-frv.c, solib-irix.c, solib-osf.c, solib-pa64.c: Update.
* solib-som.c, solib-sunos.c, solib-svr4.c, solib.c: Update.
* somread.c, somsolib.c, source.c, stabsread.c: Update.
* stack.c, std-regs.c, symfile-mem.c, symfile.c: Update.
* symmisc.c, symtab.c, target.c, thread.c, top.c: Update.
* tracepoint.c, trad-frame.c, typeprint.c, utils.c: Update.
* uw-thread.c, valarith.c, valops.c, valprint.c: Update.
* value.c, varobj.c, version.in, win32-nat.c, wince.c: Update.
* xcoffread.c, xcoffsolib.c, cli/cli-cmds.c: Update.
* cli/cli-decode.c, cli/cli-dump.c, cli/cli-logging.c: Update.
* cli/cli-script.c, cli/cli-setshow.c, mi/mi-cmd-break.c: Update.
* mi/mi-cmd-disas.c, mi/mi-cmd-env.c, mi/mi-cmd-file.c: Update.
* mi/mi-cmd-stack.c, mi/mi-cmd-var.c, mi/mi-getopt.c: Update.
* mi/mi-symbol-cmds.c, tui/tui-layout.c, tui/tui-stack.c: Update.
* tui/tui-win.c: Update.
2005-02-11 04:06:14 +00:00
|
|
|
|
error (_("Junk after end of expression."));
|
1999-04-16 01:35:26 +00:00
|
|
|
|
return exp;
|
|
|
|
|
}
|
2004-04-10 22:10:01 +00:00
|
|
|
|
|
2008-06-06 20:58:08 +00:00
|
|
|
|
/* Parse STRING as an expression. If parsing ends in the middle of a
|
|
|
|
|
field reference, return the type of the left-hand-side of the
|
|
|
|
|
reference; furthermore, if the parsing ends in the field name,
|
2010-08-18 19:02:34 +00:00
|
|
|
|
return the field name in *NAME. If the parsing ends in the middle
|
|
|
|
|
of a field reference, but the reference is somehow invalid, throw
|
|
|
|
|
an exception. In all other cases, return NULL. Returned non-NULL
|
|
|
|
|
*NAME must be freed by the caller. */
|
2008-06-06 20:58:08 +00:00
|
|
|
|
|
|
|
|
|
struct type *
|
|
|
|
|
parse_field_expression (char *string, char **name)
|
|
|
|
|
{
|
|
|
|
|
struct expression *exp = NULL;
|
|
|
|
|
struct value *val;
|
|
|
|
|
int subexp;
|
|
|
|
|
volatile struct gdb_exception except;
|
|
|
|
|
|
2010-08-18 19:02:34 +00:00
|
|
|
|
TRY_CATCH (except, RETURN_MASK_ERROR)
|
2008-06-06 20:58:08 +00:00
|
|
|
|
{
|
|
|
|
|
in_parse_field = 1;
|
2012-06-27 18:08:41 +00:00
|
|
|
|
exp = parse_exp_in_context (&string, 0, 0, 0, 0, &subexp);
|
2008-06-06 20:58:08 +00:00
|
|
|
|
}
|
|
|
|
|
in_parse_field = 0;
|
|
|
|
|
if (except.reason < 0 || ! exp)
|
|
|
|
|
return NULL;
|
|
|
|
|
if (expout_last_struct == -1)
|
|
|
|
|
{
|
|
|
|
|
xfree (exp);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*name = extract_field_op (exp, &subexp);
|
|
|
|
|
if (!*name)
|
|
|
|
|
{
|
|
|
|
|
xfree (exp);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2008-11-24 17:05:43 +00:00
|
|
|
|
|
2010-08-18 19:02:34 +00:00
|
|
|
|
/* This might throw an exception. If so, we want to let it
|
|
|
|
|
propagate. */
|
2008-06-06 20:58:08 +00:00
|
|
|
|
val = evaluate_subexpression_type (exp, subexp);
|
2010-08-18 19:02:34 +00:00
|
|
|
|
/* (*NAME) is a part of the EXP memory block freed below. */
|
|
|
|
|
*name = xstrdup (*name);
|
2008-06-06 20:58:08 +00:00
|
|
|
|
xfree (exp);
|
|
|
|
|
|
|
|
|
|
return value_type (val);
|
|
|
|
|
}
|
|
|
|
|
|
2011-01-10 20:38:51 +00:00
|
|
|
|
/* A post-parser that does nothing. */
|
2004-04-10 22:10:01 +00:00
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
null_post_parser (struct expression **exp, int void_context_p)
|
|
|
|
|
{
|
|
|
|
|
}
|
2010-08-19 13:33:15 +00:00
|
|
|
|
|
|
|
|
|
/* Parse floating point value P of length LEN.
|
|
|
|
|
Return 0 (false) if invalid, 1 (true) if valid.
|
|
|
|
|
The successfully parsed number is stored in D.
|
|
|
|
|
*SUFFIX points to the suffix of the number in P.
|
|
|
|
|
|
|
|
|
|
NOTE: This accepts the floating point syntax that sscanf accepts. */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
parse_float (const char *p, int len, DOUBLEST *d, const char **suffix)
|
|
|
|
|
{
|
|
|
|
|
char *copy;
|
|
|
|
|
int n, num;
|
|
|
|
|
|
|
|
|
|
copy = xmalloc (len + 1);
|
|
|
|
|
memcpy (copy, p, len);
|
|
|
|
|
copy[len] = 0;
|
|
|
|
|
|
|
|
|
|
num = sscanf (copy, "%" DOUBLEST_SCAN_FORMAT "%n", d, &n);
|
|
|
|
|
xfree (copy);
|
|
|
|
|
|
|
|
|
|
/* The sscanf man page suggests not making any assumptions on the effect
|
|
|
|
|
of %n on the result, so we don't.
|
|
|
|
|
That is why we simply test num == 0. */
|
|
|
|
|
if (num == 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
*suffix = p + n;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Parse floating point value P of length LEN, using the C syntax for floats.
|
|
|
|
|
Return 0 (false) if invalid, 1 (true) if valid.
|
|
|
|
|
The successfully parsed number is stored in *D.
|
|
|
|
|
Its type is taken from builtin_type (gdbarch) and is stored in *T. */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
parse_c_float (struct gdbarch *gdbarch, const char *p, int len,
|
|
|
|
|
DOUBLEST *d, struct type **t)
|
|
|
|
|
{
|
|
|
|
|
const char *suffix;
|
|
|
|
|
int suffix_len;
|
|
|
|
|
const struct builtin_type *builtin_types = builtin_type (gdbarch);
|
|
|
|
|
|
|
|
|
|
if (! parse_float (p, len, d, &suffix))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
suffix_len = p + len - suffix;
|
|
|
|
|
|
|
|
|
|
if (suffix_len == 0)
|
|
|
|
|
*t = builtin_types->builtin_double;
|
|
|
|
|
else if (suffix_len == 1)
|
|
|
|
|
{
|
|
|
|
|
/* Handle suffixes: 'f' for float, 'l' for long double. */
|
|
|
|
|
if (tolower (*suffix) == 'f')
|
|
|
|
|
*t = builtin_types->builtin_float;
|
|
|
|
|
else if (tolower (*suffix) == 'l')
|
|
|
|
|
*t = builtin_types->builtin_long_double;
|
|
|
|
|
else
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
1999-04-16 01:35:26 +00:00
|
|
|
|
|
|
|
|
|
/* Stuff for maintaining a stack of types. Currently just used by C, but
|
|
|
|
|
probably useful for any language which declares its types "backwards". */
|
|
|
|
|
|
2012-07-06 14:44:22 +00:00
|
|
|
|
/* Ensure that there are HOWMUCH open slots on the type stack STACK. */
|
|
|
|
|
|
2001-11-15 01:55:59 +00:00
|
|
|
|
static void
|
2012-07-06 14:44:22 +00:00
|
|
|
|
type_stack_reserve (struct type_stack *stack, int howmuch)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2012-07-06 14:44:22 +00:00
|
|
|
|
if (stack->depth + howmuch >= stack->size)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2012-07-06 14:44:22 +00:00
|
|
|
|
stack->size *= 2;
|
|
|
|
|
if (stack->size < howmuch)
|
|
|
|
|
stack->size = howmuch;
|
|
|
|
|
stack->elements = xrealloc (stack->elements,
|
|
|
|
|
stack->size * sizeof (union type_stack_elt));
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
2001-11-15 01:55:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
2012-07-06 14:44:22 +00:00
|
|
|
|
/* Ensure that there is a single open slot in the global type stack. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
check_type_stack_depth (void)
|
|
|
|
|
{
|
|
|
|
|
type_stack_reserve (&type_stack, 1);
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-19 19:49:42 +00:00
|
|
|
|
/* A helper function for insert_type and insert_type_address_space.
|
|
|
|
|
This does work of expanding the type stack and inserting the new
|
|
|
|
|
element, ELEMENT, into the stack at location SLOT. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
insert_into_type_stack (int slot, union type_stack_elt element)
|
|
|
|
|
{
|
|
|
|
|
check_type_stack_depth ();
|
|
|
|
|
|
* parser-defs.h (type_stack, type_stack_size, type_stack_depth):
Remove.
(struct type_stack): New.
* parse.c (type_stack, type_stack_size, type_stack_depth):
Remove.
(type_stack): New global.
(parse_exp_in_context, check_type_stack_depth)
(insert_into_type_stack, insert_type, push_type, push_type_int)
(insert_type_address_space, pop_type, pop_type_int)
(_initialize_parse): Update.
2012-07-06 14:42:09 +00:00
|
|
|
|
if (slot < type_stack.depth)
|
|
|
|
|
memmove (&type_stack.elements[slot + 1], &type_stack.elements[slot],
|
|
|
|
|
(type_stack.depth - slot) * sizeof (union type_stack_elt));
|
|
|
|
|
type_stack.elements[slot] = element;
|
|
|
|
|
++type_stack.depth;
|
2012-06-19 19:49:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Insert a new type, TP, at the bottom of the type stack. If TP is
|
|
|
|
|
tp_pointer or tp_reference, it is inserted at the bottom. If TP is
|
|
|
|
|
a qualifier, it is inserted at slot 1 (just above a previous
|
|
|
|
|
tp_pointer) if there is anything on the stack, or simply pushed if
|
|
|
|
|
the stack is empty. Other values for TP are invalid. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
insert_type (enum type_pieces tp)
|
|
|
|
|
{
|
|
|
|
|
union type_stack_elt element;
|
|
|
|
|
int slot;
|
|
|
|
|
|
|
|
|
|
gdb_assert (tp == tp_pointer || tp == tp_reference
|
|
|
|
|
|| tp == tp_const || tp == tp_volatile);
|
|
|
|
|
|
|
|
|
|
/* If there is anything on the stack (we know it will be a
|
|
|
|
|
tp_pointer), insert the qualifier above it. Otherwise, simply
|
|
|
|
|
push this on the top of the stack. */
|
* parser-defs.h (type_stack, type_stack_size, type_stack_depth):
Remove.
(struct type_stack): New.
* parse.c (type_stack, type_stack_size, type_stack_depth):
Remove.
(type_stack): New global.
(parse_exp_in_context, check_type_stack_depth)
(insert_into_type_stack, insert_type, push_type, push_type_int)
(insert_type_address_space, pop_type, pop_type_int)
(_initialize_parse): Update.
2012-07-06 14:42:09 +00:00
|
|
|
|
if (type_stack.depth && (tp == tp_const || tp == tp_volatile))
|
2012-06-19 19:49:42 +00:00
|
|
|
|
slot = 1;
|
|
|
|
|
else
|
|
|
|
|
slot = 0;
|
|
|
|
|
|
|
|
|
|
element.piece = tp;
|
|
|
|
|
insert_into_type_stack (slot, element);
|
|
|
|
|
}
|
|
|
|
|
|
2001-11-15 01:55:59 +00:00
|
|
|
|
void
|
|
|
|
|
push_type (enum type_pieces tp)
|
|
|
|
|
{
|
|
|
|
|
check_type_stack_depth ();
|
* parser-defs.h (type_stack, type_stack_size, type_stack_depth):
Remove.
(struct type_stack): New.
* parse.c (type_stack, type_stack_size, type_stack_depth):
Remove.
(type_stack): New global.
(parse_exp_in_context, check_type_stack_depth)
(insert_into_type_stack, insert_type, push_type, push_type_int)
(insert_type_address_space, pop_type, pop_type_int)
(_initialize_parse): Update.
2012-07-06 14:42:09 +00:00
|
|
|
|
type_stack.elements[type_stack.depth++].piece = tp;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2000-07-30 01:48:28 +00:00
|
|
|
|
push_type_int (int n)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
2001-11-15 01:55:59 +00:00
|
|
|
|
check_type_stack_depth ();
|
* parser-defs.h (type_stack, type_stack_size, type_stack_depth):
Remove.
(struct type_stack): New.
* parse.c (type_stack, type_stack_size, type_stack_depth):
Remove.
(type_stack): New global.
(parse_exp_in_context, check_type_stack_depth)
(insert_into_type_stack, insert_type, push_type, push_type_int)
(insert_type_address_space, pop_type, pop_type_int)
(_initialize_parse): Update.
2012-07-06 14:42:09 +00:00
|
|
|
|
type_stack.elements[type_stack.depth++].int_val = n;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
|
2012-06-19 19:49:42 +00:00
|
|
|
|
/* Insert a tp_space_identifier and the corresponding address space
|
|
|
|
|
value into the stack. STRING is the name of an address space, as
|
|
|
|
|
recognized by address_space_name_to_int. If the stack is empty,
|
|
|
|
|
the new elements are simply pushed. If the stack is not empty,
|
|
|
|
|
this function assumes that the first item on the stack is a
|
|
|
|
|
tp_pointer, and the new values are inserted above the first
|
|
|
|
|
item. */
|
|
|
|
|
|
2001-11-15 01:55:59 +00:00
|
|
|
|
void
|
2012-06-19 19:49:42 +00:00
|
|
|
|
insert_type_address_space (char *string)
|
2001-11-15 01:55:59 +00:00
|
|
|
|
{
|
2012-06-19 19:49:42 +00:00
|
|
|
|
union type_stack_elt element;
|
|
|
|
|
int slot;
|
|
|
|
|
|
|
|
|
|
/* If there is anything on the stack (we know it will be a
|
|
|
|
|
tp_pointer), insert the address space qualifier above it.
|
|
|
|
|
Otherwise, simply push this on the top of the stack. */
|
* parser-defs.h (type_stack, type_stack_size, type_stack_depth):
Remove.
(struct type_stack): New.
* parse.c (type_stack, type_stack_size, type_stack_depth):
Remove.
(type_stack): New global.
(parse_exp_in_context, check_type_stack_depth)
(insert_into_type_stack, insert_type, push_type, push_type_int)
(insert_type_address_space, pop_type, pop_type_int)
(_initialize_parse): Update.
2012-07-06 14:42:09 +00:00
|
|
|
|
if (type_stack.depth)
|
2012-06-19 19:49:42 +00:00
|
|
|
|
slot = 1;
|
|
|
|
|
else
|
|
|
|
|
slot = 0;
|
|
|
|
|
|
|
|
|
|
element.piece = tp_space_identifier;
|
|
|
|
|
insert_into_type_stack (slot, element);
|
|
|
|
|
element.int_val = address_space_name_to_int (parse_gdbarch, string);
|
|
|
|
|
insert_into_type_stack (slot, element);
|
2001-11-15 01:55:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
1999-07-07 20:19:36 +00:00
|
|
|
|
enum type_pieces
|
2000-07-30 01:48:28 +00:00
|
|
|
|
pop_type (void)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
* parser-defs.h (type_stack, type_stack_size, type_stack_depth):
Remove.
(struct type_stack): New.
* parse.c (type_stack, type_stack_size, type_stack_depth):
Remove.
(type_stack): New global.
(parse_exp_in_context, check_type_stack_depth)
(insert_into_type_stack, insert_type, push_type, push_type_int)
(insert_type_address_space, pop_type, pop_type_int)
(_initialize_parse): Update.
2012-07-06 14:42:09 +00:00
|
|
|
|
if (type_stack.depth)
|
|
|
|
|
return type_stack.elements[--type_stack.depth].piece;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
return tp_end;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
2000-07-30 01:48:28 +00:00
|
|
|
|
pop_type_int (void)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
* parser-defs.h (type_stack, type_stack_size, type_stack_depth):
Remove.
(struct type_stack): New.
* parse.c (type_stack, type_stack_size, type_stack_depth):
Remove.
(type_stack): New global.
(parse_exp_in_context, check_type_stack_depth)
(insert_into_type_stack, insert_type, push_type, push_type_int)
(insert_type_address_space, pop_type, pop_type_int)
(_initialize_parse): Update.
2012-07-06 14:42:09 +00:00
|
|
|
|
if (type_stack.depth)
|
|
|
|
|
return type_stack.elements[--type_stack.depth].int_val;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
/* "Can't happen". */
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-06 14:47:00 +00:00
|
|
|
|
/* Pop a type list element from the global type stack. */
|
|
|
|
|
|
|
|
|
|
static VEC (type_ptr) *
|
|
|
|
|
pop_typelist (void)
|
|
|
|
|
{
|
|
|
|
|
gdb_assert (type_stack.depth);
|
|
|
|
|
return type_stack.elements[--type_stack.depth].typelist_val;
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-06 14:44:22 +00:00
|
|
|
|
/* Pop a type_stack element from the global type stack. */
|
|
|
|
|
|
|
|
|
|
static struct type_stack *
|
|
|
|
|
pop_type_stack (void)
|
|
|
|
|
{
|
|
|
|
|
gdb_assert (type_stack.depth);
|
|
|
|
|
return type_stack.elements[--type_stack.depth].stack_val;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Append the elements of the type stack FROM to the type stack TO.
|
|
|
|
|
Always returns TO. */
|
|
|
|
|
|
|
|
|
|
struct type_stack *
|
|
|
|
|
append_type_stack (struct type_stack *to, struct type_stack *from)
|
|
|
|
|
{
|
|
|
|
|
type_stack_reserve (to, from->depth);
|
|
|
|
|
|
|
|
|
|
memcpy (&to->elements[to->depth], &from->elements[0],
|
|
|
|
|
from->depth * sizeof (union type_stack_elt));
|
|
|
|
|
to->depth += from->depth;
|
|
|
|
|
|
|
|
|
|
return to;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Push the type stack STACK as an element on the global type stack. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
push_type_stack (struct type_stack *stack)
|
|
|
|
|
{
|
|
|
|
|
check_type_stack_depth ();
|
|
|
|
|
type_stack.elements[type_stack.depth++].stack_val = stack;
|
|
|
|
|
push_type (tp_type_stack);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Copy the global type stack into a newly allocated type stack and
|
|
|
|
|
return it. The global stack is cleared. The returned type stack
|
|
|
|
|
must be freed with type_stack_cleanup. */
|
|
|
|
|
|
|
|
|
|
struct type_stack *
|
|
|
|
|
get_type_stack (void)
|
|
|
|
|
{
|
|
|
|
|
struct type_stack *result = XNEW (struct type_stack);
|
|
|
|
|
|
|
|
|
|
*result = type_stack;
|
|
|
|
|
type_stack.depth = 0;
|
|
|
|
|
type_stack.size = 0;
|
|
|
|
|
type_stack.elements = NULL;
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* A cleanup function that destroys a single type stack. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
type_stack_cleanup (void *arg)
|
|
|
|
|
{
|
|
|
|
|
struct type_stack *stack = arg;
|
|
|
|
|
|
|
|
|
|
xfree (stack->elements);
|
|
|
|
|
xfree (stack);
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-06 14:47:00 +00:00
|
|
|
|
/* Push a function type with arguments onto the global type stack.
|
2012-07-06 14:48:48 +00:00
|
|
|
|
LIST holds the argument types. If the final item in LIST is NULL,
|
|
|
|
|
then the function will be varargs. */
|
2012-07-06 14:47:00 +00:00
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
push_typelist (VEC (type_ptr) *list)
|
|
|
|
|
{
|
|
|
|
|
check_type_stack_depth ();
|
|
|
|
|
type_stack.elements[type_stack.depth++].typelist_val = list;
|
|
|
|
|
push_type (tp_function_with_arguments);
|
|
|
|
|
}
|
|
|
|
|
|
1999-04-16 01:35:26 +00:00
|
|
|
|
/* Pop the type stack and return the type which corresponds to FOLLOW_TYPE
|
|
|
|
|
as modified by all the stuff on the stack. */
|
|
|
|
|
struct type *
|
2000-07-30 01:48:28 +00:00
|
|
|
|
follow_types (struct type *follow_type)
|
1999-04-16 01:35:26 +00:00
|
|
|
|
{
|
|
|
|
|
int done = 0;
|
2001-09-27 22:39:05 +00:00
|
|
|
|
int make_const = 0;
|
|
|
|
|
int make_volatile = 0;
|
2001-11-15 01:55:59 +00:00
|
|
|
|
int make_addr_space = 0;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
int array_size;
|
|
|
|
|
|
|
|
|
|
while (!done)
|
|
|
|
|
switch (pop_type ())
|
|
|
|
|
{
|
|
|
|
|
case tp_end:
|
|
|
|
|
done = 1;
|
2001-09-27 22:39:05 +00:00
|
|
|
|
if (make_const)
|
|
|
|
|
follow_type = make_cv_type (make_const,
|
|
|
|
|
TYPE_VOLATILE (follow_type),
|
|
|
|
|
follow_type, 0);
|
|
|
|
|
if (make_volatile)
|
|
|
|
|
follow_type = make_cv_type (TYPE_CONST (follow_type),
|
|
|
|
|
make_volatile,
|
|
|
|
|
follow_type, 0);
|
2001-11-15 01:55:59 +00:00
|
|
|
|
if (make_addr_space)
|
|
|
|
|
follow_type = make_type_with_address_space (follow_type,
|
|
|
|
|
make_addr_space);
|
|
|
|
|
make_const = make_volatile = 0;
|
|
|
|
|
make_addr_space = 0;
|
2001-09-27 22:39:05 +00:00
|
|
|
|
break;
|
|
|
|
|
case tp_const:
|
|
|
|
|
make_const = 1;
|
|
|
|
|
break;
|
|
|
|
|
case tp_volatile:
|
|
|
|
|
make_volatile = 1;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
break;
|
2001-11-15 01:55:59 +00:00
|
|
|
|
case tp_space_identifier:
|
|
|
|
|
make_addr_space = pop_type_int ();
|
|
|
|
|
break;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
case tp_pointer:
|
|
|
|
|
follow_type = lookup_pointer_type (follow_type);
|
2001-09-27 22:39:05 +00:00
|
|
|
|
if (make_const)
|
|
|
|
|
follow_type = make_cv_type (make_const,
|
|
|
|
|
TYPE_VOLATILE (follow_type),
|
|
|
|
|
follow_type, 0);
|
|
|
|
|
if (make_volatile)
|
|
|
|
|
follow_type = make_cv_type (TYPE_CONST (follow_type),
|
|
|
|
|
make_volatile,
|
|
|
|
|
follow_type, 0);
|
2001-11-15 01:55:59 +00:00
|
|
|
|
if (make_addr_space)
|
|
|
|
|
follow_type = make_type_with_address_space (follow_type,
|
|
|
|
|
make_addr_space);
|
2001-09-27 22:39:05 +00:00
|
|
|
|
make_const = make_volatile = 0;
|
2001-11-15 01:55:59 +00:00
|
|
|
|
make_addr_space = 0;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
break;
|
|
|
|
|
case tp_reference:
|
|
|
|
|
follow_type = lookup_reference_type (follow_type);
|
2001-09-27 22:39:05 +00:00
|
|
|
|
if (make_const)
|
2001-11-15 01:55:59 +00:00
|
|
|
|
follow_type = make_cv_type (make_const,
|
|
|
|
|
TYPE_VOLATILE (follow_type),
|
|
|
|
|
follow_type, 0);
|
2001-09-27 22:39:05 +00:00
|
|
|
|
if (make_volatile)
|
2001-11-15 01:55:59 +00:00
|
|
|
|
follow_type = make_cv_type (TYPE_CONST (follow_type),
|
|
|
|
|
make_volatile,
|
|
|
|
|
follow_type, 0);
|
|
|
|
|
if (make_addr_space)
|
|
|
|
|
follow_type = make_type_with_address_space (follow_type,
|
|
|
|
|
make_addr_space);
|
2001-09-27 22:39:05 +00:00
|
|
|
|
make_const = make_volatile = 0;
|
2001-11-15 01:55:59 +00:00
|
|
|
|
make_addr_space = 0;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
break;
|
|
|
|
|
case tp_array:
|
|
|
|
|
array_size = pop_type_int ();
|
|
|
|
|
/* FIXME-type-allocation: need a way to free this type when we are
|
|
|
|
|
done with it. */
|
|
|
|
|
follow_type =
|
2009-07-02 12:18:46 +00:00
|
|
|
|
lookup_array_range_type (follow_type,
|
|
|
|
|
0, array_size >= 0 ? array_size - 1 : 0);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
if (array_size < 0)
|
gdb/
Replace TYPE_ARRAY_{UPPER,LOWER}_BOUND_TYPE by a bit if {un,}defined.
* c-typeprint.c (c_type_print_varspec_suffix), m2-typeprint.c
(m2_array), p-typeprint.c (pascal_type_print_varspec_prefix),
valops.c (value_cast), varobj.c (c_number_of_children): Replace
TYPE_ARRAY_UPPER_BOUND_TYPE compared to BOUND_CANNOT_BE_DETERMINED by
TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED.
* parse.c (follow_types): Use TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED.
* f-valprint.c (f77_get_dynamic_upperbound): Replace with ...
(f77_get_upperbound): ... this function handling now only
TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED.
(f77_get_dynamic_lowerbound): Replace with ...
(f77_get_lowerbound): ... this function handling now only
TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED.
(f77_get_dynamic_length_of_aggregate, f77_create_arrayprint_offset_tbl):
Update their callers.
* eval.c (evaluate_subexp_standard): Update their callers.
* f-lang.h (f77_get_dynamic_upperbound, f77_get_upperbound)
(f77_get_dynamic_lowerbound, f77_get_lowerbound): Update their
prototypes.
(BOUND_FETCH_OK, BOUND_FETCH_ERROR): Remove.
* f-typeprint.c (f_type_print_varspec_suffix, f_type_print_base): Remove
the lower_bound_was_default variable. Update the
f77_get_dynamic_upperbound, f77_get_upperbound and
TYPE_ARRAY_UPPER_BOUND_TYPE calls.
* gdbtypes.c (print_bound_type): Remove the function.
(recursive_dump_type): Remove its calls printing UPPER_BOUND_TYPE and
LOWER_BOUND_TYPE.
* gdbtypes.h (enum array_bound_type): Remove.
(struct main_type): Remove the fields upper_bound_type and
lower_bound_type. Comment the new overload of the field artificial.
(TYPE_ARRAY_UPPER_BOUND_TYPE): Replace by ...
(TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED): ... this macro.
(TYPE_ARRAY_LOWER_BOUND_TYPE): Replace by ...
(TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED): ... this macro.
gdb/testsuite/
* gdb.base/maint.exp (maint print type): Remove printing
UPPER_BOUND_TYPE and LOWER_BOUND_TYPE.
2008-10-02 22:06:08 +00:00
|
|
|
|
TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (follow_type) = 1;
|
1999-04-16 01:35:26 +00:00
|
|
|
|
break;
|
|
|
|
|
case tp_function:
|
|
|
|
|
/* FIXME-type-allocation: need a way to free this type when we are
|
|
|
|
|
done with it. */
|
|
|
|
|
follow_type = lookup_function_type (follow_type);
|
|
|
|
|
break;
|
2012-07-06 14:44:22 +00:00
|
|
|
|
|
2012-07-06 14:47:00 +00:00
|
|
|
|
case tp_function_with_arguments:
|
|
|
|
|
{
|
|
|
|
|
VEC (type_ptr) *args = pop_typelist ();
|
|
|
|
|
|
|
|
|
|
follow_type
|
|
|
|
|
= lookup_function_type_with_arguments (follow_type,
|
|
|
|
|
VEC_length (type_ptr, args),
|
|
|
|
|
VEC_address (type_ptr,
|
|
|
|
|
args));
|
|
|
|
|
VEC_free (type_ptr, args);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
2012-07-06 14:44:22 +00:00
|
|
|
|
case tp_type_stack:
|
|
|
|
|
{
|
|
|
|
|
struct type_stack *stack = pop_type_stack ();
|
|
|
|
|
/* Sort of ugly, but not really much worse than the
|
|
|
|
|
alternatives. */
|
|
|
|
|
struct type_stack save = type_stack;
|
|
|
|
|
|
|
|
|
|
type_stack = *stack;
|
|
|
|
|
follow_type = follow_types (follow_type);
|
|
|
|
|
gdb_assert (type_stack.depth == 0);
|
|
|
|
|
|
|
|
|
|
type_stack = save;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
gdb_assert_not_reached ("unrecognized tp_ value in follow_types");
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|
|
|
|
|
return follow_type;
|
|
|
|
|
}
|
|
|
|
|
|
2002-06-21 14:32:10 +00:00
|
|
|
|
/* This function avoids direct calls to fprintf
|
|
|
|
|
in the parser generated debug code. */
|
|
|
|
|
void
|
|
|
|
|
parser_fprintf (FILE *x, const char *y, ...)
|
|
|
|
|
{
|
|
|
|
|
va_list args;
|
2010-05-16 01:27:02 +00:00
|
|
|
|
|
2002-06-21 14:32:10 +00:00
|
|
|
|
va_start (args, y);
|
|
|
|
|
if (x == stderr)
|
|
|
|
|
vfprintf_unfiltered (gdb_stderr, y, args);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n");
|
|
|
|
|
vfprintf_unfiltered (gdb_stderr, y, args);
|
|
|
|
|
}
|
|
|
|
|
va_end (args);
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-22 23:15:43 +00:00
|
|
|
|
/* Implementation of the exp_descriptor method operator_check. */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
operator_check_standard (struct expression *exp, int pos,
|
|
|
|
|
int (*objfile_func) (struct objfile *objfile,
|
|
|
|
|
void *data),
|
|
|
|
|
void *data)
|
|
|
|
|
{
|
|
|
|
|
const union exp_element *const elts = exp->elts;
|
|
|
|
|
struct type *type = NULL;
|
|
|
|
|
struct objfile *objfile = NULL;
|
|
|
|
|
|
|
|
|
|
/* Extended operators should have been already handled by exp_descriptor
|
|
|
|
|
iterate method of its specific language. */
|
|
|
|
|
gdb_assert (elts[pos].opcode < OP_EXTENDED0);
|
|
|
|
|
|
|
|
|
|
/* Track the callers of write_exp_elt_type for this table. */
|
|
|
|
|
|
|
|
|
|
switch (elts[pos].opcode)
|
|
|
|
|
{
|
|
|
|
|
case BINOP_VAL:
|
|
|
|
|
case OP_COMPLEX:
|
|
|
|
|
case OP_DECFLOAT:
|
|
|
|
|
case OP_DOUBLE:
|
|
|
|
|
case OP_LONG:
|
|
|
|
|
case OP_SCOPE:
|
|
|
|
|
case OP_TYPE:
|
|
|
|
|
case UNOP_CAST:
|
|
|
|
|
case UNOP_MAX:
|
|
|
|
|
case UNOP_MEMVAL:
|
|
|
|
|
case UNOP_MIN:
|
|
|
|
|
type = elts[pos + 1].type;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TYPE_INSTANCE:
|
|
|
|
|
{
|
|
|
|
|
LONGEST arg, nargs = elts[pos + 1].longconst;
|
|
|
|
|
|
|
|
|
|
for (arg = 0; arg < nargs; arg++)
|
|
|
|
|
{
|
|
|
|
|
struct type *type = elts[pos + 2 + arg].type;
|
|
|
|
|
struct objfile *objfile = TYPE_OBJFILE (type);
|
|
|
|
|
|
|
|
|
|
if (objfile && (*objfile_func) (objfile, data))
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case UNOP_MEMVAL_TLS:
|
|
|
|
|
objfile = elts[pos + 1].objfile;
|
|
|
|
|
type = elts[pos + 2].type;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case OP_VAR_VALUE:
|
|
|
|
|
{
|
|
|
|
|
const struct block *const block = elts[pos + 1].block;
|
|
|
|
|
const struct symbol *const symbol = elts[pos + 2].symbol;
|
|
|
|
|
|
|
|
|
|
/* Check objfile where the variable itself is placed.
|
|
|
|
|
SYMBOL_OBJ_SECTION (symbol) may be NULL. */
|
|
|
|
|
if ((*objfile_func) (SYMBOL_SYMTAB (symbol)->objfile, data))
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
/* Check objfile where is placed the code touching the variable. */
|
|
|
|
|
objfile = lookup_objfile_from_block (block);
|
|
|
|
|
|
|
|
|
|
type = SYMBOL_TYPE (symbol);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL. */
|
|
|
|
|
|
|
|
|
|
if (type && TYPE_OBJFILE (type)
|
|
|
|
|
&& (*objfile_func) (TYPE_OBJFILE (type), data))
|
|
|
|
|
return 1;
|
|
|
|
|
if (objfile && (*objfile_func) (objfile, data))
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Call OBJFILE_FUNC for any TYPE and OBJFILE found being referenced by EXP.
|
|
|
|
|
The functions are never called with NULL OBJFILE. Functions get passed an
|
|
|
|
|
arbitrary caller supplied DATA pointer. If any of the functions returns
|
|
|
|
|
non-zero value then (any other) non-zero value is immediately returned to
|
|
|
|
|
the caller. Otherwise zero is returned after iterating through whole EXP.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
exp_iterate (struct expression *exp,
|
|
|
|
|
int (*objfile_func) (struct objfile *objfile, void *data),
|
|
|
|
|
void *data)
|
|
|
|
|
{
|
|
|
|
|
int endpos;
|
|
|
|
|
|
|
|
|
|
for (endpos = exp->nelts; endpos > 0; )
|
|
|
|
|
{
|
|
|
|
|
int pos, args, oplen = 0;
|
|
|
|
|
|
2010-05-18 23:05:28 +00:00
|
|
|
|
operator_length (exp, endpos, &oplen, &args);
|
2010-04-22 23:15:43 +00:00
|
|
|
|
gdb_assert (oplen > 0);
|
|
|
|
|
|
|
|
|
|
pos = endpos - oplen;
|
|
|
|
|
if (exp->language_defn->la_exp_desc->operator_check (exp, pos,
|
|
|
|
|
objfile_func, data))
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
endpos = pos;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Helper for exp_uses_objfile. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp)
|
|
|
|
|
{
|
|
|
|
|
struct objfile *objfile = objfile_voidp;
|
|
|
|
|
|
|
|
|
|
if (exp_objfile->separate_debug_objfile_backlink)
|
|
|
|
|
exp_objfile = exp_objfile->separate_debug_objfile_backlink;
|
|
|
|
|
|
|
|
|
|
return exp_objfile == objfile;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE
|
|
|
|
|
is unloaded), otherwise return 0. OBJFILE must not be a separate debug info
|
|
|
|
|
file. */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
exp_uses_objfile (struct expression *exp, struct objfile *objfile)
|
|
|
|
|
{
|
|
|
|
|
gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
|
|
|
|
|
|
|
|
|
|
return exp_iterate (exp, exp_uses_objfile_iter, objfile);
|
|
|
|
|
}
|
|
|
|
|
|
1999-06-01 15:44:41 +00:00
|
|
|
|
void
|
2000-07-30 01:48:28 +00:00
|
|
|
|
_initialize_parse (void)
|
1999-06-01 15:44:41 +00:00
|
|
|
|
{
|
2012-07-06 14:44:22 +00:00
|
|
|
|
type_stack.size = 0;
|
* parser-defs.h (type_stack, type_stack_size, type_stack_depth):
Remove.
(struct type_stack): New.
* parse.c (type_stack, type_stack_size, type_stack_depth):
Remove.
(type_stack): New global.
(parse_exp_in_context, check_type_stack_depth)
(insert_into_type_stack, insert_type, push_type, push_type_int)
(insert_type_address_space, pop_type, pop_type_int)
(_initialize_parse): Update.
2012-07-06 14:42:09 +00:00
|
|
|
|
type_stack.depth = 0;
|
2012-07-06 14:44:22 +00:00
|
|
|
|
type_stack.elements = NULL;
|
1999-06-01 15:44:41 +00:00
|
|
|
|
|
2012-08-02 09:36:40 +00:00
|
|
|
|
add_setshow_zuinteger_cmd ("expression", class_maintenance,
|
|
|
|
|
&expressiondebug,
|
|
|
|
|
_("Set expression debugging."),
|
|
|
|
|
_("Show expression debugging."),
|
|
|
|
|
_("When non-zero, the internal representation "
|
|
|
|
|
"of expressions will be printed."),
|
|
|
|
|
NULL,
|
|
|
|
|
show_expressiondebug,
|
|
|
|
|
&setdebuglist, &showdebuglist);
|
2010-02-10 18:57:21 +00:00
|
|
|
|
add_setshow_boolean_cmd ("parser", class_maintenance,
|
2011-01-05 22:22:53 +00:00
|
|
|
|
&parser_debug,
|
|
|
|
|
_("Set parser debugging."),
|
|
|
|
|
_("Show parser debugging."),
|
|
|
|
|
_("When non-zero, expression parser "
|
|
|
|
|
"tracing will be enabled."),
|
2010-02-10 18:57:21 +00:00
|
|
|
|
NULL,
|
|
|
|
|
show_parserdebug,
|
|
|
|
|
&setdebuglist, &showdebuglist);
|
1999-04-16 01:35:26 +00:00
|
|
|
|
}
|