This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH v2 2/9] change minsym representation


In a later patch we're going to change the minimal symbol address
calculation to apply section offsets at the point of use.  To make it
simpler to catch potential problem spots, this patch changes the
representation of minimal symbols and introduces new
minimal-symbol-specific variants of the various accessors.  This is
necessary because it would be excessively ambitious to try to convert
all the symbol types at once.

The core of this change is just renaming a field in minimal_symbol;
the rest is just a fairly mechanical rewording.

	* symtab.h (struct minimal_symbol) <mginfo>: Rename from ginfo.
	(MSYMBOL_VALUE, MSYMBOL_VALUE_ADDRESS, MSYMBOL_VALUE_BYTES)
	(MSYMBOL_BLOCK_VALUE, MSYMBOL_VALUE_CHAIN, MSYMBOL_LANGUAGE)
	(MSYMBOL_SECTION, MSYMBOL_OBJ_SECTION, MSYMBOL_NATURAL_NAME)
	(MSYMBOL_LINKAGE_NAME, MSYMBOL_PRINT_NAME, MSYMBOL_DEMANGLED_NAME)
	(MSYMBOL_SET_LANGUAGE, MSYMBOL_SEARCH_NAME)
	(MSYMBOL_MATCHES_SEARCH_NAME, MSYMBOL_SET_NAMES): New macros.
	* ada-lang.c (ada_main_name): Update.
	(ada_lookup_simple_minsym): Update.
	(ada_make_symbol_completion_list): Update.
	* ada-tasks.c (read_atcb, ada_tasks_inferior_data_sniffer): Update.
	* aix-thread.c (pdc_symbol_addrs, pd_enable): Update.
	* amd64-windows-tdep.c (amd64_skip_main_prologue): Update.
	* arm-tdep.c (skip_prologue_function): Update.
	(arm_skip_stack_protector, arm_skip_stub): Update.
	* arm-wince-tdep.c (arm_pe_skip_trampoline_code): Update.
	(arm_wince_skip_main_prologue): Update.
	* auxv.c (ld_so_xfer_auxv): Update.
	* avr-tdep.c (avr_scan_prologue): Update.
	* ax-gdb.c (gen_var_ref): Update.
	* block.c (call_site_for_pc): Update.
	* blockframe.c (get_pc_function_start): Update.
	(find_pc_partial_function_gnu_ifunc): Update.
	* breakpoint.c (create_overlay_event_breakpoint): Update.
	(create_longjmp_master_breakpoint): Update.
	(create_std_terminate_master_breakpoint): Update.
	(create_exception_master_breakpoint): Update.
	(resolve_sal_pc): Update.
	* bsd-uthread.c (bsd_uthread_lookup_address): Update.
	* btrace.c (ftrace_print_function_name, ftrace_function_switched):
	Update.
	* c-valprint.c (c_val_print): Update.
	* coff-pe-read.c (add_pe_forwarded_sym): Update.
	* coffread.c (coff_symfile_read): Update.
	* common/agent.c (agent_look_up_symbols): Update.
	* dbxread.c (find_stab_function_addr): Update.
	(end_psymtab): Update.
	* dwarf2loc.c (call_site_to_target_addr): Update.
	(func_verify_no_selftailcall): Update.
	(tailcall_dump): Update.
	(call_site_find_chain_1): Update.
	(dwarf_expr_reg_to_entry_parameter): Update.
	* elfread.c (elf_gnu_ifunc_record_cache): Update.
	(elf_gnu_ifunc_resolve_by_got): Update.
	* f-valprint.c (info_common_command): Update.
	* findvar.c (read_var_value): Update.
	* frame.c (get_prev_frame_1): Update.
	(inside_main_func): Update.
	* frv-tdep.c (frv_skip_main_prologue): Update.
	(frv_frame_this_id): Update.
	* glibc-tdep.c (glibc_skip_solib_resolver): Update.
	* gnu-v2-abi.c (gnuv2_value_rtti_type): Update.
	* gnu-v3-abi.c (gnuv3_rtti_type): Update.
	(gnuv3_skip_trampoline): Update.
	* hppa-hpux-tdep.c (hppa32_hpux_in_solib_call_trampoline): Update.
	(hppa64_hpux_in_solib_call_trampoline): Update.
	(hppa_hpux_skip_trampoline_code): Update.
	(hppa64_hpux_search_dummy_call_sequence): Update.
	(hppa_hpux_find_import_stub_for_addr): Update.
	(hppa_hpux_find_dummy_bpaddr): Update.
	* hppa-tdep.c (hppa_symbol_address)
	(hppa_lookup_stub_minimal_symbol): Update.
	* i386-tdep.c (i386_skip_main_prologue): Update.
	(i386_pe_skip_trampoline_code): Update.
	* ia64-tdep.c (ia64_convert_from_func_ptr_addr): Update.
	* infcall.c (get_function_name): Update.
	* infcmd.c (until_next_command): Update.
	* jit.c (jit_breakpoint_re_set_internal): Update.
	(jit_inferior_init): Update.
	* linespec.c (minsym_found): Update.
	(add_minsym): Update.
	* linux-fork.c (info_checkpoints_command): Update.
	* linux-nat.c (get_signo): Update.
	* linux-thread-db.c (inferior_has_bug): Update.
	* m32c-tdep.c (m32c_return_value): Update.
	(m32c_m16c_address_to_pointer): Update.
	(m32c_m16c_pointer_to_address): Update.
	* m32r-tdep.c (m32r_frame_this_id): Update.
	* m68hc11-tdep.c (m68hc11_get_register_info): Update.
	* machoread.c (macho_resolve_oso_sym_with_minsym): Update.
	* maint.c (maintenance_translate_address): Update.
	* minsyms.c (add_minsym_to_hash_table): Update.
	(add_minsym_to_demangled_hash_table): Update.
	(msymbol_objfile): Update.
	(lookup_minimal_symbol): Update.
	(iterate_over_minimal_symbols): Update.
	(lookup_minimal_symbol_text): Update.
	(lookup_minimal_symbol_by_pc_name): Update.
	(lookup_minimal_symbol_solib_trampoline): Update.
	(lookup_minimal_symbol_by_pc_section_1): Update.
	(lookup_minimal_symbol_and_objfile): Update.
	(prim_record_minimal_symbol_full): Update.
	(compare_minimal_symbols): Update.
	(compact_minimal_symbols): Update.
	(build_minimal_symbol_hash_tables): Update.
	(install_minimal_symbols): Update.
	(terminate_minimal_symbol_table): Update.
	(find_solib_trampoline_target): Update.
	(minimal_symbol_upper_bound): Update.
	* mips-linux-tdep.c (mips_linux_skip_resolver): Update.
	* mips-tdep.c (mips_stub_frame_sniffer): Update.
	(mips_skip_pic_trampoline_code): Update.
	* msp430-tdep.c (msp430_skip_trampoline_code): Update.
	* objc-lang.c (selectors_info): Update.
	(classes_info): Update.
	(find_methods): Update.
	(find_imps): Update.
	(find_objc_msgsend): Update.
	* objfiles.c (objfile_relocate1): Update.
	* objfiles.h (ALL_OBJFILE_MSYMBOLS): Update.
	* obsd-tdep.c (obsd_skip_solib_resolver): Update.
	* p-valprint.c (pascal_val_print): Update.
	* parse.c (write_exp_msymbol): Update.
	* ppc-linux-tdep.c (powerpc_linux_in_dynsym_resolve_code)
	(ppc_linux_spe_context_lookup): Update.
	* ppc-sysv-tdep.c (convert_code_addr_to_desc_addr): Update.
	* printcmd.c (build_address_symbolic): Update.
	(sym_info): Update.
	(address_info): Update.
	* proc-service.c (ps_pglobal_lookup): Update.
	* psymtab.c (find_pc_sect_psymtab_closer): Update.
	(find_pc_sect_psymtab): Update.
	* python/py-framefilter.c (py_print_frame): Update.
	* ravenscar-thread.c (get_running_thread_id): Update.
	* record-btrace.c (btrace_func_history): Update.
	* remote.c (remote_check_symbols): Update.
	* rs6000-tdep.c (rs6000_skip_main_prologue): Update.
	(rs6000_skip_trampoline_code): Update.
	* sh64-tdep.c (sh64_elf_make_msymbol_special): Update.
	* sol2-tdep.c (sol2_skip_solib_resolver): Update.
	* solib-dsbt.c (lm_base): Update.
	* solib-frv.c (lm_base): Update.
	(main_got): Update.
	* solib-irix.c (locate_base): Update.
	* solib-som.c (som_solib_create_inferior_hook): Update.
	(som_solib_desire_dynamic_linker_symbols): Update.
	(link_map_start): Update.
	* solib-spu.c (spu_enable_break): Update.
	(ocl_enable_break): Update.
	* solib-svr4.c (elf_locate_base): Update.
	(enable_break): Update.
	* spu-tdep.c (spu_get_overlay_table): Update.
	(spu_catch_start): Update.
	(flush_ea_cache): Update.
	* stabsread.c (define_symbol): Update.
	(scan_file_globals): Update.
	* stack.c (find_frame_funname): Update.
	(frame_info): Update.
	* symfile.c (simple_read_overlay_table): Update.
	(simple_overlay_update): Update.
	* symmisc.c (dump_msymbols): Update.
	* symtab.c (fixup_section): Update.
	(find_pc_sect_line): Update.
	(skip_prologue_sal): Update.
	(search_symbols): Update.
	(print_msymbol_info): Update.
	(rbreak_command): Update.
	(MCOMPLETION_LIST_ADD_SYMBOL): New macro.
	(completion_list_objc_symbol): Update.
	(default_make_symbol_completion_list_break_on): Update.
	* tracepoint.c (scope_info): Update.
	* tui/tui-disasm.c (tui_find_disassembly_address): Update.
	(tui_get_begin_asm_address): Update.
	* valops.c (find_function_in_inferior): Update.
	* value.c (value_static_field): Update.
	(value_fn_field): Update.
---
 gdb/ada-lang.c              |   6 +--
 gdb/ada-tasks.c             |   6 +--
 gdb/aix-thread.c            |   4 +-
 gdb/amd64-windows-tdep.c    |   6 +--
 gdb/arm-tdep.c              |  10 ++--
 gdb/arm-wince-tdep.c        |   6 +--
 gdb/auxv.c                  |   2 +-
 gdb/avr-tdep.c              |   2 +-
 gdb/ax-gdb.c                |   2 +-
 gdb/block.c                 |   2 +-
 gdb/blockframe.c            |   8 +--
 gdb/breakpoint.c            |  10 ++--
 gdb/bsd-uthread.c           |   2 +-
 gdb/btrace.c                |   4 +-
 gdb/c-valprint.c            |   6 +--
 gdb/coff-pe-read.c          |   2 +-
 gdb/coffread.c              |   2 +-
 gdb/common/agent.c          |   2 +-
 gdb/dbxread.c               |   4 +-
 gdb/dwarf2loc.c             |  26 +++++-----
 gdb/elfread.c               |   6 +--
 gdb/findvar.c               |  10 ++--
 gdb/frame.c                 |   4 +-
 gdb/frv-tdep.c              |   6 +--
 gdb/glibc-tdep.c            |   2 +-
 gdb/gnu-v2-abi.c            |   2 +-
 gdb/gnu-v3-abi.c            |  12 ++---
 gdb/hppa-hpux-tdep.c        |  28 +++++------
 gdb/hppa-tdep.c             |   6 +--
 gdb/i386-tdep.c             |   6 +--
 gdb/ia64-tdep.c             |   3 +-
 gdb/infcall.c               |   2 +-
 gdb/infcmd.c                |   2 +-
 gdb/jit.c                   |  10 ++--
 gdb/linespec.c              |  10 ++--
 gdb/linux-fork.c            |   2 +-
 gdb/linux-nat.c             |   2 +-
 gdb/linux-thread-db.c       |   2 +-
 gdb/m32c-tdep.c             |  12 ++---
 gdb/m32r-tdep.c             |   2 +-
 gdb/m68hc11-tdep.c          |   2 +-
 gdb/machoread.c             |   2 +-
 gdb/maint.c                 |   6 +--
 gdb/minsyms.c               | 115 ++++++++++++++++++++++----------------------
 gdb/mips-linux-tdep.c       |   2 +-
 gdb/mips-tdep.c             |  10 ++--
 gdb/msp430-tdep.c           |   2 +-
 gdb/objc-lang.c             |  16 +++---
 gdb/objfiles.c              |   5 +-
 gdb/objfiles.h              |   2 +-
 gdb/obsd-tdep.c             |   2 +-
 gdb/p-valprint.c            |   6 +--
 gdb/parse.c                 |   6 +--
 gdb/ppc-linux-tdep.c        |   6 +--
 gdb/ppc-sysv-tdep.c         |   6 +--
 gdb/printcmd.c              |  20 ++++----
 gdb/proc-service.c          |   2 +-
 gdb/psymtab.c               |   4 +-
 gdb/python/py-framefilter.c |   2 +-
 gdb/ravenscar-thread.c      |   2 +-
 gdb/record-btrace.c         |   3 +-
 gdb/remote.c                |   2 +-
 gdb/rs6000-tdep.c           |   8 +--
 gdb/sh64-tdep.c             |   2 +-
 gdb/sol2-tdep.c             |   2 +-
 gdb/solib-dsbt.c            |   2 +-
 gdb/solib-frv.c             |   4 +-
 gdb/solib-irix.c            |   4 +-
 gdb/solib-som.c             |  34 ++++++-------
 gdb/solib-spu.c             |   6 +--
 gdb/solib-svr4.c            |  10 ++--
 gdb/spu-tdep.c              |  10 ++--
 gdb/stabsread.c             |  14 +++---
 gdb/stack.c                 |  14 +++---
 gdb/symfile.c               |   6 +--
 gdb/symmisc.c               |  10 ++--
 gdb/symtab.c                |  50 ++++++++++---------
 gdb/symtab.h                |  34 +++++++++++--
 gdb/tracepoint.c            |   2 +-
 gdb/tui/tui-disasm.c        |   4 +-
 gdb/valops.c                |   2 +-
 gdb/value.c                 |   4 +-
 82 files changed, 361 insertions(+), 325 deletions(-)

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 9ff3ab9..8ce28e1 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -815,7 +815,7 @@ ada_main_name (void)
       CORE_ADDR main_program_name_addr;
       int err_code;
 
-      main_program_name_addr = SYMBOL_VALUE_ADDRESS (msym);
+      main_program_name_addr = MSYMBOL_VALUE_ADDRESS (msym);
       if (main_program_name_addr == 0)
         error (_("Invalid address for Ada main program name."));
 
@@ -4433,7 +4433,7 @@ ada_lookup_simple_minsym (const char *name)
 
   ALL_MSYMBOLS (objfile, msymbol)
   {
-    if (match_name (SYMBOL_LINKAGE_NAME (msymbol), name, wild_match_p)
+    if (match_name (MSYMBOL_LINKAGE_NAME (msymbol), name, wild_match_p)
         && MSYMBOL_TYPE (msymbol) != mst_solib_trampoline)
       {
 	result.minsym = msymbol;
@@ -5954,7 +5954,7 @@ ada_make_symbol_completion_list (const char *text0, const char *word,
   ALL_MSYMBOLS (objfile, msymbol)
   {
     QUIT;
-    symbol_completion_add (&completions, SYMBOL_LINKAGE_NAME (msymbol),
+    symbol_completion_add (&completions, MSYMBOL_LINKAGE_NAME (msymbol),
 			   text, text_len, text0, word, wild_match_p,
 			   encoded_p);
   }
diff --git a/gdb/ada-tasks.c b/gdb/ada-tasks.c
index dfb6719..8243ecf 100644
--- a/gdb/ada-tasks.c
+++ b/gdb/ada-tasks.c
@@ -640,7 +640,7 @@ read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
 	  msym = lookup_minimal_symbol_by_pc (task_id);
 	  if (msym.minsym)
 	    {
-	      const char *full_name = SYMBOL_LINKAGE_NAME (msym.minsym);
+	      const char *full_name = MSYMBOL_LINKAGE_NAME (msym.minsym);
 	      const char *task_name = full_name;
 	      const char *p;
 
@@ -859,7 +859,7 @@ ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
   if (msym != NULL)
     {
       data->known_tasks_kind = ADA_TASKS_ARRAY;
-      data->known_tasks_addr = SYMBOL_VALUE_ADDRESS (msym);
+      data->known_tasks_addr = MSYMBOL_VALUE_ADDRESS (msym);
 
       /* Try to get pointer type and array length from the symtab.  */
       sym = lookup_symbol_in_language (KNOWN_TASKS_NAME, NULL, VAR_DOMAIN,
@@ -904,7 +904,7 @@ ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
   if (msym != NULL)
     {
       data->known_tasks_kind = ADA_TASKS_LIST;
-      data->known_tasks_addr = SYMBOL_VALUE_ADDRESS (msym);
+      data->known_tasks_addr = MSYMBOL_VALUE_ADDRESS (msym);
       data->known_tasks_length = 1;
 
       sym = lookup_symbol_in_language (KNOWN_TASKS_LIST, NULL, VAR_DOMAIN,
diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c
index 3175835..d528d90 100644
--- a/gdb/aix-thread.c
+++ b/gdb/aix-thread.c
@@ -312,7 +312,7 @@ pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
 		fprintf_unfiltered (gdb_stdlog, " returning PDC_FAILURE\n");
 	      return PDC_FAILURE;
 	    }
-	  symbols[i].addr = SYMBOL_VALUE_ADDRESS (ms);
+	  symbols[i].addr = MSYMBOL_VALUE_ADDRESS (ms);
 	}
       if (debug_aix_thread)
 	fprintf_unfiltered (gdb_stdlog, "  symbols[%d].addr = %s\n",
@@ -910,7 +910,7 @@ pd_enable (void)
   /* Set a breakpoint on the returned stub function.  */
   if (!(ms = lookup_minimal_symbol (stub_name, NULL, NULL)))
     return;
-  pd_brk_addr = SYMBOL_VALUE_ADDRESS (ms);
+  pd_brk_addr = MSYMBOL_VALUE_ADDRESS (ms);
   if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr))
     return;
 
diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c
index 359173a..8c02401 100644
--- a/gdb/amd64-windows-tdep.c
+++ b/gdb/amd64-windows-tdep.c
@@ -355,8 +355,8 @@ amd64_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 	  call_dest = pc + 5 + extract_signed_integer (buf, 4, byte_order);
  	  s = lookup_minimal_symbol_by_pc (call_dest);
  	  if (s.minsym != NULL
- 	      && SYMBOL_LINKAGE_NAME (s.minsym) != NULL
- 	      && strcmp (SYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
+ 	      && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL
+ 	      && strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
  	    pc += 5;
  	}
     }
@@ -1133,7 +1133,7 @@ amd64_windows_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 	= (indirect_addr
 	   ? lookup_minimal_symbol_by_pc (indirect_addr).minsym
 	   : NULL);
-      const char *symname = indsym ? SYMBOL_LINKAGE_NAME (indsym) : NULL;
+      const char *symname = indsym ? MSYMBOL_LINKAGE_NAME (indsym) : NULL;
 
       if (symname)
 	{
diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
index 7c78a61..1212994 100644
--- a/gdb/arm-tdep.c
+++ b/gdb/arm-tdep.c
@@ -472,10 +472,10 @@ skip_prologue_function (struct gdbarch *gdbarch, CORE_ADDR pc, int is_thumb)
 
   msym = lookup_minimal_symbol_by_pc (pc);
   if (msym.minsym != NULL
-      && SYMBOL_VALUE_ADDRESS (msym.minsym) == pc
-      && SYMBOL_LINKAGE_NAME (msym.minsym) != NULL)
+      && MSYMBOL_VALUE_ADDRESS (msym.minsym) == pc
+      && MSYMBOL_LINKAGE_NAME (msym.minsym) != NULL)
     {
-      const char *name = SYMBOL_LINKAGE_NAME (msym.minsym);
+      const char *name = MSYMBOL_LINKAGE_NAME (msym.minsym);
 
       /* The GNU linker's Thumb call stub to foo is named
 	 __foo_from_thumb.  */
@@ -1300,7 +1300,7 @@ arm_skip_stack_protector(CORE_ADDR pc, struct gdbarch *gdbarch)
      instruction sequence is not for stack protector.  If symbol is
      removed, we conservatively think this sequence is for stack protector.  */
   if (stack_chk_guard.minsym
-      && strncmp (SYMBOL_LINKAGE_NAME (stack_chk_guard.minsym),
+      && strncmp (MSYMBOL_LINKAGE_NAME (stack_chk_guard.minsym),
 		  "__stack_chk_guard",
 		  strlen ("__stack_chk_guard")) != 0)
    return pc;
@@ -9288,7 +9288,7 @@ arm_skip_stub (struct frame_info *frame, CORE_ADDR pc)
       objfile = (sec == NULL) ? NULL : sec->objfile;
       minsym = lookup_minimal_symbol (target_name, NULL, objfile);
       if (minsym != NULL)
-	return SYMBOL_VALUE_ADDRESS (minsym);
+	return MSYMBOL_VALUE_ADDRESS (minsym);
       else
 	return 0;
     }
diff --git a/gdb/arm-wince-tdep.c b/gdb/arm-wince-tdep.c
index 0e888e0..8f333dc 100644
--- a/gdb/arm-wince-tdep.c
+++ b/gdb/arm-wince-tdep.c
@@ -64,7 +64,7 @@ arm_pe_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
   if (indsym.minsym == NULL)
     return 0;
 
-  symname = SYMBOL_LINKAGE_NAME (indsym.minsym);
+  symname = MSYMBOL_LINKAGE_NAME (indsym.minsym);
   if (symname == NULL || strncmp (symname, "__imp_", 6) != 0)
     return 0;
 
@@ -102,8 +102,8 @@ arm_wince_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
       struct bound_minimal_symbol s = lookup_minimal_symbol_by_pc (call_dest);
 
       if (s.minsym != NULL
-	  && SYMBOL_LINKAGE_NAME (s.minsym) != NULL
-	  && strcmp (SYMBOL_LINKAGE_NAME (s.minsym), "__gccmain") == 0)
+	  && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL
+	  && strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__gccmain") == 0)
 	pc += 4;
     }
 
diff --git a/gdb/auxv.c b/gdb/auxv.c
index 437040a..07781bf 100644
--- a/gdb/auxv.c
+++ b/gdb/auxv.c
@@ -95,7 +95,7 @@ ld_so_xfer_auxv (gdb_byte *readbuf,
      resides.  DATA_ADDRESS is the inferior value present in
      `_dl_auxv', therefore the real inferior AUXV address.  */
 
-  pointer_address = SYMBOL_VALUE_ADDRESS (msym);
+  pointer_address = MSYMBOL_VALUE_ADDRESS (msym);
 
   /* The location of the _dl_auxv symbol may no longer be correct if
      ld.so runs at a different address than the one present in the
diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c
index fc4e0f0..8c247d7 100644
--- a/gdb/avr-tdep.c
+++ b/gdb/avr-tdep.c
@@ -624,7 +624,7 @@ avr_scan_prologue (struct gdbarch *gdbarch, CORE_ADDR pc_beg, CORE_ADDR pc_end,
 
       /* Resolve offset (in words) from __prologue_saves__ symbol.
          Which is a pushes count in `-mcall-prologues' mode */
-      num_pushes = AVR_MAX_PUSHES - (i - SYMBOL_VALUE_ADDRESS (msymbol)) / 2;
+      num_pushes = AVR_MAX_PUSHES - (i - MSYMBOL_VALUE_ADDRESS (msymbol)) / 2;
 
       if (num_pushes > AVR_MAX_PUSHES)
         {
diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index 4196655..3d89b4f 100644
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -720,7 +720,7 @@ gen_var_ref (struct gdbarch *gdbarch, struct agent_expr *ax,
 	  error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var));
 
 	/* Push the address of the variable.  */
-	ax_const_l (ax, SYMBOL_VALUE_ADDRESS (msym));
+	ax_const_l (ax, MSYMBOL_VALUE_ADDRESS (msym));
 	value->kind = axs_lvalue_memory;
       }
       break;
diff --git a/gdb/block.c b/gdb/block.c
index 643e144..7318d59 100644
--- a/gdb/block.c
+++ b/gdb/block.c
@@ -217,7 +217,7 @@ call_site_for_pc (struct gdbarch *gdbarch, CORE_ADDR pc)
 		     "DW_TAG_GNU_call_site %s in %s"),
 		   paddress (gdbarch, pc),
 		   (msym.minsym == NULL ? "???"
-		    : SYMBOL_PRINT_NAME (msym.minsym)));
+		    : MSYMBOL_PRINT_NAME (msym.minsym)));
     }
 
   return *slot;
diff --git a/gdb/blockframe.c b/gdb/blockframe.c
index 10b7816..adfb5b3 100644
--- a/gdb/blockframe.c
+++ b/gdb/blockframe.c
@@ -104,7 +104,7 @@ get_pc_function_start (CORE_ADDR pc)
   msymbol = lookup_minimal_symbol_by_pc (pc);
   if (msymbol.minsym)
     {
-      CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol.minsym);
+      CORE_ADDR fstart = MSYMBOL_VALUE_ADDRESS (msymbol.minsym);
 
       if (find_pc_section (fstart))
 	return fstart;
@@ -235,7 +235,7 @@ find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, const char **name,
       if (f != NULL
 	  && (msymbol.minsym == NULL
 	      || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
-		  >= SYMBOL_VALUE_ADDRESS (msymbol.minsym))))
+		  >= MSYMBOL_VALUE_ADDRESS (msymbol.minsym))))
 	{
 	  cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
 	  cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
@@ -269,8 +269,8 @@ find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, const char **name,
       return 0;
     }
 
-  cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol.minsym);
-  cache_pc_function_name = SYMBOL_LINKAGE_NAME (msymbol.minsym);
+  cache_pc_function_low = MSYMBOL_VALUE_ADDRESS (msymbol.minsym);
+  cache_pc_function_name = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
   cache_pc_function_section = section;
   cache_pc_function_is_gnu_ifunc = (MSYMBOL_TYPE (msymbol.minsym)
 				    == mst_text_gnu_ifunc);
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 5ce50de..72e3fc2 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -3171,7 +3171,7 @@ create_overlay_event_breakpoint (void)
 	  bp_objfile_data->overlay_msym = m;
 	}
 
-      addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
+      addr = MSYMBOL_VALUE_ADDRESS (bp_objfile_data->overlay_msym);
       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
                                       bp_overlay_event,
 				      &internal_breakpoint_ops);
@@ -3287,7 +3287,7 @@ create_longjmp_master_breakpoint (void)
 	      bp_objfile_data->longjmp_msym[i] = m;
 	    }
 
-	  addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
+	  addr = MSYMBOL_VALUE_ADDRESS (bp_objfile_data->longjmp_msym[i]);
 	  b = create_internal_breakpoint (gdbarch, addr, bp_longjmp_master,
 					  &internal_breakpoint_ops);
 	  b->addr_string = xstrdup (func_name);
@@ -3342,7 +3342,7 @@ create_std_terminate_master_breakpoint (void)
 	  bp_objfile_data->terminate_msym = m;
 	}
 
-      addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
+      addr = MSYMBOL_VALUE_ADDRESS (bp_objfile_data->terminate_msym);
       b = create_internal_breakpoint (get_objfile_arch (objfile), addr,
                                       bp_std_terminate_master,
 				      &internal_breakpoint_ops);
@@ -3442,7 +3442,7 @@ create_exception_master_breakpoint (void)
 	  bp_objfile_data->exception_msym = debug_hook;
 	}
 
-      addr = SYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
+      addr = MSYMBOL_VALUE_ADDRESS (bp_objfile_data->exception_msym);
       addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
 						 &current_target);
       b = create_internal_breakpoint (gdbarch, addr, bp_exception_master,
@@ -9859,7 +9859,7 @@ resolve_sal_pc (struct symtab_and_line *sal)
 
 	      msym = lookup_minimal_symbol_by_pc (sal->pc);
 	      if (msym.minsym)
-		sal->section = SYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
+		sal->section = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
 
 	      do_cleanups (old_chain);
 	    }
diff --git a/gdb/bsd-uthread.c b/gdb/bsd-uthread.c
index 0a2ea81..2726062 100644
--- a/gdb/bsd-uthread.c
+++ b/gdb/bsd-uthread.c
@@ -129,7 +129,7 @@ bsd_uthread_lookup_address (const char *name, struct objfile *objfile)
 
   sym = lookup_minimal_symbol (name, NULL, objfile);
   if (sym)
-    return SYMBOL_VALUE_ADDRESS (sym);
+    return MSYMBOL_VALUE_ADDRESS (sym);
 
   return 0;
 }
diff --git a/gdb/btrace.c b/gdb/btrace.c
index 3230a3e..2aec922 100644
--- a/gdb/btrace.c
+++ b/gdb/btrace.c
@@ -142,7 +142,7 @@ ftrace_print_function_name (struct btrace_func *bfun)
     return SYMBOL_PRINT_NAME (sym);
 
   if (msym != NULL)
-    return SYMBOL_PRINT_NAME (msym);
+    return MSYMBOL_PRINT_NAME (msym);
 
   return "<unknown>";
 }
@@ -209,7 +209,7 @@ ftrace_function_switched (struct btrace_func *bfun,
 
   /* If the minimal symbol changed, we certainly switched functions.  */
   if (mfun != NULL && msym != NULL
-      && strcmp (SYMBOL_LINKAGE_NAME (mfun), SYMBOL_LINKAGE_NAME (msym)) != 0)
+      && strcmp (MSYMBOL_LINKAGE_NAME (mfun), MSYMBOL_LINKAGE_NAME (msym)) != 0)
     return 1;
 
   /* If the symbol changed, we certainly switched functions.  */
diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c
index 3466df0..8ba2d11 100644
--- a/gdb/c-valprint.c
+++ b/gdb/c-valprint.c
@@ -316,12 +316,12 @@ c_val_print (struct type *type, const gdb_byte *valaddr,
 	      /* If 'symbol_print' is set, we did the work above.  */
 	      if (!options->symbol_print
 		  && (msymbol.minsym != NULL)
-		  && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol.minsym)))
+		  && (vt_address == MSYMBOL_VALUE_ADDRESS (msymbol.minsym)))
 		{
 		  if (want_space)
 		    fputs_filtered (" ", stream);
 		  fputs_filtered (" <", stream);
-		  fputs_filtered (SYMBOL_PRINT_NAME (msymbol.minsym), stream);
+		  fputs_filtered (MSYMBOL_PRINT_NAME (msymbol.minsym), stream);
 		  fputs_filtered (">", stream);
 		  want_space = 1;
 		}
@@ -338,7 +338,7 @@ c_val_print (struct type *type, const gdb_byte *valaddr,
 		    fputs_filtered (" ", stream);
 
 		  if (msymbol.minsym != NULL)
-		    wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol.minsym),
+		    wsym = lookup_symbol (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
 					  block, VAR_DOMAIN,
 					  &is_this_fld);
 
diff --git a/gdb/coff-pe-read.c b/gdb/coff-pe-read.c
index 91ee3f6..4db36ec 100644
--- a/gdb/coff-pe-read.c
+++ b/gdb/coff-pe-read.c
@@ -240,7 +240,7 @@ add_pe_forwarded_sym (const char *sym_name, const char *forward_dll_name,
 			" \"%s\" in dll \"%s\", pointing to \"%s\"\n"),
 			sym_name, dll_name, forward_qualified_name);
 
-  vma = SYMBOL_VALUE_ADDRESS (msymbol.minsym);
+  vma = MSYMBOL_VALUE_ADDRESS (msymbol.minsym);
   msymtype = MSYMBOL_TYPE (msymbol.minsym);
 
   /* Generate a (hopefully unique) qualified name using the first part
diff --git a/gdb/coffread.c b/gdb/coffread.c
index 959e96a..a155179 100644
--- a/gdb/coffread.c
+++ b/gdb/coffread.c
@@ -669,7 +669,7 @@ coff_symfile_read (struct objfile *objfile, int symfile_flags)
 
       ALL_OBJFILE_MSYMBOLS (objfile, msym)
 	{
-	  const char *name = SYMBOL_LINKAGE_NAME (msym);
+	  const char *name = MSYMBOL_LINKAGE_NAME (msym);
 
 	  /* If the minimal symbols whose name are prefixed by "__imp_"
 	     or "_imp_", get rid of the prefix, and search the minimal
diff --git a/gdb/common/agent.c b/gdb/common/agent.c
index 99cef4f..51308ed 100644
--- a/gdb/common/agent.c
+++ b/gdb/common/agent.c
@@ -103,7 +103,7 @@ agent_look_up_symbols (void *arg)
 			       (struct objfile *) arg);
 
       if (sym != NULL)
-	*addrp = SYMBOL_VALUE_ADDRESS (sym);
+	*addrp = MSYMBOL_VALUE_ADDRESS (sym);
       else
 #endif
 	{
diff --git a/gdb/dbxread.c b/gdb/dbxread.c
index 00949ac..2a99916 100644
--- a/gdb/dbxread.c
+++ b/gdb/dbxread.c
@@ -1171,7 +1171,7 @@ find_stab_function_addr (char *namestring, const char *filename,
       msym = lookup_minimal_symbol (p, NULL, objfile);
     }
 
-  return msym == NULL ? 0 : SYMBOL_VALUE_ADDRESS (msym);
+  return msym == NULL ? 0 : MSYMBOL_VALUE_ADDRESS (msym);
 }
 
 static void
@@ -2281,7 +2281,7 @@ end_psymtab (struct objfile *objfile, struct partial_symtab *pst,
 	}
 
       if (minsym)
-	pst->texthigh = SYMBOL_VALUE_ADDRESS (minsym) + MSYMBOL_SIZE (minsym);
+	pst->texthigh = MSYMBOL_VALUE_ADDRESS (minsym) + MSYMBOL_SIZE (minsym);
 
       last_function_name = NULL;
     }
diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
index 8242dca..e1d14fc 100644
--- a/gdb/dwarf2loc.c
+++ b/gdb/dwarf2loc.c
@@ -543,7 +543,7 @@ call_site_to_target_addr (struct gdbarch *call_site_gdbarch,
 			   "at %s in %s"),
 			 paddress (call_site_gdbarch, call_site->pc),
 			 (msym.minsym == NULL ? "???"
-			  : SYMBOL_PRINT_NAME (msym.minsym)));
+			  : MSYMBOL_PRINT_NAME (msym.minsym)));
 			
 	  }
 	if (caller_frame == NULL)
@@ -557,7 +557,7 @@ call_site_to_target_addr (struct gdbarch *call_site_gdbarch,
 			   "available at %s in %s"),
 			 paddress (call_site_gdbarch, call_site->pc),
 			 (msym.minsym == NULL ? "???"
-			  : SYMBOL_PRINT_NAME (msym.minsym)));
+			  : MSYMBOL_PRINT_NAME (msym.minsym)));
 			
 	  }
 	caller_arch = get_frame_arch (caller_frame);
@@ -589,10 +589,10 @@ call_site_to_target_addr (struct gdbarch *call_site_gdbarch,
 			 _("Cannot find function \"%s\" for a call site target "
 			   "at %s in %s"),
 			 physname, paddress (call_site_gdbarch, call_site->pc),
-			 msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
+			 msym == NULL ? "???" : MSYMBOL_PRINT_NAME (msym));
 			
 	  }
-	return SYMBOL_VALUE_ADDRESS (msym);
+	return MSYMBOL_VALUE_ADDRESS (msym);
       }
 
     case FIELD_LOC_KIND_PHYSADDR:
@@ -688,7 +688,7 @@ func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_addr)
 			     "function \"%s\" at %s can call itself via tail "
 			     "calls"),
 			   (msym.minsym == NULL ? "???"
-			    : SYMBOL_PRINT_NAME (msym.minsym)),
+			    : MSYMBOL_PRINT_NAME (msym.minsym)),
 			   paddress (gdbarch, verify_addr));
 	    }
 
@@ -716,7 +716,7 @@ tailcall_dump (struct gdbarch *gdbarch, const struct call_site *call_site)
 
   fprintf_unfiltered (gdb_stdlog, " %s(%s)", paddress (gdbarch, addr),
 		      (msym.minsym == NULL ? "???"
-		       : SYMBOL_PRINT_NAME (msym.minsym)));
+		       : MSYMBOL_PRINT_NAME (msym.minsym)));
 
 }
 
@@ -955,10 +955,10 @@ call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
 		     "callers or callees between caller function \"%s\" at %s "
 		     "and callee function \"%s\" at %s"),
 		   (msym_caller.minsym == NULL
-		    ? "???" : SYMBOL_PRINT_NAME (msym_caller.minsym)),
+		    ? "???" : MSYMBOL_PRINT_NAME (msym_caller.minsym)),
 		   paddress (gdbarch, caller_pc),
 		   (msym_callee.minsym == NULL
-		    ? "???" : SYMBOL_PRINT_NAME (msym_callee.minsym)),
+		    ? "???" : MSYMBOL_PRINT_NAME (msym_callee.minsym)),
 		   paddress (gdbarch, callee_pc));
     }
 
@@ -1060,7 +1060,7 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
 		   gdbarch_bfd_arch_info (gdbarch)->printable_name,
 		   paddress (gdbarch, func_addr),
 		   (msym.minsym == NULL ? "???"
-		    : SYMBOL_PRINT_NAME (msym.minsym)),
+		    : MSYMBOL_PRINT_NAME (msym.minsym)),
 		   gdbarch_bfd_arch_info (caller_gdbarch)->printable_name);
     }
 
@@ -1073,7 +1073,7 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
 					   "requires caller of %s (%s)"),
 		   paddress (gdbarch, func_addr),
 		   (msym.minsym == NULL ? "???"
-		    : SYMBOL_PRINT_NAME (msym.minsym)));
+		    : MSYMBOL_PRINT_NAME (msym.minsym)));
     }
   caller_pc = get_frame_pc (caller_frame);
   call_site = call_site_for_pc (gdbarch, caller_pc);
@@ -1089,9 +1089,9 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
 		   _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
 		     "but the called frame is for %s at %s"),
 		   (target_msym == NULL ? "???"
-					: SYMBOL_PRINT_NAME (target_msym)),
+					: MSYMBOL_PRINT_NAME (target_msym)),
 		   paddress (gdbarch, target_addr),
-		   func_msym == NULL ? "???" : SYMBOL_PRINT_NAME (func_msym),
+		   func_msym == NULL ? "???" : MSYMBOL_PRINT_NAME (func_msym),
 		   paddress (gdbarch, func_addr));
     }
 
@@ -1115,7 +1115,7 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
       throw_error (NO_ENTRY_VALUE_ERROR, _("Cannot find matching parameter "
 					   "at DW_TAG_GNU_call_site %s at %s"),
 		   paddress (gdbarch, caller_pc),
-		   msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym)); 
+		   msym == NULL ? "???" : MSYMBOL_PRINT_NAME (msym)); 
     }
 
   *per_cu_return = call_site->per_cu;
diff --git a/gdb/elfread.c b/gdb/elfread.c
index 47602ef..145d26e 100644
--- a/gdb/elfread.c
+++ b/gdb/elfread.c
@@ -760,10 +760,10 @@ elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr)
   msym = lookup_minimal_symbol_by_pc (addr);
   if (msym.minsym == NULL)
     return 0;
-  if (SYMBOL_VALUE_ADDRESS (msym.minsym) != addr)
+  if (MSYMBOL_VALUE_ADDRESS (msym.minsym) != addr)
     return 0;
   /* minimal symbols have always SYMBOL_OBJ_SECTION non-NULL.  */
-  sect = SYMBOL_OBJ_SECTION (msym.objfile, msym.minsym)->the_bfd_section;
+  sect = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym)->the_bfd_section;
   objfile = msym.objfile;
 
   /* If .plt jumps back to .plt the symbol is still deferred for later
@@ -886,7 +886,7 @@ elf_gnu_ifunc_resolve_by_got (const char *name, CORE_ADDR *addr_p)
 	continue;
       if (MSYMBOL_TYPE (msym) != mst_slot_got_plt)
 	continue;
-      pointer_address = SYMBOL_VALUE_ADDRESS (msym);
+      pointer_address = MSYMBOL_VALUE_ADDRESS (msym);
 
       plt = bfd_get_section_by_name (obfd, ".plt");
       if (plt == NULL)
diff --git a/gdb/findvar.c b/gdb/findvar.c
index c3550b4..daff3f9 100644
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -577,13 +577,13 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
 	if (msym == NULL)
 	  error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var));
 	if (overlay_debugging)
-	  addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
-					   SYMBOL_OBJ_SECTION (lookup_data.objfile,
-							       msym));
+	  addr = symbol_overlayed_address (MSYMBOL_VALUE_ADDRESS (msym),
+					   MSYMBOL_OBJ_SECTION (lookup_data.objfile,
+								msym));
 	else
-	  addr = SYMBOL_VALUE_ADDRESS (msym);
+	  addr = MSYMBOL_VALUE_ADDRESS (msym);
 
-	obj_section = SYMBOL_OBJ_SECTION (lookup_data.objfile, msym);
+	obj_section = MSYMBOL_OBJ_SECTION (lookup_data.objfile, msym);
 	if (obj_section
 	    && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
 	  addr = target_translate_tls_address (obj_section->objfile, addr);
diff --git a/gdb/frame.c b/gdb/frame.c
index 59e31db..c8b60c0 100644
--- a/gdb/frame.c
+++ b/gdb/frame.c
@@ -1752,7 +1752,7 @@ get_prev_frame_1 (struct frame_info *this_frame)
       this_pc_in_block = get_frame_address_in_block (this_frame);
       morestack_msym = lookup_minimal_symbol_by_pc (this_pc_in_block).minsym;
       if (morestack_msym)
-	morestack_name = SYMBOL_LINKAGE_NAME (morestack_msym);
+	morestack_name = MSYMBOL_LINKAGE_NAME (morestack_msym);
       if (!morestack_name || strcmp (morestack_name, "__morestack") != 0)
 	{
 	  if (frame_debug)
@@ -1925,7 +1925,7 @@ inside_main_func (struct frame_info *this_frame)
   /* Make certain that the code, and not descriptor, address is
      returned.  */
   maddr = gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame),
-					      SYMBOL_VALUE_ADDRESS (msymbol),
+					      MSYMBOL_VALUE_ADDRESS (msymbol),
 					      &current_target);
   return maddr == get_frame_func (this_frame);
 }
diff --git a/gdb/frv-tdep.c b/gdb/frv-tdep.c
index 4b725c3..e60202c 100644
--- a/gdb/frv-tdep.c
+++ b/gdb/frv-tdep.c
@@ -1082,8 +1082,8 @@ frv_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
       s = lookup_minimal_symbol_by_pc (call_dest);
 
       if (s.minsym != NULL
-          && SYMBOL_LINKAGE_NAME (s.minsym) != NULL
-	  && strcmp (SYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
+          && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL
+	  && strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
 	{
 	  pc += 4;
 	  return pc;
@@ -1399,7 +1399,7 @@ frv_frame_this_id (struct frame_info *this_frame,
 
   /* Check if the stack is empty.  */
   msym_stack = lookup_minimal_symbol ("_stack", NULL, NULL);
-  if (msym_stack && info->base == SYMBOL_VALUE_ADDRESS (msym_stack))
+  if (msym_stack && info->base == MSYMBOL_VALUE_ADDRESS (msym_stack))
     return;
 
   /* Hopefully the prologue analysis either correctly determined the
diff --git a/gdb/glibc-tdep.c b/gdb/glibc-tdep.c
index 64938b5..25801bf 100644
--- a/gdb/glibc-tdep.c
+++ b/gdb/glibc-tdep.c
@@ -66,7 +66,7 @@ glibc_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
       if (! fixup)
         fixup = lookup_minimal_symbol ("fixup", NULL, resolver.objfile);
 
-      if (fixup && SYMBOL_VALUE_ADDRESS (fixup) == pc)
+      if (fixup && MSYMBOL_VALUE_ADDRESS (fixup) == pc)
 	return frame_unwind_caller_pc (get_current_frame ());
     }
 
diff --git a/gdb/gnu-v2-abi.c b/gdb/gnu-v2-abi.c
index e7f0166..5b7a52d 100644
--- a/gdb/gnu-v2-abi.c
+++ b/gdb/gnu-v2-abi.c
@@ -246,7 +246,7 @@ gnuv2_value_rtti_type (struct value *v, int *full, int *top, int *using_enc)
   /* Try to find a symbol that is the vtable.  */
   minsym=lookup_minimal_symbol_by_pc(vtbl);
   if (minsym.minsym==NULL
-      || (linkage_name=SYMBOL_LINKAGE_NAME (minsym.minsym))==NULL
+      || (linkage_name=MSYMBOL_LINKAGE_NAME (minsym.minsym))==NULL
       || !is_vtable_name (linkage_name))
     return NULL;
 
diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index 1821f18..73ae82b 100644
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -322,7 +322,7 @@ gnuv3_rtti_type (struct value *value,
      If we didn't like this approach, we could instead look in the
      type_info object itself to get the class name.  But this way
      should work just as well, and doesn't read target memory.  */
-  vtable_symbol_name = SYMBOL_DEMANGLED_NAME (vtable_symbol);
+  vtable_symbol_name = MSYMBOL_DEMANGLED_NAME (vtable_symbol);
   if (vtable_symbol_name == NULL
       || strncmp (vtable_symbol_name, "vtable for ", 11))
     {
@@ -1131,7 +1131,7 @@ gnuv3_get_typeid (struct value *value)
       if (minsym == NULL)
 	error (_("could not find typeinfo symbol for '%s'"), typename);
 
-      result = value_at_lazy (typeinfo_type, SYMBOL_VALUE_ADDRESS (minsym));
+      result = value_at_lazy (typeinfo_type, MSYMBOL_VALUE_ADDRESS (minsym));
     }
 
   do_cleanups (cleanup);
@@ -1158,11 +1158,11 @@ gnuv3_get_typename_from_type_info (struct value *type_info_ptr)
 
 #define TYPEINFO_PREFIX "typeinfo for "
 #define TYPEINFO_PREFIX_LEN (sizeof (TYPEINFO_PREFIX) - 1)
-  symname = SYMBOL_DEMANGLED_NAME (typeinfo_sym.minsym);
+  symname = MSYMBOL_DEMANGLED_NAME (typeinfo_sym.minsym);
   if (symname == NULL || strncmp (symname, TYPEINFO_PREFIX,
 				  TYPEINFO_PREFIX_LEN))
     error (_("typeinfo symbol '%s' has unexpected name"),
-	   SYMBOL_LINKAGE_NAME (typeinfo_sym.minsym));
+	   MSYMBOL_LINKAGE_NAME (typeinfo_sym.minsym));
   class_name = symname + TYPEINFO_PREFIX_LEN;
 
   /* Strip off @plt and version suffixes.  */
@@ -1226,7 +1226,7 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
   /* The symbol's demangled name should be something like "virtual
      thunk to FUNCTION", where FUNCTION is the name of the function
      being thunked to.  */
-  thunk_name = SYMBOL_DEMANGLED_NAME (thunk_sym);
+  thunk_name = MSYMBOL_DEMANGLED_NAME (thunk_sym);
   if (thunk_name == NULL || strstr (thunk_name, " thunk to ") == NULL)
     return 0;
 
@@ -1235,7 +1235,7 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
   if (fn_sym == NULL)
     return 0;
 
-  method_stop_pc = SYMBOL_VALUE_ADDRESS (fn_sym);
+  method_stop_pc = MSYMBOL_VALUE_ADDRESS (fn_sym);
 
   /* Some targets have minimal symbols pointing to function descriptors
      (powerpc 64 for example).  Make sure to retrieve the address
diff --git a/gdb/hppa-hpux-tdep.c b/gdb/hppa-hpux-tdep.c
index 88e59ba..4e21fff 100644
--- a/gdb/hppa-hpux-tdep.c
+++ b/gdb/hppa-hpux-tdep.c
@@ -84,7 +84,7 @@ hppa32_hpux_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc)
 
   minsym = lookup_minimal_symbol_by_pc (pc);
   if (minsym.minsym
-      && strcmp (SYMBOL_LINKAGE_NAME (minsym.minsym), ".stub") == 0)
+      && strcmp (MSYMBOL_LINKAGE_NAME (minsym.minsym), ".stub") == 0)
     return 1;
 
   /* Get the unwind descriptor corresponding to PC, return zero
@@ -168,7 +168,7 @@ hppa64_hpux_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc)
   if (! minsym.minsym)
     return 0;
 
-  sec = SYMBOL_OBJ_SECTION (minsym.objfile, minsym.minsym)->the_bfd_section;
+  sec = MSYMBOL_OBJ_SECTION (minsym.objfile, minsym.minsym)->the_bfd_section;
 
   if (bfd_get_section_vma (sec->owner, sec) <= pc
       && pc < (bfd_get_section_vma (sec->owner, sec)
@@ -370,8 +370,8 @@ hppa_hpux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 	  ALL_MSYMBOLS (objfile, msymbol)
 	  {
 	    if (MSYMBOL_TYPE (msymbol) == mst_text
-		&& strcmp (SYMBOL_LINKAGE_NAME (msymbol),
-			    SYMBOL_LINKAGE_NAME (msym.minsym)) == 0)
+		&& strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
+			   MSYMBOL_LINKAGE_NAME (msym.minsym)) == 0)
 	      {
 		function_found = 1;
 		break;
@@ -469,16 +469,16 @@ hppa_hpux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
 	      return orig_pc == pc ? 0 : pc & ~0x3;
 	    }
 
-	  libsym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (stubsym.minsym),
+	  libsym = lookup_minimal_symbol (MSYMBOL_LINKAGE_NAME (stubsym.minsym),
 					  NULL, NULL);
 	  if (libsym == NULL)
 	    {
 	      warning (_("Unable to find library symbol for %s."),
-		       SYMBOL_PRINT_NAME (stubsym.minsym));
+		       MSYMBOL_PRINT_NAME (stubsym.minsym));
 	      return orig_pc == pc ? 0 : pc & ~0x3;
 	    }
 
-	  return SYMBOL_VALUE (libsym);
+	  return MSYMBOL_VALUE (libsym);
 	}
 
       /* Does it look like bl X,%rp or bl X,%r0?  Another way to do a
@@ -973,7 +973,7 @@ hppa64_hpux_search_dummy_call_sequence (struct gdbarch *gdbarch, CORE_ADDR pc,
       gdb_byte buf[2 * HPPA_INSN_SIZE];
       int offset;
 
-      find_pc_partial_function (SYMBOL_VALUE_ADDRESS (msym), &name,
+      find_pc_partial_function (MSYMBOL_VALUE_ADDRESS (msym), &name,
       				&begin, &end);
 
       if (name == NULL || begin == 0 || end == 0)
@@ -1023,19 +1023,19 @@ hppa_hpux_find_import_stub_for_addr (CORE_ADDR funcaddr)
   ALL_OBJFILES (objfile)
     {
       stubsym = lookup_minimal_symbol_solib_trampoline
-	(SYMBOL_LINKAGE_NAME (funsym.minsym), objfile);
+	(MSYMBOL_LINKAGE_NAME (funsym.minsym), objfile);
 
       if (stubsym)
 	{
 	  struct unwind_table_entry *u;
 
-	  u = find_unwind_entry (SYMBOL_VALUE (stubsym));
+	  u = find_unwind_entry (MSYMBOL_VALUE (stubsym));
 	  if (u == NULL 
 	      || (u->stub_unwind.stub_type != IMPORT
 		  && u->stub_unwind.stub_type != IMPORT_SHLIB))
 	    continue;
 
-          stubaddr = SYMBOL_VALUE (stubsym);
+          stubaddr = MSYMBOL_VALUE (stubsym);
 
 	  /* If we found an IMPORT stub, then we can stop searching;
 	     if we found an IMPORT_SHLIB, we want to continue the search
@@ -1096,10 +1096,10 @@ hppa_hpux_find_dummy_bpaddr (CORE_ADDR addr)
       find_pc_partial_function (addr, NULL, &func, NULL);
       ALL_OBJFILE_MSYMBOLS (sec->objfile, msym)
 	{
-	  u = find_unwind_entry (SYMBOL_VALUE_ADDRESS (msym));
-	  if (func != SYMBOL_VALUE_ADDRESS (msym) 
+	  u = find_unwind_entry (MSYMBOL_VALUE_ADDRESS (msym));
+	  if (func != MSYMBOL_VALUE_ADDRESS (msym) 
 	      && (!u || u->stub_unwind.stub_type == 0))
-	    return SYMBOL_VALUE_ADDRESS (msym);
+	    return MSYMBOL_VALUE_ADDRESS (msym);
 	}
     }
 
diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c
index 53f8ed7..a2e0523 100644
--- a/gdb/hppa-tdep.c
+++ b/gdb/hppa-tdep.c
@@ -166,7 +166,7 @@ hppa_symbol_address(const char *sym)
 
   minsym = lookup_minimal_symbol (sym, NULL, NULL);
   if (minsym)
-    return SYMBOL_VALUE_ADDRESS (minsym);
+    return MSYMBOL_VALUE_ADDRESS (minsym);
   else
     return (CORE_ADDR)-1;
 }
@@ -2472,11 +2472,11 @@ hppa_lookup_stub_minimal_symbol (const char *name,
 
   ALL_MSYMBOLS (objfile, msym)
     {
-      if (strcmp (SYMBOL_LINKAGE_NAME (msym), name) == 0)
+      if (strcmp (MSYMBOL_LINKAGE_NAME (msym), name) == 0)
         {
           struct unwind_table_entry *u;
 
-          u = find_unwind_entry (SYMBOL_VALUE (msym));
+          u = find_unwind_entry (MSYMBOL_VALUE (msym));
           if (u != NULL && u->stub_unwind.stub_type == stub_type)
             return msym;
         }
diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
index b159b49..6d1673c 100644
--- a/gdb/i386-tdep.c
+++ b/gdb/i386-tdep.c
@@ -1694,8 +1694,8 @@ i386_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 	  call_dest = call_dest & 0xffffffffU;
  	  s = lookup_minimal_symbol_by_pc (call_dest);
  	  if (s.minsym != NULL
- 	      && SYMBOL_LINKAGE_NAME (s.minsym) != NULL
- 	      && strcmp (SYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
+ 	      && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL
+ 	      && strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
  	    pc += 5;
  	}
     }
@@ -3352,7 +3352,7 @@ i386_pe_skip_trampoline_code (struct frame_info *frame,
 	read_memory_unsigned_integer (pc + 2, 4, byte_order);
       struct minimal_symbol *indsym =
 	indirect ? lookup_minimal_symbol_by_pc (indirect).minsym : 0;
-      const char *symname = indsym ? SYMBOL_LINKAGE_NAME (indsym) : 0;
+      const char *symname = indsym ? MSYMBOL_LINKAGE_NAME (indsym) : 0;
 
       if (symname)
 	{
diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c
index 44000b9..6f16ae0 100644
--- a/gdb/ia64-tdep.c
+++ b/gdb/ia64-tdep.c
@@ -3655,7 +3655,8 @@ ia64_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
 
       minsym = lookup_minimal_symbol_by_pc (addr);
 
-      if (minsym.minsym && is_vtable_name (SYMBOL_LINKAGE_NAME (minsym.minsym)))
+      if (minsym.minsym
+	  && is_vtable_name (MSYMBOL_LINKAGE_NAME (minsym.minsym)))
 	return read_memory_unsigned_integer (addr, 8, byte_order);
     }
 
diff --git a/gdb/infcall.c b/gdb/infcall.c
index 19af044..47b391a 100644
--- a/gdb/infcall.c
+++ b/gdb/infcall.c
@@ -358,7 +358,7 @@ get_function_name (CORE_ADDR funaddr, char *buf, int buf_size)
     struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (funaddr);
 
     if (msymbol.minsym)
-      return SYMBOL_PRINT_NAME (msymbol.minsym);
+      return MSYMBOL_PRINT_NAME (msymbol.minsym);
   }
 
   {
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index 20f8857..e3436f1 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -1332,7 +1332,7 @@ until_next_command (int from_tty)
       if (msymbol.minsym == NULL)
 	error (_("Execution is not within a known function."));
 
-      tp->control.step_range_start = SYMBOL_VALUE_ADDRESS (msymbol.minsym);
+      tp->control.step_range_start = MSYMBOL_VALUE_ADDRESS (msymbol.minsym);
       tp->control.step_range_end = pc;
     }
   else
diff --git a/gdb/jit.c b/gdb/jit.c
index ba0be5e..a21eb7c 100644
--- a/gdb/jit.c
+++ b/gdb/jit.c
@@ -357,7 +357,7 @@ jit_read_descriptor (struct gdbarch *gdbarch,
   if (jit_debug)
     fprintf_unfiltered (gdb_stdlog,
 			"jit_read_descriptor, descriptor_addr = %s\n",
-			paddress (gdbarch, SYMBOL_VALUE_ADDRESS (objf_data->descriptor)));
+			paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (objf_data->descriptor)));
 
   /* Figure out how big the descriptor is on the remote and how to read it.  */
   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
@@ -366,7 +366,7 @@ jit_read_descriptor (struct gdbarch *gdbarch,
   desc_buf = alloca (desc_size);
 
   /* Read the descriptor.  */
-  err = target_read_memory (SYMBOL_VALUE_ADDRESS (objf_data->descriptor),
+  err = target_read_memory (MSYMBOL_VALUE_ADDRESS (objf_data->descriptor),
 			    desc_buf, desc_size);
   if (err)
     {
@@ -1026,12 +1026,12 @@ jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
 	 assume we are not attached to a JIT.  */
       reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name);
       if (reg_symbol.minsym == NULL
-	  || SYMBOL_VALUE_ADDRESS (reg_symbol.minsym) == 0)
+	  || MSYMBOL_VALUE_ADDRESS (reg_symbol.minsym) == 0)
 	return 1;
 
       desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL,
 					   reg_symbol.objfile);
-      if (desc_symbol == NULL || SYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
+      if (desc_symbol == NULL || MSYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
 	return 1;
 
       objf_data = get_jit_objfile_data (reg_symbol.objfile);
@@ -1043,7 +1043,7 @@ jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
   else
     objf_data = get_jit_objfile_data (ps_data->objfile);
 
-  addr = SYMBOL_VALUE_ADDRESS (objf_data->register_code);
+  addr = MSYMBOL_VALUE_ADDRESS (objf_data->register_code);
 
   if (jit_debug)
     fprintf_unfiltered (gdb_stdlog,
diff --git a/gdb/linespec.c b/gdb/linespec.c
index 9468f26..a4344b5 100644
--- a/gdb/linespec.c
+++ b/gdb/linespec.c
@@ -3417,9 +3417,9 @@ minsym_found (struct linespec_state *self, struct objfile *objfile,
   CORE_ADDR pc;
   struct symtab_and_line sal;
 
-  sal = find_pc_sect_line (SYMBOL_VALUE_ADDRESS (msymbol),
+  sal = find_pc_sect_line (MSYMBOL_VALUE_ADDRESS (msymbol),
 			   (struct obj_section *) 0, 0);
-  sal.section = SYMBOL_OBJ_SECTION (objfile, msymbol);
+  sal.section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
 
   /* The minimal symbol might point to a function descriptor;
      resolve it to the actual code address instead.  */
@@ -3431,7 +3431,7 @@ minsym_found (struct linespec_state *self, struct objfile *objfile,
     skip_prologue_sal (&sal);
 
   if (maybe_add_address (self->addr_set, objfile->pspace, sal.pc))
-    add_sal_to_sals (self, result, &sal, SYMBOL_NATURAL_NAME (msymbol), 0);
+    add_sal_to_sals (self, result, &sal, MSYMBOL_NATURAL_NAME (msymbol), 0);
 }
 
 /* A helper struct to pass some data through
@@ -3513,10 +3513,10 @@ add_minsym (struct minimal_symbol *minsym, void *d)
 	       before we decide to discard it.  */
 	    struct gdbarch *gdbarch = get_objfile_arch (info->objfile);
 	    CORE_ADDR addr = gdbarch_convert_from_func_ptr_addr
-			       (gdbarch, SYMBOL_VALUE_ADDRESS (minsym),
+			       (gdbarch, MSYMBOL_VALUE_ADDRESS (minsym),
 				&current_target);
 
-	    if (addr == SYMBOL_VALUE_ADDRESS (minsym))
+	    if (addr == MSYMBOL_VALUE_ADDRESS (minsym))
 	      return;
 	  }
       }
diff --git a/gdb/linux-fork.c b/gdb/linux-fork.c
index bff807e..0b09360 100644
--- a/gdb/linux-fork.c
+++ b/gdb/linux-fork.c
@@ -596,7 +596,7 @@ info_checkpoints_command (char *arg, int from_tty)
 
 	  msym = lookup_minimal_symbol_by_pc (pc);
 	  if (msym.minsym)
-	    printf_filtered (", <%s>", SYMBOL_LINKAGE_NAME (msym.minsym));
+	    printf_filtered (", <%s>", MSYMBOL_LINKAGE_NAME (msym.minsym));
 	}
 
       putchar_filtered ('\n');
diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index 4784a5e..c972e60 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -5001,7 +5001,7 @@ get_signo (const char *name)
   if (ms == NULL)
     return 0;
 
-  if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms), (gdb_byte *) &signo,
+  if (target_read_memory (MSYMBOL_VALUE_ADDRESS (ms), (gdb_byte *) &signo,
 			  sizeof (signo)) != 0)
     return 0;
 
diff --git a/gdb/linux-thread-db.c b/gdb/linux-thread-db.c
index 593fc29..79d1b4b 100644
--- a/gdb/linux-thread-db.c
+++ b/gdb/linux-thread-db.c
@@ -574,7 +574,7 @@ inferior_has_bug (const char *ver_symbol, int ver_major_min, int ver_minor_min)
   if (version_msym == NULL)
     return 0;
 
-  version_addr = SYMBOL_VALUE_ADDRESS (version_msym);
+  version_addr = MSYMBOL_VALUE_ADDRESS (version_msym);
   got = target_read_string (version_addr, &version, 32, &err);
   if (err == 0 && memchr (version, 0, got) == &version[got -1])
     {
diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c
index a147c94..e7cad0d 100644
--- a/gdb/m32c-tdep.c
+++ b/gdb/m32c-tdep.c
@@ -2250,7 +2250,7 @@ m32c_return_value (struct gdbarch *gdbarch,
 	    error (_("The return value is stored in memory at 'mem0', "
 		     "but GDB cannot find\n"
 		     "its address."));
-	  read_memory (SYMBOL_VALUE_ADDRESS (mem0), readbuf, valtype_len);
+	  read_memory (MSYMBOL_VALUE_ADDRESS (mem0), readbuf, valtype_len);
 	}
     }
 
@@ -2282,7 +2282,7 @@ m32c_return_value (struct gdbarch *gdbarch,
 	    error (_("The return value is stored in memory at 'mem0', "
 		     "but GDB cannot find\n"
 		     " its address."));
-	  write_memory (SYMBOL_VALUE_ADDRESS (mem0), writebuf, valtype_len);
+	  write_memory (MSYMBOL_VALUE_ADDRESS (mem0), writebuf, valtype_len);
 	}
     }
 
@@ -2464,7 +2464,7 @@ m32c_m16c_address_to_pointer (struct gdbarch *gdbarch,
                "couldn't find a symbol at that address, to find trampoline."),
                paddress (gdbarch, addr));
 
-      func_name = SYMBOL_LINKAGE_NAME (func_msym.minsym);
+      func_name = MSYMBOL_LINKAGE_NAME (func_msym.minsym);
       tramp_name = xmalloc (strlen (func_name) + 5);
       strcpy (tramp_name, func_name);
       strcat (tramp_name, ".plt");
@@ -2508,7 +2508,7 @@ m32c_m16c_address_to_pointer (struct gdbarch *gdbarch,
       else
 	{
 	  /* The trampoline's address is our pointer.  */
-	  addr = SYMBOL_VALUE_ADDRESS (tramp_msym);
+	  addr = MSYMBOL_VALUE_ADDRESS (tramp_msym);
 	}
     }
 
@@ -2539,7 +2539,7 @@ m32c_m16c_pointer_to_address (struct gdbarch *gdbarch,
 
       if (ptr_msym.minsym)
         {
-          const char *ptr_msym_name = SYMBOL_LINKAGE_NAME (ptr_msym.minsym);
+          const char *ptr_msym_name = MSYMBOL_LINKAGE_NAME (ptr_msym.minsym);
           int len = strlen (ptr_msym_name);
 
           if (len > 4
@@ -2561,7 +2561,7 @@ m32c_m16c_pointer_to_address (struct gdbarch *gdbarch,
               /* If we do have such a symbol, return its value as the
                  function's true address.  */
               if (func_msym)
-                ptr = SYMBOL_VALUE_ADDRESS (func_msym);
+                ptr = MSYMBOL_VALUE_ADDRESS (func_msym);
             }
         }
       else
diff --git a/gdb/m32r-tdep.c b/gdb/m32r-tdep.c
index d96ebed..15d2332 100644
--- a/gdb/m32r-tdep.c
+++ b/gdb/m32r-tdep.c
@@ -844,7 +844,7 @@ m32r_frame_this_id (struct frame_info *this_frame,
 
   /* Check if the stack is empty.  */
   msym_stack = lookup_minimal_symbol ("_stack", NULL, NULL);
-  if (msym_stack && info->base == SYMBOL_VALUE_ADDRESS (msym_stack))
+  if (msym_stack && info->base == MSYMBOL_VALUE_ADDRESS (msym_stack))
     return;
 
   /* Hopefully the prologue analysis either correctly determined the
diff --git a/gdb/m68hc11-tdep.c b/gdb/m68hc11-tdep.c
index b3023ad..600dd52 100644
--- a/gdb/m68hc11-tdep.c
+++ b/gdb/m68hc11-tdep.c
@@ -204,7 +204,7 @@ m68hc11_get_register_info (struct m68hc11_soft_reg *reg, const char *name)
   msymbol = lookup_minimal_symbol (name, NULL, NULL);
   if (msymbol)
     {
-      reg->addr = SYMBOL_VALUE_ADDRESS (msymbol);
+      reg->addr = MSYMBOL_VALUE_ADDRESS (msymbol);
       reg->name = xstrdup (name);
 
       /* Keep track of the address range for soft registers.  */
diff --git a/gdb/machoread.c b/gdb/machoread.c
index 69a234c..2d15a28 100644
--- a/gdb/machoread.c
+++ b/gdb/machoread.c
@@ -441,7 +441,7 @@ macho_resolve_oso_sym_with_minsym (struct objfile *main_objfile, asymbol *sym)
       return 0;
     }
   else
-    return SYMBOL_VALUE_ADDRESS (msym);
+    return MSYMBOL_VALUE_ADDRESS (msym);
 }
 
 /* Add oso file OSO/ABFD as a symbol file.  */
diff --git a/gdb/maint.c b/gdb/maint.c
index 71c4b85..1ce580d 100644
--- a/gdb/maint.c
+++ b/gdb/maint.c
@@ -490,11 +490,11 @@ maintenance_translate_address (char *arg, int from_tty)
 
   if (sym.minsym)
     {
-      const char *symbol_name = SYMBOL_PRINT_NAME (sym.minsym);
+      const char *symbol_name = MSYMBOL_PRINT_NAME (sym.minsym);
       const char *symbol_offset
-	= pulongest (address - SYMBOL_VALUE_ADDRESS (sym.minsym));
+	= pulongest (address - MSYMBOL_VALUE_ADDRESS (sym.minsym));
 
-      sect = SYMBOL_OBJ_SECTION(sym.objfile, sym.minsym);
+      sect = MSYMBOL_OBJ_SECTION(sym.objfile, sym.minsym);
       if (sect != NULL)
 	{
 	  const char *section_name;
diff --git a/gdb/minsyms.c b/gdb/minsyms.c
index 97c31c6..f2d6459 100644
--- a/gdb/minsyms.c
+++ b/gdb/minsyms.c
@@ -116,7 +116,7 @@ add_minsym_to_hash_table (struct minimal_symbol *sym,
   if (sym->hash_next == NULL)
     {
       unsigned int hash
-	= msymbol_hash (SYMBOL_LINKAGE_NAME (sym)) % MINIMAL_SYMBOL_HASH_SIZE;
+	= msymbol_hash (MSYMBOL_LINKAGE_NAME (sym)) % MINIMAL_SYMBOL_HASH_SIZE;
 
       sym->hash_next = table[hash];
       table[hash] = sym;
@@ -131,7 +131,7 @@ add_minsym_to_demangled_hash_table (struct minimal_symbol *sym,
 {
   if (sym->demangled_hash_next == NULL)
     {
-      unsigned int hash = msymbol_hash_iw (SYMBOL_SEARCH_NAME (sym))
+      unsigned int hash = msymbol_hash_iw (MSYMBOL_SEARCH_NAME (sym))
 	% MINIMAL_SYMBOL_HASH_SIZE;
 
       sym->demangled_hash_next = table[hash];
@@ -221,13 +221,13 @@ lookup_minimal_symbol_internal (const char *name, const char *sfile,
 
 		      cmp = (case_sensitivity == case_sensitive_on
 		             ? strcmp : strcasecmp);
-		      match = cmp (SYMBOL_LINKAGE_NAME (msymbol),
+		      match = cmp (MSYMBOL_LINKAGE_NAME (msymbol),
 				   modified_name) == 0;
 		    }
 		  else
 		    {
 		      /* The function respects CASE_SENSITIVITY.  */
-		      match = SYMBOL_MATCHES_SEARCH_NAME (msymbol,
+		      match = MSYMBOL_MATCHES_SEARCH_NAME (msymbol,
 							  modified_name);
 		    }
 
@@ -331,7 +331,7 @@ iterate_over_minimal_symbols (struct objfile *objf, const char *name,
   cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
   while (iter)
     {
-      if (cmp (SYMBOL_LINKAGE_NAME (iter), name) == 0)
+      if (cmp (MSYMBOL_LINKAGE_NAME (iter), name) == 0)
 	(*callback) (iter, user_data);
       iter = iter->hash_next;
     }
@@ -341,7 +341,7 @@ iterate_over_minimal_symbols (struct objfile *objf, const char *name,
   iter = objf->msymbol_demangled_hash[hash];
   while (iter)
     {
-      if (SYMBOL_MATCHES_SEARCH_NAME (iter, name))
+      if (MSYMBOL_MATCHES_SEARCH_NAME (iter, name))
 	(*callback) (iter, user_data);
       iter = iter->demangled_hash_next;
     }
@@ -370,7 +370,7 @@ lookup_minimal_symbol_text (const char *name, struct objfile *objf)
 	       msymbol != NULL && found_symbol == NULL;
 	       msymbol = msymbol->hash_next)
 	    {
-	      if (strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
+	      if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
 		  (MSYMBOL_TYPE (msymbol) == mst_text
 		   || MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc
 		   || MSYMBOL_TYPE (msymbol) == mst_file_text))
@@ -421,8 +421,8 @@ lookup_minimal_symbol_by_pc_name (CORE_ADDR pc, const char *name,
 	       msymbol != NULL;
 	       msymbol = msymbol->hash_next)
 	    {
-	      if (SYMBOL_VALUE_ADDRESS (msymbol) == pc
-		  && strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0)
+	      if (MSYMBOL_VALUE_ADDRESS (msymbol) == pc
+		  && strcmp (MSYMBOL_LINKAGE_NAME (msymbol), name) == 0)
 		return msymbol;
 	    }
 	}
@@ -454,7 +454,7 @@ lookup_minimal_symbol_solib_trampoline (const char *name,
 	       msymbol != NULL && found_symbol == NULL;
 	       msymbol = msymbol->hash_next)
 	    {
-	      if (strcmp (SYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
+	      if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol), name) == 0 &&
 		  MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
 		return msymbol;
 	    }
@@ -545,14 +545,14 @@ lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc,
 	     Warning: this code is trickier than it would appear at first.  */
 
 	  /* Should also require that pc is <= end of objfile.  FIXME!  */
-	  if (pc >= SYMBOL_VALUE_ADDRESS (&msymbol[lo]))
+	  if (pc >= MSYMBOL_VALUE_ADDRESS (&msymbol[lo]))
 	    {
-	      while (SYMBOL_VALUE_ADDRESS (&msymbol[hi]) > pc)
+	      while (MSYMBOL_VALUE_ADDRESS (&msymbol[hi]) > pc)
 		{
 		  /* pc is still strictly less than highest address.  */
 		  /* Note "new" will always be >= lo.  */
 		  new = (lo + hi) / 2;
-		  if ((SYMBOL_VALUE_ADDRESS (&msymbol[new]) >= pc) ||
+		  if ((MSYMBOL_VALUE_ADDRESS (&msymbol[new]) >= pc) ||
 		      (lo == new))
 		    {
 		      hi = new;
@@ -567,8 +567,8 @@ lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc,
 	         hi to point to the last one.  That way we can find the
 	         right symbol if it has an index greater than hi.  */
 	      while (hi < objfile->minimal_symbol_count - 1
-		     && (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
-			 == SYMBOL_VALUE_ADDRESS (&msymbol[hi + 1])))
+		     && (MSYMBOL_VALUE_ADDRESS (&msymbol[hi])
+			 == MSYMBOL_VALUE_ADDRESS (&msymbol[hi + 1])))
 		hi++;
 
 	      /* Skip various undesirable symbols.  */
@@ -598,9 +598,9 @@ lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc,
 		      /* Some types of debug info, such as COFF,
 			 don't fill the bfd_section member, so don't
 			 throw away symbols on those platforms.  */
-		      && SYMBOL_OBJ_SECTION (objfile, &msymbol[hi]) != NULL
+		      && MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi]) != NULL
 		      && (!matching_obj_sections
-			  (SYMBOL_OBJ_SECTION (objfile, &msymbol[hi]),
+			  (MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi]),
 			   section)))
 		    {
 		      hi--;
@@ -616,10 +616,10 @@ lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc,
 		      && MSYMBOL_TYPE (&msymbol[hi - 1]) == want_type
 		      && (MSYMBOL_SIZE (&msymbol[hi])
 			  == MSYMBOL_SIZE (&msymbol[hi - 1]))
-		      && (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
-			  == SYMBOL_VALUE_ADDRESS (&msymbol[hi - 1]))
-		      && (SYMBOL_OBJ_SECTION (objfile, &msymbol[hi])
-			  == SYMBOL_OBJ_SECTION (objfile, &msymbol[hi - 1])))
+		      && (MSYMBOL_VALUE_ADDRESS (&msymbol[hi])
+			  == MSYMBOL_VALUE_ADDRESS (&msymbol[hi - 1]))
+		      && (MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi])
+			  == MSYMBOL_OBJ_SECTION (objfile, &msymbol[hi - 1])))
 		    {
 		      hi--;
 		      continue;
@@ -646,9 +646,9 @@ lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc,
 		     the cancellable variants, but both have sizes.  */
 		  if (hi > 0
 		      && MSYMBOL_SIZE (&msymbol[hi]) != 0
-		      && pc >= (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
+		      && pc >= (MSYMBOL_VALUE_ADDRESS (&msymbol[hi])
 				+ MSYMBOL_SIZE (&msymbol[hi]))
-		      && pc < (SYMBOL_VALUE_ADDRESS (&msymbol[hi - 1])
+		      && pc < (MSYMBOL_VALUE_ADDRESS (&msymbol[hi - 1])
 			       + MSYMBOL_SIZE (&msymbol[hi - 1])))
 		    {
 		      hi--;
@@ -678,7 +678,7 @@ lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc,
 
 	      if (hi >= 0
 		  && MSYMBOL_SIZE (&msymbol[hi]) != 0
-		  && pc >= (SYMBOL_VALUE_ADDRESS (&msymbol[hi])
+		  && pc >= (MSYMBOL_VALUE_ADDRESS (&msymbol[hi])
 			    + MSYMBOL_SIZE (&msymbol[hi])))
 		{
 		  if (best_zero_sized != -1)
@@ -694,8 +694,8 @@ lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc,
 
 	      if (hi >= 0
 		  && ((best_symbol == NULL) ||
-		      (SYMBOL_VALUE_ADDRESS (best_symbol) <
-		       SYMBOL_VALUE_ADDRESS (&msymbol[hi]))))
+		      (MSYMBOL_VALUE_ADDRESS (best_symbol) <
+		       MSYMBOL_VALUE_ADDRESS (&msymbol[hi]))))
 		{
 		  best_symbol = &msymbol[hi];
 		  best_objfile = objfile;
@@ -826,7 +826,7 @@ lookup_minimal_symbol_and_objfile (const char *name)
 	   msym != NULL;
 	   msym = msym->hash_next)
 	{
-	  if (strcmp (SYMBOL_LINKAGE_NAME (msym), name) == 0)
+	  if (strcmp (MSYMBOL_LINKAGE_NAME (msym), name) == 0)
 	    {
 	      result.minsym = msym;
 	      result.objfile = objfile;
@@ -943,11 +943,11 @@ prim_record_minimal_symbol_full (const char *name, int name_len, int copy_name,
       msym_bunch = new;
     }
   msymbol = &msym_bunch->contents[msym_bunch_index];
-  SYMBOL_SET_LANGUAGE (msymbol, language_auto, &objfile->objfile_obstack);
-  SYMBOL_SET_NAMES (msymbol, name, name_len, copy_name, objfile);
+  MSYMBOL_SET_LANGUAGE (msymbol, language_auto, &objfile->objfile_obstack);
+  MSYMBOL_SET_NAMES (msymbol, name, name_len, copy_name, objfile);
 
-  SYMBOL_VALUE_ADDRESS (msymbol) = address;
-  SYMBOL_SECTION (msymbol) = section;
+  MSYMBOL_VALUE_ADDRESS (msymbol) = address;
+  MSYMBOL_SECTION (msymbol) = section;
 
   MSYMBOL_TYPE (msymbol) = ms_type;
   MSYMBOL_TARGET_FLAG_1 (msymbol) = 0;
@@ -993,19 +993,19 @@ compare_minimal_symbols (const void *fn1p, const void *fn2p)
   fn1 = (const struct minimal_symbol *) fn1p;
   fn2 = (const struct minimal_symbol *) fn2p;
 
-  if (SYMBOL_VALUE_ADDRESS (fn1) < SYMBOL_VALUE_ADDRESS (fn2))
+  if (MSYMBOL_VALUE_ADDRESS (fn1) < MSYMBOL_VALUE_ADDRESS (fn2))
     {
       return (-1);		/* addr 1 is less than addr 2.  */
     }
-  else if (SYMBOL_VALUE_ADDRESS (fn1) > SYMBOL_VALUE_ADDRESS (fn2))
+  else if (MSYMBOL_VALUE_ADDRESS (fn1) > MSYMBOL_VALUE_ADDRESS (fn2))
     {
       return (1);		/* addr 1 is greater than addr 2.  */
     }
   else
     /* addrs are equal: sort by name */
     {
-      const char *name1 = SYMBOL_LINKAGE_NAME (fn1);
-      const char *name2 = SYMBOL_LINKAGE_NAME (fn2);
+      const char *name1 = MSYMBOL_LINKAGE_NAME (fn1);
+      const char *name2 = MSYMBOL_LINKAGE_NAME (fn2);
 
       if (name1 && name2)	/* both have names */
 	return strcmp (name1, name2);
@@ -1097,10 +1097,10 @@ compact_minimal_symbols (struct minimal_symbol *msymbol, int mcount,
       copyfrom = copyto = msymbol;
       while (copyfrom < msymbol + mcount - 1)
 	{
-	  if (SYMBOL_VALUE_ADDRESS (copyfrom)
-	      == SYMBOL_VALUE_ADDRESS ((copyfrom + 1))
-	      && strcmp (SYMBOL_LINKAGE_NAME (copyfrom),
-			 SYMBOL_LINKAGE_NAME ((copyfrom + 1))) == 0)
+	  if (MSYMBOL_VALUE_ADDRESS (copyfrom)
+	      == MSYMBOL_VALUE_ADDRESS ((copyfrom + 1))
+	      && strcmp (MSYMBOL_LINKAGE_NAME (copyfrom),
+			 MSYMBOL_LINKAGE_NAME ((copyfrom + 1))) == 0)
 	    {
 	      if (MSYMBOL_TYPE ((copyfrom + 1)) == mst_unknown)
 		{
@@ -1143,7 +1143,7 @@ build_minimal_symbol_hash_tables (struct objfile *objfile)
       add_minsym_to_hash_table (msym, objfile->msymbol_hash);
 
       msym->demangled_hash_next = 0;
-      if (SYMBOL_SEARCH_NAME (msym) != SYMBOL_LINKAGE_NAME (msym))
+      if (MSYMBOL_SEARCH_NAME (msym) != MSYMBOL_LINKAGE_NAME (msym))
 	add_minsym_to_demangled_hash_table (msym,
                                             objfile->msymbol_demangled_hash);
     }
@@ -1279,7 +1279,7 @@ terminate_minimal_symbol_table (struct objfile *objfile)
     memset (m, 0, sizeof (*m));
     /* Don't rely on these enumeration values being 0's.  */
     MSYMBOL_TYPE (m) = mst_unknown;
-    SYMBOL_SET_LANGUAGE (m, language_unknown, &objfile->objfile_obstack);
+    MSYMBOL_SET_LANGUAGE (m, language_unknown, &objfile->objfile_obstack);
   }
 }
 
@@ -1336,24 +1336,24 @@ find_solib_trampoline_target (struct frame_info *frame, CORE_ADDR pc)
       {
 	if ((MSYMBOL_TYPE (msymbol) == mst_text
 	    || MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc)
-	    && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
-		       SYMBOL_LINKAGE_NAME (tsymbol)) == 0)
-	  return SYMBOL_VALUE_ADDRESS (msymbol);
+	    && strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
+		       MSYMBOL_LINKAGE_NAME (tsymbol)) == 0)
+	  return MSYMBOL_VALUE_ADDRESS (msymbol);
 
 	/* Also handle minimal symbols pointing to function descriptors.  */
 	if (MSYMBOL_TYPE (msymbol) == mst_data
-	    && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
-		       SYMBOL_LINKAGE_NAME (tsymbol)) == 0)
+	    && strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
+		       MSYMBOL_LINKAGE_NAME (tsymbol)) == 0)
 	  {
 	    CORE_ADDR func;
 
 	    func = gdbarch_convert_from_func_ptr_addr
 		    (get_objfile_arch (objfile),
-		     SYMBOL_VALUE_ADDRESS (msymbol),
+		     MSYMBOL_VALUE_ADDRESS (msymbol),
 		     &current_target);
 
 	    /* Ignore data symbols that are not function descriptors.  */
-	    if (func != SYMBOL_VALUE_ADDRESS (msymbol))
+	    if (func != MSYMBOL_VALUE_ADDRESS (msymbol))
 	      return func;
 	  }
       }
@@ -1379,25 +1379,26 @@ minimal_symbol_upper_bound (struct bound_minimal_symbol minsym)
      of the section, as the end of the function.  */
 
   if (MSYMBOL_SIZE (minsym.minsym) != 0)
-    return SYMBOL_VALUE_ADDRESS (minsym.minsym) + MSYMBOL_SIZE (minsym.minsym);
+    return MSYMBOL_VALUE_ADDRESS (minsym.minsym) + MSYMBOL_SIZE (minsym.minsym);
 
   /* Step over other symbols at this same address, and symbols in
      other sections, to find the next symbol in this section with a
      different address.  */
 
   msymbol = minsym.minsym;
-  section = SYMBOL_SECTION (msymbol);
-  for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
+  section = MSYMBOL_SECTION (msymbol);
+  for (i = 1; MSYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
     {
-      if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
-	  && SYMBOL_SECTION (msymbol + i) == section)
+      if (MSYMBOL_VALUE_ADDRESS (msymbol + i) != MSYMBOL_VALUE_ADDRESS (msymbol)
+	  && MSYMBOL_SECTION (msymbol + i) == section)
 	break;
     }
 
-  obj_section = SYMBOL_OBJ_SECTION (minsym.objfile, minsym.minsym);
-  if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL
-      && SYMBOL_VALUE_ADDRESS (msymbol + i) < obj_section_endaddr (obj_section))
-    result = SYMBOL_VALUE_ADDRESS (msymbol + i);
+  obj_section = MSYMBOL_OBJ_SECTION (minsym.objfile, minsym.minsym);
+  if (MSYMBOL_LINKAGE_NAME (msymbol + i) != NULL
+      && (MSYMBOL_VALUE_ADDRESS (msymbol + i)
+	  < obj_section_endaddr (obj_section)))
+    result = MSYMBOL_VALUE_ADDRESS (msymbol + i);
   else
     /* We got the start address from the last msymbol in the objfile.
        So the end address is the end of the section.  */
diff --git a/gdb/mips-linux-tdep.c b/gdb/mips-linux-tdep.c
index 8d17839..c957b6f 100644
--- a/gdb/mips-linux-tdep.c
+++ b/gdb/mips-linux-tdep.c
@@ -827,7 +827,7 @@ mips_linux_skip_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
 
   resolver = lookup_minimal_symbol ("__dl_runtime_resolve", NULL, NULL);
 
-  if (resolver && SYMBOL_VALUE_ADDRESS (resolver) == pc)
+  if (resolver && MSYMBOL_VALUE_ADDRESS (resolver) == pc)
     return frame_unwind_caller_pc (get_current_frame ());
 
   return glibc_skip_solib_resolver (gdbarch, pc);
diff --git a/gdb/mips-tdep.c b/gdb/mips-tdep.c
index bcbdcc5..c440249 100644
--- a/gdb/mips-tdep.c
+++ b/gdb/mips-tdep.c
@@ -3602,8 +3602,8 @@ mips_stub_frame_sniffer (const struct frame_unwind *self,
      stub.  The stub for foo is named ".pic.foo".  */
   msym = lookup_minimal_symbol_by_pc (pc);
   if (msym.minsym != NULL
-      && SYMBOL_LINKAGE_NAME (msym.minsym) != NULL
-      && strncmp (SYMBOL_LINKAGE_NAME (msym.minsym), ".pic.", 5) == 0)
+      && MSYMBOL_LINKAGE_NAME (msym.minsym) != NULL
+      && strncmp (MSYMBOL_LINKAGE_NAME (msym.minsym), ".pic.", 5) == 0)
     return 1;
 
   return 0;
@@ -7635,9 +7635,9 @@ mips_skip_pic_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
      which jumps to foo.  */
   msym = lookup_minimal_symbol_by_pc (pc);
   if (msym.minsym == NULL
-      || SYMBOL_VALUE_ADDRESS (msym.minsym) != pc
-      || SYMBOL_LINKAGE_NAME (msym.minsym) == NULL
-      || strncmp (SYMBOL_LINKAGE_NAME (msym.minsym), ".pic.", 5) != 0)
+      || MSYMBOL_VALUE_ADDRESS (msym.minsym) != pc
+      || MSYMBOL_LINKAGE_NAME (msym.minsym) == NULL
+      || strncmp (MSYMBOL_LINKAGE_NAME (msym.minsym), ".pic.", 5) != 0)
     return 0;
 
   /* A two-instruction header.  */
diff --git a/gdb/msp430-tdep.c b/gdb/msp430-tdep.c
index 166f280..91f80b7 100644
--- a/gdb/msp430-tdep.c
+++ b/gdb/msp430-tdep.c
@@ -850,7 +850,7 @@ msp430_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
   if (!bms.minsym)
     return pc;
 
-  stub_name = SYMBOL_LINKAGE_NAME (bms.minsym);
+  stub_name = MSYMBOL_LINKAGE_NAME (bms.minsym);
 
   if (gdbarch_tdep (gdbarch)->code_model == MSP_SMALL_CODE_MODEL
       && msp430_in_return_stub (gdbarch, pc, stub_name))
diff --git a/gdb/objc-lang.c b/gdb/objc-lang.c
index 1b3968f..242a6da 100644
--- a/gdb/objc-lang.c
+++ b/gdb/objc-lang.c
@@ -591,7 +591,7 @@ selectors_info (char *regexp, int from_tty)
   ALL_MSYMBOLS (objfile, msymbol)
     {
       QUIT;
-      name = SYMBOL_NATURAL_NAME (msymbol);
+      name = MSYMBOL_NATURAL_NAME (msymbol);
       if (name
           && (name[0] == '-' || name[0] == '+')
 	  && name[1] == '[')		/* Got a method name.  */
@@ -605,7 +605,7 @@ selectors_info (char *regexp, int from_tty)
 	    {
 	      complaint (&symfile_complaints, 
 			 _("Bad method name '%s'"), 
-			 SYMBOL_NATURAL_NAME (msymbol));
+			 MSYMBOL_NATURAL_NAME (msymbol));
 	      continue;
 	    }
 	  if (regexp == NULL || re_exec(++name) != 0)
@@ -629,7 +629,7 @@ selectors_info (char *regexp, int from_tty)
       ALL_MSYMBOLS (objfile, msymbol)
 	{
 	  QUIT;
-	  name = SYMBOL_NATURAL_NAME (msymbol);
+	  name = MSYMBOL_NATURAL_NAME (msymbol);
 	  if (name &&
 	     (name[0] == '-' || name[0] == '+') &&
 	      name[1] == '[')		/* Got a method name.  */
@@ -742,7 +742,7 @@ classes_info (char *regexp, int from_tty)
   ALL_MSYMBOLS (objfile, msymbol)
     {
       QUIT;
-      name = SYMBOL_NATURAL_NAME (msymbol);
+      name = MSYMBOL_NATURAL_NAME (msymbol);
       if (name &&
 	 (name[0] == '-' || name[0] == '+') &&
 	  name[1] == '[')			/* Got a method name.  */
@@ -766,7 +766,7 @@ classes_info (char *regexp, int from_tty)
       ALL_MSYMBOLS (objfile, msymbol)
 	{
 	  QUIT;
-	  name = SYMBOL_NATURAL_NAME (msymbol);
+	  name = MSYMBOL_NATURAL_NAME (msymbol);
 	  if (name &&
 	     (name[0] == '-' || name[0] == '+') &&
 	      name[1] == '[')			/* Got a method name.  */
@@ -991,7 +991,7 @@ find_methods (char type, const char *class, const char *category,
 
 	  /* Check the symbol name first as this can be done entirely without
 	     sending any query to the target.  */
-	  symname = SYMBOL_NATURAL_NAME (msymbol);
+	  symname = MSYMBOL_NATURAL_NAME (msymbol);
 	  if (symname == NULL)
 	    continue;
 
@@ -1148,7 +1148,7 @@ find_imps (const char *method, VEC (const_char_ptr) **symbol_names)
 
 	  if (msym != NULL) 
 	    VEC_safe_push (const_char_ptr, *symbol_names,
-			   SYMBOL_NATURAL_NAME (msym));
+			   MSYMBOL_NATURAL_NAME (msym));
 	}
     }
 
@@ -1267,7 +1267,7 @@ find_objc_msgsend (void)
 	  continue; 
 	}
 
-      methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func.minsym);
+      methcalls[i].begin = MSYMBOL_VALUE_ADDRESS (func.minsym);
       methcalls[i].end = minimal_symbol_upper_bound (func);
     }
 }
diff --git a/gdb/objfiles.c b/gdb/objfiles.c
index d1f3121..36a956d 100644
--- a/gdb/objfiles.c
+++ b/gdb/objfiles.c
@@ -811,8 +811,9 @@ objfile_relocate1 (struct objfile *objfile,
     struct minimal_symbol *msym;
 
     ALL_OBJFILE_MSYMBOLS (objfile, msym)
-      if (SYMBOL_SECTION (msym) >= 0)
-      SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym));
+      if (MSYMBOL_SECTION (msym) >= 0)
+	MSYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta,
+						  MSYMBOL_SECTION (msym));
   }
   /* Relocating different sections by different amounts may cause the symbols
      to be out of order.  */
diff --git a/gdb/objfiles.h b/gdb/objfiles.h
index 08771d0..af31e96 100644
--- a/gdb/objfiles.h
+++ b/gdb/objfiles.h
@@ -574,7 +574,7 @@ extern void default_iterate_over_objfiles_in_search_order
 /* Traverse all minimal symbols in one objfile.  */
 
 #define	ALL_OBJFILE_MSYMBOLS(objfile, m) \
-    for ((m) = (objfile) -> msymbols; SYMBOL_LINKAGE_NAME(m) != NULL; (m)++)
+    for ((m) = (objfile) -> msymbols; MSYMBOL_LINKAGE_NAME(m) != NULL; (m)++)
 
 /* Traverse all symtabs in all objfiles in the current symbol
    space.  */
diff --git a/gdb/obsd-tdep.c b/gdb/obsd-tdep.c
index 97fe24c..8aa827f 100644
--- a/gdb/obsd-tdep.c
+++ b/gdb/obsd-tdep.c
@@ -29,7 +29,7 @@ obsd_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
   struct minimal_symbol *msym;
 
   msym = lookup_minimal_symbol("_dl_bind", NULL, NULL);
-  if (msym && SYMBOL_VALUE_ADDRESS (msym) == pc)
+  if (msym && MSYMBOL_VALUE_ADDRESS (msym) == pc)
     return frame_unwind_caller_pc (get_current_frame ());
   else
     return find_solib_trampoline_target (get_current_frame (), pc);
diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c
index e6d4b91..205a41d 100644
--- a/gdb/p-valprint.c
+++ b/gdb/p-valprint.c
@@ -227,12 +227,12 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr,
 	  /* If 'symbol_print' is set, we did the work above.  */
 	  if (!options->symbol_print
 	      && (msymbol.minsym != NULL)
-	      && (vt_address == SYMBOL_VALUE_ADDRESS (msymbol.minsym)))
+	      && (vt_address == MSYMBOL_VALUE_ADDRESS (msymbol.minsym)))
 	    {
 	      if (want_space)
 		fputs_filtered (" ", stream);
 	      fputs_filtered ("<", stream);
-	      fputs_filtered (SYMBOL_PRINT_NAME (msymbol.minsym), stream);
+	      fputs_filtered (MSYMBOL_PRINT_NAME (msymbol.minsym), stream);
 	      fputs_filtered (">", stream);
 	      want_space = 1;
 	    }
@@ -248,7 +248,7 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr,
 		fputs_filtered (" ", stream);
 
 	      if (msymbol.minsym != NULL)
-		wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol.minsym),
+		wsym = lookup_symbol (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
 				      block,
 				      VAR_DOMAIN, &is_this_fld);
 
diff --git a/gdb/parse.c b/gdb/parse.c
index 07c1765..f449481 100644
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -502,8 +502,8 @@ write_exp_msymbol (struct bound_minimal_symbol bound_msym)
   struct objfile *objfile = bound_msym.objfile;
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 
-  CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (msymbol);
-  struct obj_section *section = SYMBOL_OBJ_SECTION (objfile, msymbol);
+  CORE_ADDR addr = MSYMBOL_VALUE_ADDRESS (msymbol);
+  struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
   enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
   CORE_ADDR pc;
 
@@ -519,7 +519,7 @@ write_exp_msymbol (struct bound_minimal_symbol bound_msym)
 
       if (ifunc_msym.minsym != NULL
 	  && MSYMBOL_TYPE (ifunc_msym.minsym) == mst_text_gnu_ifunc
-	  && SYMBOL_VALUE_ADDRESS (ifunc_msym.minsym) == pc)
+	  && MSYMBOL_VALUE_ADDRESS (ifunc_msym.minsym) == pc)
 	{
 	  /* A function descriptor has been resolved but PC is still in the
 	     STT_GNU_IFUNC resolver body (such as because inferior does not
diff --git a/gdb/ppc-linux-tdep.c b/gdb/ppc-linux-tdep.c
index fc09560..575575d 100644
--- a/gdb/ppc-linux-tdep.c
+++ b/gdb/ppc-linux-tdep.c
@@ -342,8 +342,8 @@ powerpc_linux_in_dynsym_resolve_code (CORE_ADDR pc)
   /* Check if we are in the resolver.  */
   sym = lookup_minimal_symbol_by_pc (pc);
   if (sym.minsym != NULL
-      && (strcmp (SYMBOL_LINKAGE_NAME (sym.minsym), "__glink") == 0
-	  || strcmp (SYMBOL_LINKAGE_NAME (sym.minsym),
+      && (strcmp (MSYMBOL_LINKAGE_NAME (sym.minsym), "__glink") == 0
+	  || strcmp (MSYMBOL_LINKAGE_NAME (sym.minsym),
 		     "__glink_PLTresolve") == 0))
     return 1;
 
@@ -978,7 +978,7 @@ ppc_linux_spe_context_lookup (struct objfile *objfile)
     {
       spe_context_objfile = objfile;
       spe_context_lm_addr = svr4_fetch_objfile_link_map (objfile);
-      spe_context_offset = SYMBOL_VALUE_ADDRESS (sym);
+      spe_context_offset = MSYMBOL_VALUE_ADDRESS (sym);
       spe_context_cache_ptid = minus_one_ptid;
       spe_context_cache_address = 0;
       return;
diff --git a/gdb/ppc-sysv-tdep.c b/gdb/ppc-sysv-tdep.c
index 0cddf64..10cc68f 100644
--- a/gdb/ppc-sysv-tdep.c
+++ b/gdb/ppc-sysv-tdep.c
@@ -1082,7 +1082,7 @@ convert_code_addr_to_desc_addr (CORE_ADDR code_addr, CORE_ADDR *desc_addr)
   /* Find the minimal symbol that corresponds to CODE_ADDR (should
      have a name of the form ".FN").  */
   dot_fn = lookup_minimal_symbol_by_pc (code_addr);
-  if (dot_fn.minsym == NULL || SYMBOL_LINKAGE_NAME (dot_fn.minsym)[0] != '.')
+  if (dot_fn.minsym == NULL || MSYMBOL_LINKAGE_NAME (dot_fn.minsym)[0] != '.')
     return 0;
   /* Get the section that contains CODE_ADDR.  Need this for the
      "objfile" that it contains.  */
@@ -1093,12 +1093,12 @@ convert_code_addr_to_desc_addr (CORE_ADDR code_addr, CORE_ADDR *desc_addr)
      address.  Only look for the minimal symbol in ".FN"'s object file
      - avoids problems when two object files (i.e., shared libraries)
      contain a minimal symbol with the same name.  */
-  fn = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (dot_fn.minsym) + 1, NULL,
+  fn = lookup_minimal_symbol (MSYMBOL_LINKAGE_NAME (dot_fn.minsym) + 1, NULL,
 			      dot_fn_section->objfile);
   if (fn == NULL)
     return 0;
   /* Found a descriptor.  */
-  (*desc_addr) = SYMBOL_VALUE_ADDRESS (fn);
+  (*desc_addr) = MSYMBOL_VALUE_ADDRESS (fn);
   return 1;
 }
 
diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index 751cd2b..4792ed5 100644
--- a/gdb/printcmd.c
+++ b/gdb/printcmd.c
@@ -691,7 +691,7 @@ build_address_symbolic (struct gdbarch *gdbarch,
 
   if (msymbol != NULL)
     {
-      if (SYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
+      if (MSYMBOL_VALUE_ADDRESS (msymbol) > name_location || symbol == NULL)
 	{
 	  /* If this is a function (i.e. a code address), strip out any
 	     non-address bits.  For instance, display a pointer to the
@@ -707,11 +707,11 @@ build_address_symbolic (struct gdbarch *gdbarch,
 	  /* The msymbol is closer to the address than the symbol;
 	     use the msymbol instead.  */
 	  symbol = 0;
-	  name_location = SYMBOL_VALUE_ADDRESS (msymbol);
+	  name_location = MSYMBOL_VALUE_ADDRESS (msymbol);
 	  if (do_demangle || asm_demangle)
-	    name_temp = SYMBOL_PRINT_NAME (msymbol);
+	    name_temp = MSYMBOL_PRINT_NAME (msymbol);
 	  else
-	    name_temp = SYMBOL_LINKAGE_NAME (msymbol);
+	    name_temp = MSYMBOL_LINKAGE_NAME (msymbol);
 	}
     }
   if (symbol == NULL && msymbol == NULL)
@@ -1135,10 +1135,10 @@ sym_info (char *arg, int from_tty)
 	struct cleanup *old_chain;
 
 	matches = 1;
-	offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
+	offset = sect_addr - MSYMBOL_VALUE_ADDRESS (msymbol);
 	mapped = section_is_mapped (osect) ? _("mapped") : _("unmapped");
 	sec_name = osect->the_bfd_section->name;
-	msym_name = SYMBOL_PRINT_NAME (msymbol);
+	msym_name = MSYMBOL_PRINT_NAME (msymbol);
 
 	/* Don't print the offset if it is zero.
 	   We assume there's no need to handle i18n of "sym + offset".  */
@@ -1234,7 +1234,7 @@ address_info (char *exp, int from_tty)
 	  struct objfile *objfile = msymbol.objfile;
 
 	  gdbarch = get_objfile_arch (objfile);
-	  load_addr = SYMBOL_VALUE_ADDRESS (msymbol.minsym);
+	  load_addr = MSYMBOL_VALUE_ADDRESS (msymbol.minsym);
 
 	  printf_filtered ("Symbol \"");
 	  fprintf_symbol_filtered (gdb_stdout, exp,
@@ -1242,7 +1242,7 @@ address_info (char *exp, int from_tty)
 	  printf_filtered ("\" is at ");
 	  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
 	  printf_filtered (" in a file compiled without debugging");
-	  section = SYMBOL_OBJ_SECTION (objfile, msymbol.minsym);
+	  section = MSYMBOL_OBJ_SECTION (objfile, msymbol.minsym);
 	  if (section_is_overlay (section))
 	    {
 	      load_addr = overlay_unmapped_address (load_addr, section);
@@ -1375,8 +1375,8 @@ address_info (char *exp, int from_tty)
 	  printf_filtered ("unresolved");
 	else
 	  {
-	    section = SYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
-	    load_addr = SYMBOL_VALUE_ADDRESS (msym.minsym);
+	    section = MSYMBOL_OBJ_SECTION (msym.objfile, msym.minsym);
+	    load_addr = MSYMBOL_VALUE_ADDRESS (msym.minsym);
 
 	    if (section
 		&& (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
diff --git a/gdb/proc-service.c b/gdb/proc-service.c
index f76ad4b..a79f628 100644
--- a/gdb/proc-service.c
+++ b/gdb/proc-service.c
@@ -207,7 +207,7 @@ ps_pglobal_lookup (gdb_ps_prochandle_t ph, const char *obj,
     result = PS_NOSYM;
   else
     {
-      *sym_addr = core_addr_to_ps_addr (SYMBOL_VALUE_ADDRESS (ms));
+      *sym_addr = core_addr_to_ps_addr (MSYMBOL_VALUE_ADDRESS (ms));
       result = PS_OK;
     }
 
diff --git a/gdb/psymtab.c b/gdb/psymtab.c
index 8eac5e1..760519c 100644
--- a/gdb/psymtab.c
+++ b/gdb/psymtab.c
@@ -266,7 +266,7 @@ find_pc_sect_psymtab_closer (struct objfile *objfile,
 	  p = find_pc_sect_psymbol (objfile, tpst, pc, section);
 	  if (p != NULL
 	      && SYMBOL_VALUE_ADDRESS (p)
-	      == SYMBOL_VALUE_ADDRESS (msymbol))
+	      == MSYMBOL_VALUE_ADDRESS (msymbol))
 	    return tpst;
 
 	  /* Also accept the textlow value of a psymtab as a
@@ -331,7 +331,7 @@ find_pc_sect_psymtab (struct objfile *objfile, CORE_ADDR pc,
 	      p = find_pc_sect_psymbol (objfile, pst, pc, section);
 	      if (!p
 		  || SYMBOL_VALUE_ADDRESS (p)
-		  != SYMBOL_VALUE_ADDRESS (msymbol))
+		  != MSYMBOL_VALUE_ADDRESS (msymbol))
 		goto next;
 	    }
 
diff --git a/gdb/python/py-framefilter.c b/gdb/python/py-framefilter.c
index 871c245..918d26d 100644
--- a/gdb/python/py-framefilter.c
+++ b/gdb/python/py-framefilter.c
@@ -1192,7 +1192,7 @@ py_print_frame (PyObject *filter, int flags, enum py_frame_args args_type,
 
 		  msymbol = lookup_minimal_symbol_by_pc (addr);
 		  if (msymbol.minsym != NULL)
-		    function = SYMBOL_PRINT_NAME (msymbol.minsym);
+		    function = MSYMBOL_PRINT_NAME (msymbol.minsym);
 		}
 	      else if (py_func != Py_None)
 		{
diff --git a/gdb/ravenscar-thread.c b/gdb/ravenscar-thread.c
index 26b8171..30fc265 100644
--- a/gdb/ravenscar-thread.c
+++ b/gdb/ravenscar-thread.c
@@ -163,7 +163,7 @@ get_running_thread_id (void)
   if (!object_msym)
     return 0;
 
-  object_addr = SYMBOL_VALUE_ADDRESS (object_msym);
+  object_addr = MSYMBOL_VALUE_ADDRESS (object_msym);
   object_size = TYPE_LENGTH (builtin_type_void_data_ptr);
   buf_size = object_size;
   buf = alloca (buf_size);
diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c
index 68f40c8..0a56b75 100644
--- a/gdb/record-btrace.c
+++ b/gdb/record-btrace.c
@@ -484,7 +484,8 @@ btrace_func_history (struct btrace_thread_info *btinfo, struct ui_out *uiout,
       if (bfun->sym != NULL)
 	ui_out_field_string (uiout, "function", SYMBOL_PRINT_NAME (bfun->sym));
       else if (bfun->msym != NULL)
-	ui_out_field_string (uiout, "function", SYMBOL_PRINT_NAME (bfun->msym));
+	ui_out_field_string (uiout, "function",
+			     MSYMBOL_PRINT_NAME (bfun->msym));
       ui_out_text (uiout, "\n");
     }
 }
diff --git a/gdb/remote.c b/gdb/remote.c
index a2e8a01..6ccf8fe 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -3722,7 +3722,7 @@ remote_check_symbols (void)
       else
 	{
 	  int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
-	  CORE_ADDR sym_addr = SYMBOL_VALUE_ADDRESS (sym);
+	  CORE_ADDR sym_addr = MSYMBOL_VALUE_ADDRESS (sym);
 
 	  /* If this is a function address, return the start of code
 	     instead of any data function descriptor.  */
diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c
index c561bc8..d9f80ee 100644
--- a/gdb/rs6000-tdep.c
+++ b/gdb/rs6000-tdep.c
@@ -2158,9 +2158,9 @@ rs6000_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
          to __eabi in case the GCC option "-fleading-underscore" was
 	 used to compile the program.  */
       if (s.minsym != NULL
-          && SYMBOL_LINKAGE_NAME (s.minsym) != NULL
-	  && (strcmp (SYMBOL_LINKAGE_NAME (s.minsym), "__eabi") == 0
-	      || strcmp (SYMBOL_LINKAGE_NAME (s.minsym), "___eabi") == 0))
+          && MSYMBOL_LINKAGE_NAME (s.minsym) != NULL
+	  && (strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "__eabi") == 0
+	      || strcmp (MSYMBOL_LINKAGE_NAME (s.minsym), "___eabi") == 0))
 	pc += 4;
     }
   return pc;
@@ -2244,7 +2244,7 @@ rs6000_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
   msymbol = lookup_minimal_symbol_by_pc (pc);
   if (msymbol.minsym
       && rs6000_in_solib_return_trampoline (gdbarch, pc,
-					    SYMBOL_LINKAGE_NAME (msymbol.minsym)))
+					    MSYMBOL_LINKAGE_NAME (msymbol.minsym)))
     {
       /* Double-check that the third instruction from PC is relative "b".  */
       op = read_memory_integer (pc + 8, 4, byte_order);
diff --git a/gdb/sh64-tdep.c b/gdb/sh64-tdep.c
index 9425e9f..eb661db 100644
--- a/gdb/sh64-tdep.c
+++ b/gdb/sh64-tdep.c
@@ -224,7 +224,7 @@ sh64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
   if (((elf_symbol_type *)(sym))->internal_elf_sym.st_other == STO_SH5_ISA32)
     {
       MSYMBOL_TARGET_FLAG_1 (msym) = 1;
-      SYMBOL_VALUE_ADDRESS (msym) |= 1;
+      MSYMBOL_VALUE_ADDRESS (msym) |= 1;
     }
 }
 
diff --git a/gdb/sol2-tdep.c b/gdb/sol2-tdep.c
index b9dcd26..d1b4c02 100644
--- a/gdb/sol2-tdep.c
+++ b/gdb/sol2-tdep.c
@@ -30,7 +30,7 @@ sol2_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
   struct minimal_symbol *msym;
 
   msym = lookup_minimal_symbol("elf_bndr", NULL, NULL);
-  if (msym && SYMBOL_VALUE_ADDRESS (msym) == pc)
+  if (msym && MSYMBOL_VALUE_ADDRESS (msym) == pc)
     return frame_unwind_caller_pc (get_current_frame ());
 
   return 0;
diff --git a/gdb/solib-dsbt.c b/gdb/solib-dsbt.c
index 4fe24f8..f938abd 100644
--- a/gdb/solib-dsbt.c
+++ b/gdb/solib-dsbt.c
@@ -575,7 +575,7 @@ lm_base (void)
 
   if (got_sym != 0)
     {
-      addr = SYMBOL_VALUE_ADDRESS (got_sym);
+      addr = MSYMBOL_VALUE_ADDRESS (got_sym);
       if (solib_dsbt_debug)
 	fprintf_unfiltered (gdb_stdlog,
 			    "lm_base: get addr %x by _GLOBAL_OFFSET_TABLE_.\n",
diff --git a/gdb/solib-frv.c b/gdb/solib-frv.c
index 65c7e01..4c2071b 100644
--- a/gdb/solib-frv.c
+++ b/gdb/solib-frv.c
@@ -292,7 +292,7 @@ lm_base (void)
       return 0;
     }
 
-  addr = SYMBOL_VALUE_ADDRESS (got_sym) + 8;
+  addr = MSYMBOL_VALUE_ADDRESS (got_sym) + 8;
 
   if (solib_frv_debug)
     fprintf_unfiltered (gdb_stdlog,
@@ -927,7 +927,7 @@ main_got (void)
   if (got_sym == 0)
     return 0;
 
-  return SYMBOL_VALUE_ADDRESS (got_sym);
+  return MSYMBOL_VALUE_ADDRESS (got_sym);
 }
 
 /* Find the global pointer for the given function address ADDR.  */
diff --git a/gdb/solib-irix.c b/gdb/solib-irix.c
index 0dbbb1b..6d20955 100644
--- a/gdb/solib-irix.c
+++ b/gdb/solib-irix.c
@@ -285,9 +285,9 @@ locate_base (void)
   CORE_ADDR address = 0;
 
   msymbol = lookup_minimal_symbol (DEBUG_BASE, NULL, symfile_objfile);
-  if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
+  if ((msymbol != NULL) && (MSYMBOL_VALUE_ADDRESS (msymbol) != 0))
     {
-      address = SYMBOL_VALUE_ADDRESS (msymbol);
+      address = MSYMBOL_VALUE_ADDRESS (msymbol);
     }
   return (address);
 }
diff --git a/gdb/solib-som.c b/gdb/solib-som.c
index fd0ff81..a142388 100644
--- a/gdb/solib-som.c
+++ b/gdb/solib-som.c
@@ -219,7 +219,7 @@ som_solib_create_inferior_hook (int from_tty)
   if (msymbol == NULL)
     goto keep_going;
 
-  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+  anaddr = MSYMBOL_VALUE_ADDRESS (msymbol);
   store_unsigned_integer (buf, 4, byte_order, ptid_get_pid (inferior_ptid));
   status = target_write_memory (anaddr, buf, 4);
   if (status != 0)
@@ -251,16 +251,16 @@ Suggest linking with /opt/langtools/lib/end.o.\n\
 GDB will be unable to track shl_load/shl_unload calls"));
       goto keep_going;
     }
-  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+  anaddr = MSYMBOL_VALUE_ADDRESS (msymbol);
   dld_cache.hook.address = anaddr;
 
   /* Grrr, this might not be an export symbol!  We have to find the
      export stub.  */
-  msymbol = hppa_lookup_stub_minimal_symbol (SYMBOL_LINKAGE_NAME (msymbol),
+  msymbol = hppa_lookup_stub_minimal_symbol (MSYMBOL_LINKAGE_NAME (msymbol),
                                              EXPORT);
   if (msymbol != NULL)
     {
-      anaddr = SYMBOL_VALUE (msymbol);
+      anaddr = MSYMBOL_VALUE (msymbol);
       dld_cache.hook_stub.address = anaddr;
     }
   store_unsigned_integer (buf, 4, byte_order, anaddr);
@@ -274,7 +274,7 @@ Suggest linking with /opt/langtools/lib/end.o.\n\
 GDB will be unable to track shl_load/shl_unload calls"));
       goto keep_going;
     }
-  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+  anaddr = MSYMBOL_VALUE_ADDRESS (msymbol);
   status = target_write_memory (anaddr, buf, 4);
 
   /* Now set a shlib_event breakpoint at __d_trap so we can track
@@ -289,7 +289,7 @@ GDB will be unable to track shl_load/shl_unload calls"));
       goto keep_going;
     }
   create_solib_event_breakpoint (target_gdbarch (),
-				 SYMBOL_VALUE_ADDRESS (msymbol));
+				 MSYMBOL_VALUE_ADDRESS (msymbol));
 
   /* We have all the support usually found in end.o, so we can track
      shl_load and shl_unload calls.  */
@@ -305,7 +305,7 @@ keep_going:
       error (_("Unable to find __dld_flags symbol in object file."));
     }
 
-  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+  anaddr = MSYMBOL_VALUE_ADDRESS (msymbol);
 
   /* Read the current contents.  */
   status = target_read_memory (anaddr, buf, 4);
@@ -350,7 +350,7 @@ manpage for methods to privately map shared library text."));
   if (msymbol == NULL)
     error (_("Unable to find _start symbol in object file."));
 
-  anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
+  anaddr = MSYMBOL_VALUE_ADDRESS (msymbol);
 
   /* Make the breakpoint at "_start" a shared library event breakpoint.  */
   create_solib_event_breakpoint (target_gdbarch (), anaddr);
@@ -384,7 +384,7 @@ som_solib_desire_dynamic_linker_symbols (void)
     dld_msymbol = lookup_minimal_symbol ("shl_load", NULL, objfile);
     if (dld_msymbol != NULL)
       {
-	dld_cache.load.address = SYMBOL_VALUE (dld_msymbol);
+	dld_cache.load.address = MSYMBOL_VALUE (dld_msymbol);
 	dld_cache.load.unwind = find_unwind_entry (dld_cache.load.address);
       }
 
@@ -394,10 +394,10 @@ som_solib_desire_dynamic_linker_symbols (void)
       {
 	if (MSYMBOL_TYPE (dld_msymbol) == mst_solib_trampoline)
 	  {
-	    u = find_unwind_entry (SYMBOL_VALUE (dld_msymbol));
+	    u = find_unwind_entry (MSYMBOL_VALUE (dld_msymbol));
 	    if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
 	      {
-		dld_cache.load_stub.address = SYMBOL_VALUE (dld_msymbol);
+		dld_cache.load_stub.address = MSYMBOL_VALUE (dld_msymbol);
 		dld_cache.load_stub.unwind = u;
 	      }
 	  }
@@ -406,7 +406,7 @@ som_solib_desire_dynamic_linker_symbols (void)
     dld_msymbol = lookup_minimal_symbol ("shl_unload", NULL, objfile);
     if (dld_msymbol != NULL)
       {
-	dld_cache.unload.address = SYMBOL_VALUE (dld_msymbol);
+	dld_cache.unload.address = MSYMBOL_VALUE (dld_msymbol);
 	dld_cache.unload.unwind = find_unwind_entry (dld_cache.unload.address);
 
 	/* ??rehrauer: I'm not sure exactly what this is, but it appears
@@ -433,10 +433,10 @@ som_solib_desire_dynamic_linker_symbols (void)
       {
 	if (MSYMBOL_TYPE (dld_msymbol) == mst_solib_trampoline)
 	  {
-	    u = find_unwind_entry (SYMBOL_VALUE (dld_msymbol));
+	    u = find_unwind_entry (MSYMBOL_VALUE (dld_msymbol));
 	    if ((u != NULL) && (u->stub_unwind.stub_type == EXPORT))
 	      {
-		dld_cache.unload_stub.address = SYMBOL_VALUE (dld_msymbol);
+		dld_cache.unload_stub.address = MSYMBOL_VALUE (dld_msymbol);
 		dld_cache.unload_stub.unwind = u;
 	      }
 	  }
@@ -534,7 +534,7 @@ link_map_start (void)
   sym = lookup_minimal_symbol ("__dld_flags", NULL, NULL);
   if (!sym)
     error (_("Unable to find __dld_flags symbol in object file."));
-  addr = SYMBOL_VALUE_ADDRESS (sym);
+  addr = MSYMBOL_VALUE_ADDRESS (sym);
   read_memory (addr, buf, 4);
   dld_flags = extract_unsigned_integer (buf, 4, byte_order);
   if ((dld_flags & DLD_FLAGS_LISTVALID) == 0)
@@ -551,10 +551,10 @@ link_map_start (void)
 	  error (_("Unable to find dynamic library list."));
 	  return 0;
 	}
-      addr = SYMBOL_VALUE_ADDRESS (sym) - 8;
+      addr = MSYMBOL_VALUE_ADDRESS (sym) - 8;
     }
   else
-    addr = SYMBOL_VALUE_ADDRESS (sym);
+    addr = MSYMBOL_VALUE_ADDRESS (sym);
 
   read_memory (addr, buf, 4);
   addr = extract_unsigned_integer (buf, 4, byte_order);
diff --git a/gdb/solib-spu.c b/gdb/solib-spu.c
index 626cc8f..998da5c 100644
--- a/gdb/solib-spu.c
+++ b/gdb/solib-spu.c
@@ -418,7 +418,7 @@ spu_enable_break (struct objfile *objfile)
   /* Place a solib_event breakpoint on the symbol.  */
   if (spe_event_sym)
     {
-      CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (spe_event_sym);
+      CORE_ADDR addr = MSYMBOL_VALUE_ADDRESS (spe_event_sym);
 
       addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (), addr,
                                                  &current_target);
@@ -448,7 +448,7 @@ ocl_enable_break (struct objfile *objfile)
   if (event_sym && addr_sym)
     {
       /* Place a solib_event breakpoint on the symbol.  */
-      CORE_ADDR event_addr = SYMBOL_VALUE_ADDRESS (event_sym);
+      CORE_ADDR event_addr = MSYMBOL_VALUE_ADDRESS (event_sym);
       create_solib_event_breakpoint (get_objfile_arch (objfile), event_addr);
 
       /* Store the address of the symbol that will point to OpenCL program
@@ -459,7 +459,7 @@ ocl_enable_break (struct objfile *objfile)
 		  &objfile->objfile_obstack,
 		  objfile->sections_end - objfile->sections,
 		  CORE_ADDR);
-	  *ocl_program_addr_base = SYMBOL_VALUE_ADDRESS (addr_sym);
+	  *ocl_program_addr_base = MSYMBOL_VALUE_ADDRESS (addr_sym);
 	  set_objfile_data (objfile, ocl_program_data_key,
 			    ocl_program_addr_base);
         }
diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c
index ddbbd94..6d419ad 100644
--- a/gdb/solib-svr4.c
+++ b/gdb/solib-svr4.c
@@ -821,7 +821,7 @@ elf_locate_base (void)
      conventionally named _r_debug, as a last resort.  */
   msymbol = lookup_minimal_symbol ("_r_debug", NULL, symfile_objfile);
   if (msymbol != NULL)
-    return SYMBOL_VALUE_ADDRESS (msymbol);
+    return MSYMBOL_VALUE_ADDRESS (msymbol);
 
   /* DT_DEBUG entry not found.  */
   return 0;
@@ -2350,9 +2350,9 @@ enable_break (struct svr4_info *info, int from_tty)
   for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
     {
       msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
-      if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
+      if ((msymbol != NULL) && (MSYMBOL_VALUE_ADDRESS (msymbol) != 0))
 	{
-	  sym_addr = SYMBOL_VALUE_ADDRESS (msymbol);
+	  sym_addr = MSYMBOL_VALUE_ADDRESS (msymbol);
 	  sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
 							 sym_addr,
 							 &current_target);
@@ -2366,9 +2366,9 @@ enable_break (struct svr4_info *info, int from_tty)
       for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
 	{
 	  msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
-	  if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
+	  if ((msymbol != NULL) && (MSYMBOL_VALUE_ADDRESS (msymbol) != 0))
 	    {
-	      sym_addr = SYMBOL_VALUE_ADDRESS (msymbol);
+	      sym_addr = MSYMBOL_VALUE_ADDRESS (msymbol);
 	      sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
 							     sym_addr,
 							     &current_target);
diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c
index 46f3e2c..7c3f802 100644
--- a/gdb/spu-tdep.c
+++ b/gdb/spu-tdep.c
@@ -1767,10 +1767,10 @@ spu_get_overlay_table (struct objfile *objfile)
   if (!ovly_buf_table_msym)
     return NULL;
 
-  ovly_table_base = SYMBOL_VALUE_ADDRESS (ovly_table_msym);
+  ovly_table_base = MSYMBOL_VALUE_ADDRESS (ovly_table_msym);
   ovly_table_size = MSYMBOL_SIZE (ovly_table_msym);
 
-  ovly_buf_table_base = SYMBOL_VALUE_ADDRESS (ovly_buf_table_msym);
+  ovly_buf_table_base = MSYMBOL_VALUE_ADDRESS (ovly_buf_table_msym);
   ovly_buf_table_size = MSYMBOL_SIZE (ovly_buf_table_msym);
 
   ovly_table = xmalloc (ovly_table_size);
@@ -1922,8 +1922,8 @@ spu_catch_start (struct objfile *objfile)
 
   /* If we have debugging information, try to use it -- this
      will allow us to properly skip the prologue.  */
-  pc = SYMBOL_VALUE_ADDRESS (minsym);
-  symtab = find_pc_sect_symtab (pc, SYMBOL_OBJ_SECTION (objfile, minsym));
+  pc = MSYMBOL_VALUE_ADDRESS (minsym);
+  symtab = find_pc_sect_symtab (pc, MSYMBOL_OBJ_SECTION (objfile, minsym));
   if (symtab != NULL)
     {
       struct blockvector *bv = BLOCKVECTOR (symtab);
@@ -2000,7 +2000,7 @@ flush_ea_cache (void)
       type = objfile_type (obj)->builtin_void;
       type = lookup_function_type (type);
       type = lookup_pointer_type (type);
-      addr = SYMBOL_VALUE_ADDRESS (msymbol);
+      addr = MSYMBOL_VALUE_ADDRESS (msymbol);
 
       call_function_by_hand (value_from_pointer (type, addr), 0, NULL);
     }
diff --git a/gdb/stabsread.c b/gdb/stabsread.c
index da95a7e..2d50780 100644
--- a/gdb/stabsread.c
+++ b/gdb/stabsread.c
@@ -1178,7 +1178,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
 		(gdbarch, SYMBOL_LINKAGE_NAME (sym));
 
 	      SYMBOL_SET_LINKAGE_NAME (sym, new_name);
-	      SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
+	      SYMBOL_VALUE_ADDRESS (sym) = MSYMBOL_VALUE_ADDRESS (msym);
 	    }
 	}
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
@@ -1370,7 +1370,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
 		(gdbarch, SYMBOL_LINKAGE_NAME (sym));
 
 	      SYMBOL_SET_LINKAGE_NAME (sym, new_name);
-	      SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
+	      SYMBOL_VALUE_ADDRESS (sym) = MSYMBOL_VALUE_ADDRESS (msym);
 	    }
 	}
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
@@ -4654,11 +4654,11 @@ scan_file_globals (struct objfile *objfile)
 	  /* Get the hash index and check all the symbols
 	     under that hash index.  */
 
-	  hash = hashname (SYMBOL_LINKAGE_NAME (msymbol));
+	  hash = hashname (MSYMBOL_LINKAGE_NAME (msymbol));
 
 	  for (sym = global_sym_chain[hash]; sym;)
 	    {
-	      if (strcmp (SYMBOL_LINKAGE_NAME (msymbol),
+	      if (strcmp (MSYMBOL_LINKAGE_NAME (msymbol),
 			  SYMBOL_LINKAGE_NAME (sym)) == 0)
 		{
 		  /* Splice this symbol out of the hash chain and
@@ -4680,14 +4680,14 @@ scan_file_globals (struct objfile *objfile)
 		      if (SYMBOL_CLASS (sym) == LOC_BLOCK)
 			{
 			  fix_common_block (sym,
-					    SYMBOL_VALUE_ADDRESS (msymbol));
+					    MSYMBOL_VALUE_ADDRESS (msymbol));
 			}
 		      else
 			{
 			  SYMBOL_VALUE_ADDRESS (sym)
-			    = SYMBOL_VALUE_ADDRESS (msymbol);
+			    = MSYMBOL_VALUE_ADDRESS (msymbol);
 			}
-		      SYMBOL_SECTION (sym) = SYMBOL_SECTION (msymbol);
+		      SYMBOL_SECTION (sym) = MSYMBOL_SECTION (msymbol);
 		    }
 
 		  if (prev)
diff --git a/gdb/stack.c b/gdb/stack.c
index cd4ac7a..a6ec7d8 100644
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -1076,14 +1076,14 @@ find_frame_funname (struct frame_info *frame, char **funname,
 	memset (&msymbol, 0, sizeof (msymbol));
 
       if (msymbol.minsym != NULL
-	  && (SYMBOL_VALUE_ADDRESS (msymbol.minsym)
+	  && (MSYMBOL_VALUE_ADDRESS (msymbol.minsym)
 	      > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
 	{
 	  /* We also don't know anything about the function besides
 	     its address and name.  */
 	  func = 0;
-	  *funname = xstrdup (SYMBOL_PRINT_NAME (msymbol.minsym));
-	  *funlang = SYMBOL_LANGUAGE (msymbol.minsym);
+	  *funname = xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym));
+	  *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
 	}
       else
 	{
@@ -1119,8 +1119,8 @@ find_frame_funname (struct frame_info *frame, char **funname,
       msymbol = lookup_minimal_symbol_by_pc (pc);
       if (msymbol.minsym != NULL)
 	{
-	  *funname = xstrdup (SYMBOL_PRINT_NAME (msymbol.minsym));
-	  *funlang = SYMBOL_LANGUAGE (msymbol.minsym);
+	  *funname = xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym));
+	  *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
 	}
     }
 }
@@ -1457,8 +1457,8 @@ frame_info (char *addr_exp, int from_tty)
       msymbol = lookup_minimal_symbol_by_pc (frame_pc);
       if (msymbol.minsym != NULL)
 	{
-	  funname = SYMBOL_PRINT_NAME (msymbol.minsym);
-	  funlang = SYMBOL_LANGUAGE (msymbol.minsym);
+	  funname = MSYMBOL_PRINT_NAME (msymbol.minsym);
+	  funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
 	}
     }
   calling_frame_info = get_prev_frame (fi);
diff --git a/gdb/symfile.c b/gdb/symfile.c
index d260ff9..9402a65 100644
--- a/gdb/symfile.c
+++ b/gdb/symfile.c
@@ -3451,11 +3451,11 @@ simple_read_overlay_table (void)
   word_size = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
   byte_order = gdbarch_byte_order (gdbarch);
 
-  cache_novlys = read_memory_integer (SYMBOL_VALUE_ADDRESS (novlys_msym),
+  cache_novlys = read_memory_integer (MSYMBOL_VALUE_ADDRESS (novlys_msym),
 				      4, byte_order);
   cache_ovly_table
     = (void *) xmalloc (cache_novlys * sizeof (*cache_ovly_table));
-  cache_ovly_table_base = SYMBOL_VALUE_ADDRESS (ovly_table_msym.minsym);
+  cache_ovly_table_base = MSYMBOL_VALUE_ADDRESS (ovly_table_msym.minsym);
   read_target_long_array (cache_ovly_table_base,
                           (unsigned int *) cache_ovly_table,
                           cache_novlys * 4, word_size, byte_order);
@@ -3531,7 +3531,7 @@ simple_overlay_update (struct obj_section *osect)
 		   "find `_ovly_table' array\n"
 		   "in inferior.  Use `overlay manual' mode."));
 	
-	if (cache_ovly_table_base == SYMBOL_VALUE_ADDRESS (minsym))
+	if (cache_ovly_table_base == MSYMBOL_VALUE_ADDRESS (minsym))
 	  /* Then go ahead and try to look up this single section in
 	     the cache.  */
 	  if (simple_overlay_update_1 (osect))
diff --git a/gdb/symmisc.c b/gdb/symmisc.c
index b192184..5fb266a 100644
--- a/gdb/symmisc.c
+++ b/gdb/symmisc.c
@@ -212,7 +212,7 @@ dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
   index = 0;
   ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
     {
-      struct obj_section *section = SYMBOL_OBJ_SECTION (objfile, msymbol);
+      struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
 
       switch (MSYMBOL_TYPE (msymbol))
 	{
@@ -251,9 +251,9 @@ dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
 	  break;
 	}
       fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
-      fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msymbol)),
+      fputs_filtered (paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (msymbol)),
 		      outfile);
-      fprintf_filtered (outfile, " %s", SYMBOL_LINKAGE_NAME (msymbol));
+      fprintf_filtered (outfile, " %s", MSYMBOL_LINKAGE_NAME (msymbol));
       if (section)
 	{
 	  if (section->the_bfd_section != NULL)
@@ -264,9 +264,9 @@ dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
 	    fprintf_filtered (outfile, " spurious section %ld",
 			      (long) (section - objfile->sections));
 	}
-      if (SYMBOL_DEMANGLED_NAME (msymbol) != NULL)
+      if (MSYMBOL_DEMANGLED_NAME (msymbol) != NULL)
 	{
-	  fprintf_filtered (outfile, "  %s", SYMBOL_DEMANGLED_NAME (msymbol));
+	  fprintf_filtered (outfile, "  %s", MSYMBOL_DEMANGLED_NAME (msymbol));
 	}
       if (msymbol->filename)
 	fprintf_filtered (outfile, "  %s", msymbol->filename);
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 3660f1a..27c7e16 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -1050,7 +1050,7 @@ fixup_section (struct general_symbol_info *ginfo,
      point to the actual function code.  */
   msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile);
   if (msym)
-    ginfo->section = SYMBOL_SECTION (msym);
+    ginfo->section = MSYMBOL_SECTION (msym);
   else
     {
       /* Static, function-local variables do appear in the linker
@@ -2310,7 +2310,7 @@ find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
     if (MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
       {
 	mfunsym
-	  = lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol.minsym),
+	  = lookup_minimal_symbol_text (MSYMBOL_LINKAGE_NAME (msymbol.minsym),
 					NULL);
 	if (mfunsym == NULL)
 	  /* I eliminated this warning since it is coming out
@@ -2326,8 +2326,8 @@ find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
 	     SYMBOL_LINKAGE_NAME (msymbol)); */
 	  ;
 	/* fall through */
-	else if (SYMBOL_VALUE_ADDRESS (mfunsym)
-		 == SYMBOL_VALUE_ADDRESS (msymbol.minsym))
+	else if (MSYMBOL_VALUE_ADDRESS (mfunsym)
+		 == MSYMBOL_VALUE_ADDRESS (msymbol.minsym))
 	  /* Avoid infinite recursion */
 	  /* See above comment about why warning is commented out.  */
 	  /* warning ("In stub for %s; unable to find real function/line info",
@@ -2335,7 +2335,7 @@ find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
 	  ;
 	/* fall through */
 	else
-	  return find_pc_line (SYMBOL_VALUE_ADDRESS (mfunsym), 0);
+	  return find_pc_line (MSYMBOL_VALUE_ADDRESS (mfunsym), 0);
       }
 
 
@@ -2849,9 +2849,9 @@ skip_prologue_sal (struct symtab_and_line *sal)
 	}
 
       objfile = msymbol.objfile;
-      pc = SYMBOL_VALUE_ADDRESS (msymbol.minsym);
-      section = SYMBOL_OBJ_SECTION (objfile, msymbol.minsym);
-      name = SYMBOL_LINKAGE_NAME (msymbol.minsym);
+      pc = MSYMBOL_VALUE_ADDRESS (msymbol.minsym);
+      section = MSYMBOL_OBJ_SECTION (objfile, msymbol.minsym);
+      name = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
     }
 
   gdbarch = get_objfile_arch (objfile);
@@ -3594,16 +3594,16 @@ search_symbols (char *regexp, enum search_domain kind,
 	    || MSYMBOL_TYPE (msymbol) == ourtype4)
 	  {
 	    if (!datum.preg_p
-		|| regexec (&datum.preg, SYMBOL_NATURAL_NAME (msymbol), 0,
+		|| regexec (&datum.preg, MSYMBOL_NATURAL_NAME (msymbol), 0,
 			    NULL, 0) == 0)
 	      {
 		/* Note: An important side-effect of these lookup functions
 		   is to expand the symbol table if msymbol is found, for the
 		   benefit of the next loop on ALL_PRIMARY_SYMTABS.  */
 		if (kind == FUNCTIONS_DOMAIN
-		    ? find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)) == NULL
+		    ? find_pc_symtab (MSYMBOL_VALUE_ADDRESS (msymbol)) == NULL
 		    : (lookup_symbol_in_objfile_from_linkage_name
-		       (objfile, SYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
+		       (objfile, MSYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
 		       == NULL))
 		  found_misc = 1;
 	      }
@@ -3697,16 +3697,16 @@ search_symbols (char *regexp, enum search_domain kind,
 	    || MSYMBOL_TYPE (msymbol) == ourtype4)
 	  {
 	    if (!datum.preg_p
-		|| regexec (&datum.preg, SYMBOL_NATURAL_NAME (msymbol), 0,
+		|| regexec (&datum.preg, MSYMBOL_NATURAL_NAME (msymbol), 0,
 			    NULL, 0) == 0)
 	      {
 		/* For functions we can do a quick check of whether the
 		   symbol might be found via find_pc_symtab.  */
 		if (kind != FUNCTIONS_DOMAIN
-		    || find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)) == NULL)
+		    || find_pc_symtab (MSYMBOL_VALUE_ADDRESS (msymbol)) == NULL)
 		  {
 		    if (lookup_symbol_in_objfile_from_linkage_name
-			(objfile, SYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
+			(objfile, MSYMBOL_LINKAGE_NAME (msymbol), VAR_DOMAIN)
 			== NULL)
 		      {
 			/* match */
@@ -3784,14 +3784,14 @@ print_msymbol_info (struct bound_minimal_symbol msymbol)
   char *tmp;
 
   if (gdbarch_addr_bit (gdbarch) <= 32)
-    tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol.minsym)
+    tmp = hex_string_custom (MSYMBOL_VALUE_ADDRESS (msymbol.minsym)
 			     & (CORE_ADDR) 0xffffffff,
 			     8);
   else
-    tmp = hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol.minsym),
+    tmp = hex_string_custom (MSYMBOL_VALUE_ADDRESS (msymbol.minsym),
 			     16);
   printf_filtered ("%s  %s\n",
-		   tmp, SYMBOL_PRINT_NAME (msymbol.minsym));
+		   tmp, MSYMBOL_PRINT_NAME (msymbol.minsym));
 }
 
 /* This is the guts of the commands "info functions", "info types", and
@@ -3949,7 +3949,7 @@ rbreak_command (char *regexp, int from_tty)
 	}
       else
 	{
-	  int newlen = (strlen (SYMBOL_LINKAGE_NAME (p->msymbol.minsym)) + 3);
+	  int newlen = (strlen (MSYMBOL_LINKAGE_NAME (p->msymbol.minsym)) + 3);
 
 	  if (newlen > len)
 	    {
@@ -3957,12 +3957,12 @@ rbreak_command (char *regexp, int from_tty)
 	      len = newlen;
 	    }
 	  strcpy (string, "'");
-	  strcat (string, SYMBOL_LINKAGE_NAME (p->msymbol.minsym));
+	  strcat (string, MSYMBOL_LINKAGE_NAME (p->msymbol.minsym));
 	  strcat (string, "'");
 
 	  break_command (string, from_tty);
 	  printf_filtered ("<function, no debug info> %s;\n",
-			   SYMBOL_PRINT_NAME (p->msymbol.minsym));
+			   MSYMBOL_PRINT_NAME (p->msymbol.minsym));
 	}
     }
 
@@ -4033,6 +4033,10 @@ static VEC (char_ptr) *return_val;
       completion_list_add_name \
 	(SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
 
+#define MCOMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
+      completion_list_add_name \
+	(MSYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
+
 /*  Test to see if the symbol specified by SYMNAME (which is already
    demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
    characters.  If so, add it to the current completion list.  */
@@ -4090,7 +4094,7 @@ completion_list_objc_symbol (struct minimal_symbol *msymbol,
   const char *method, *category, *selector;
   char *tmp2 = NULL;
 
-  method = SYMBOL_NATURAL_NAME (msymbol);
+  method = MSYMBOL_NATURAL_NAME (msymbol);
 
   /* Is it a method?  */
   if ((method[0] != '-') && (method[0] != '+'))
@@ -4353,8 +4357,8 @@ default_make_symbol_completion_list_break_on (const char *text,
       ALL_MSYMBOLS (objfile, msymbol)
 	{
 	  QUIT;
-	  COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text,
-				      word);
+	  MCOMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text,
+				       word);
 
 	  completion_list_objc_symbol (msymbol, sym_text, sym_text_len, text,
 				       word);
diff --git a/gdb/symtab.h b/gdb/symtab.h
index 3d3c05c..80f8e35 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -180,8 +180,8 @@ extern const char *symbol_get_demangled_name
 extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
 
 /* Note that all the following SYMBOL_* macros are used with the
-   SYMBOL argument being either a partial symbol, a minimal symbol or
-   a full symbol.  All three types have a ginfo field.  In particular
+   SYMBOL argument being either a partial symbol or
+   a full symbol.  Both types have a ginfo field.  In particular
    the SYMBOL_SET_LANGUAGE, SYMBOL_DEMANGLED_NAME, etc.
    macros cannot be entirely substituted by
    functions, unless the callers are changed to pass in the ginfo
@@ -339,7 +339,7 @@ struct minimal_symbol
      The SYMBOL_VALUE_ADDRESS contains the address that this symbol
      corresponds to.  */
 
-  struct general_symbol_info ginfo;
+  struct general_symbol_info mginfo;
 
   /* Size of this symbol.  end_psymtab in dbxread.c uses this
      information to calculate the end of the partial symtab based on the
@@ -390,6 +390,34 @@ struct minimal_symbol
 #define MSYMBOL_HAS_SIZE(msymbol)	((msymbol)->has_size + 0)
 #define MSYMBOL_TYPE(msymbol)		(msymbol)->type
 
+#define MSYMBOL_VALUE(symbol)		(symbol)->mginfo.value.ivalue
+#define MSYMBOL_VALUE_ADDRESS(symbol)	(symbol)->mginfo.value.address
+#define MSYMBOL_VALUE_BYTES(symbol)	(symbol)->mginfo.value.bytes
+#define MSYMBOL_BLOCK_VALUE(symbol)	(symbol)->mginfo.value.block
+#define MSYMBOL_VALUE_CHAIN(symbol)	(symbol)->mginfo.value.chain
+#define MSYMBOL_LANGUAGE(symbol)	(symbol)->mginfo.language
+#define MSYMBOL_SECTION(symbol)		(symbol)->mginfo.section
+#define MSYMBOL_OBJ_SECTION(objfile, symbol)			\
+  (((symbol)->mginfo.section >= 0)				\
+   ? (&(((objfile)->sections)[(symbol)->mginfo.section]))	\
+   : NULL)
+
+#define MSYMBOL_NATURAL_NAME(symbol) \
+  (symbol_natural_name (&(symbol)->mginfo))
+#define MSYMBOL_LINKAGE_NAME(symbol)	(symbol)->mginfo.name
+#define MSYMBOL_PRINT_NAME(symbol)					\
+  (demangle ? MSYMBOL_NATURAL_NAME (symbol) : MSYMBOL_LINKAGE_NAME (symbol))
+#define MSYMBOL_DEMANGLED_NAME(symbol) \
+  (symbol_demangled_name (&(symbol)->mginfo))
+#define MSYMBOL_SET_LANGUAGE(symbol,language,obstack)	\
+  (symbol_set_language (&(symbol)->mginfo, (language), (obstack)))
+#define MSYMBOL_SEARCH_NAME(symbol)					 \
+   (symbol_search_name (&(symbol)->mginfo))
+#define MSYMBOL_MATCHES_SEARCH_NAME(symbol, name)			\
+  (strcmp_iw (MSYMBOL_SEARCH_NAME (symbol), (name)) == 0)
+#define MSYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile)	\
+  symbol_set_names (&(symbol)->mginfo, linkage_name, len, copy_name, objfile)
+
 #include "minsyms.h"
 
 
diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
index c086587..7684f05 100644
--- a/gdb/tracepoint.c
+++ b/gdb/tracepoint.c
@@ -2841,7 +2841,7 @@ scope_info (char *args, int from_tty)
 		      printf_filtered ("static storage at address ");
 		      printf_filtered ("%s",
 				       paddress (gdbarch,
-						 SYMBOL_VALUE_ADDRESS (msym)));
+						 MSYMBOL_VALUE_ADDRESS (msym)));
 		    }
 		  break;
 		case LOC_OPTIMIZED_OUT:
diff --git a/gdb/tui/tui-disasm.c b/gdb/tui/tui-disasm.c
index 7f00395..7705cf3 100644
--- a/gdb/tui/tui-disasm.c
+++ b/gdb/tui/tui-disasm.c
@@ -124,7 +124,7 @@ tui_find_disassembly_address (struct gdbarch *gdbarch, CORE_ADDR pc, int from)
          msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0).minsym;
 
          if (msymbol)
-            new_low = SYMBOL_VALUE_ADDRESS (msymbol);
+            new_low = MSYMBOL_VALUE_ADDRESS (msymbol);
          else
             new_low += 1 * max_lines;
 
@@ -349,7 +349,7 @@ tui_get_begin_asm_address (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
       if (main_symbol == 0)
         main_symbol = lookup_minimal_symbol ("_start", NULL, NULL);
       if (main_symbol)
-        addr = SYMBOL_VALUE_ADDRESS (main_symbol);
+        addr = MSYMBOL_VALUE_ADDRESS (main_symbol);
       else
         addr = 0;
     }
diff --git a/gdb/valops.c b/gdb/valops.c
index 15fd7c3..ea219d4 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -162,7 +162,7 @@ find_function_in_inferior (const char *name, struct objfile **objf_p)
 	  type = lookup_pointer_type (builtin_type (gdbarch)->builtin_char);
 	  type = lookup_function_type (type);
 	  type = lookup_pointer_type (type);
-	  maddr = SYMBOL_VALUE_ADDRESS (msymbol.minsym);
+	  maddr = MSYMBOL_VALUE_ADDRESS (msymbol.minsym);
 
 	  if (objf_p)
 	    *objf_p = objfile;
diff --git a/gdb/value.c b/gdb/value.c
index d96d285..beb5559 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -2622,7 +2622,7 @@ value_static_field (struct type *type, int fieldno)
 	  else
 	    {
 	      retval = value_at_lazy (TYPE_FIELD_TYPE (type, fieldno),
-				      SYMBOL_VALUE_ADDRESS (msym));
+				      MSYMBOL_VALUE_ADDRESS (msym));
 	    }
 	}
       else
@@ -2838,7 +2838,7 @@ value_fn_field (struct value **arg1p, struct fn_field *f,
 
       set_value_address (v,
 	gdbarch_convert_from_func_ptr_addr
-	   (gdbarch, SYMBOL_VALUE_ADDRESS (msym.minsym), &current_target));
+	   (gdbarch, MSYMBOL_VALUE_ADDRESS (msym.minsym), &current_target));
     }
 
   if (arg1p)
-- 
1.8.1.4


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]