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]

Re: [13/15] Address printing


> this removes references to current_gdbarch from address printing routines.
> As a side effect, I've somewhat reduced the number of routines currently
> being used for this purpose:
> 
> - ui_out_field_core_addr and paddress:  These routines stay, but get a
>   gdbarch parameter
> 
> - strlen_paddr, paddr, paddr_nz:  These routines are removed.  Current
>   callers are converted to an appropriate paddress call.
> 
> There were a few call sites where no architecture is available.  In those
> cases, I've changed the code to use
>   - hex_string for various debug output prints
>   - phex/phex_nz in places where the correct output size is known

Here's the version I've checked in, adapted for changed that happened
in the meantime.

Bye,
Ulrich

ChangeLog:

	* defs.h (strlen_paddr, paddr, paddr_nz): Remove.
	(paddress): Add GDBARCH parameter.
	* utils.c (strlen_paddr, paddr, paddr_nz): Remove.
	(paddress): Add GDBARCH parameter, use it instead of current_gdbarch.
	* ui-out.h (ui_out_field_core_addr): Add GDBARCH parameter.
	* ui-out.c (ui_out_field_core_addr): Add GDBARCH parameter,
	use it instead of current_gdbarch.

	Update calls to ui_out_field_core_addr to pass architecture:
	* ada-lang.c (print_one_exception): Update.
	* breakpoint.c (print_one_breakpoint_location,
	print_one_exception_catchpoint): Update.
	* disasm.c (dump_insns): Update.
	* darwin-nat-info.c (darwin_debug_regions_recurse): Update.
	* mi/mi-main.c (mi_cmd_data_read_memory): Update.
	* mi/mi-symbol-cmds.c: Include "objfiles.h".
	(mi_cmd_symbol_list_lines): Update.
	* stack.c (print_frame_info, print_frame): Update.

	Update callers of paddress to pass architecture:
	* ada-tasks.c (info_task): Update.
	* ada-valprint.c (ada_val_print_1): Update.
	* annotate.c (annotate_source, annotate_frame_begin): Update.
	* breakpoint.c (insert_bp_location, describe_other_breakpoints,
	mention): Update.
	* cli/cli-cmds.c (edit_command, list_command, print_disassembly):
	Update.
	* corefile.c (memory_error): Update.
	* c-valprint.c (print_function_pointer_address, c_val_print): Update.
	* disasm.c (dis_asm_print_address): Update.
	* exec.c (print_section_info): Update.
	* f-valprint.c (f_val_print): Update.
	* infcmd.c: Include "arch-utils.h".
	(jump_command, program_info): Update.
	* linux-fork.c: Include "arch-utils.h".
	(info_forks_command): Update.
	* m2-valprint.c (print_function_pointer_address,
	print_unpacked_pointer, print_variable_at_address,
	m2_val_print): Update.
	* m32r-rom.c (m32r_load_section, m32r_load, m32r_upload_command):
	Update.
	* printcmd.c (print_address, print_address_demangle, address_info):
	Update.
	* p-valprint.c (pascal_val_print): Update.
	* source.c: Include "arch-utils.h".
	(line_info): Update.
	* stack.c (frame_info, print_block_frame_labels): Update.
	* symfile.c (add_symbol_file_command, list_overlays_command): Update.
	* symmisc.c (dump_msymbols, dump_psymtab, dump_symtab_1,
	print_symbol, print_partial_symbols, maintenance_info_psymtabs,
	maintenance_check_symtabs): Update.
	* symtab.c (find_pc_sect_symtab): Update.
	* target.c (deprecated_debug_xfer_memory): Update.
	* tracepoint.c (scope_info): Update.
	* tui/tui-stack.c (tui_make_status_line): Update.
	* valprint.c (val_print_string): Update.

	Update callers of paddr_nz to use paddress instead (keeping
	user-visible output identical):
	* alpha-tdep.c (alpha_heuristic_proc_start): Update.
	* amd64-tdep.c (fixup_riprel, amd64_displaced_step_copy_insn,
	amd64_displaced_step_fixup): Update.
	* arch-utils.c (simple_displaced_step_copy_insn): Update.
	* auxv.c (fprint_target_auxv): Update.
	* breakpoint.c (insert_single_step_breakpoint): Update.
	* buildsym.c (finish_block): Update.
	* cli/cli-dump.c (restore_section_callback): Update.
	* fbsd-nat.c (fbsd_find_memory_regions): Update.
	* frame.c (frame_unwind_register_value): Update.
	* gcore.c (gcore_create_callback): Update.
	* hppa-tdep.c (hppa_frame_cache, hppa_skip_trampoline_code): Update.
	* i386-tdep.c (i386_displaced_step_fixup, i386_record_modrm,
	i386_record_lea_modrm_addr, i386_record_lea_modrm,
	i386_process_record): Update.
	* ia64-tdep.c (ia64_frame_this_id, ia64_sigtramp_frame_this_id,
	ia64_libunwind_frame_this_id, ia64_libunwind_sigtramp_frame_this_id,
	ia64_dummy_id, ia64_access_reg, ia64_access_rse_reg): Update.
	* infrun.c (displaced_step_prepare, displaced_step_fixup,
	handle_inferior_event, insert_step_resume_breakpoint_at_sal,
	insert_longjmp_resume_breakpoint): Update.
	* linux-nat.c (linux_nat_find_memory_regions): Update.
	* linux-record.c (record_linux_system_call): Update.
	* mips-tdep.c (heuristic_proc_start, mips_eabi_push_dummy_call,
	mips_n32n64_push_dummy_call, mips_o32_push_dummy_call,
	mips_o64_push_dummy_call): Update.
	* monitor.c (monitor_error, monitor_remove_breakpoint): Update.
	* record.c (record_arch_list_add_mem, record_wait,
	record_xfer_partial): Update.
	* remote-mips.c (mips_fetch_word, mips_check_lsi_error,
	mips_common_breakpoint): Update.
	* remote-sim.c (gdbsim_xfer_inferior_memory): Update.
	* rs6000-tdep.c (ppc_displaced_step_fixup): Update.
	* solib-som.c (som_current_sos): Update.
	* symfile.c (load_progress, generic_load): Update.
	* symfile-mem.c (add_vsyscall_page): Update.
	* valops.c (value_fetch_lazy): Update.
	* windows-tdep.c (windows_xfer_shared_library): Update.

	Update callers of paddr_nz to use paddress instead (changing
	user-visible output to make it more correct):
	* dwarf2loc.c (locexpr_describe_location): Update.
	* ia64-tdep.c (ia64_memory_insert_breakpoint,
	ia64_memory_remove_breakpoint): Update.
	* jv-valprint.c (java_value_print): Update.
	* m32c-tdep.c (m32c_m16c_address_to_pointer): Update.
	* monitor.c (monitor_read_memory): Update.

	Update callers of paddr to use paddress instead (changing
	user-visible output to make it more correct):
	* arm-tdep.c (arm_push_dummy_call): Update.
	* breakpoint.c (insert_bp_location, create_thread_event_breakpoint,
	create_breakpoint): Update.
	* darwin-nat-info.c (darwin_debug_regions): Update.
	* dcache.c (dcache_info): Update.
	* dsrec.c (load_srec, make_srec): Update.
	* dwarf2-frame.c (dwarf2_restore_rule, execute_cfa_program,
	dwarf2_frame_cache): Update.
	* gcore.c (gcore_copy_callback): Update.
	* gnu-nat.c (gnu_xfer_memory): Update.
	* mips-linux-nat.c (mips_show_dr): Update.
	* monitor.c (monitor_write_memory, monitor_insert_breakpoint,
	monitor_remove_breakpoint): Update.
	* remote.c (compare_sections_command): Update.
	* remote-m32r-sdi.c (m32r_xfer_memory, m32r_insert_breakpoint,
	m32r_remove_breakpoint, m32r_insert_watchpoint,
	m32r_remove_watchpoint): Update.
	* sol-thread.c (info_cb): Update.
	* symfile.c (load_progress): Update.

	Update callers of paddress or paddr_nz to use hex_string instead
	(changes output of internal/error/debug messages only):
	* dwarf2read.c (dump_die_shallow): Update.
	* frame.c (fprint_field, fprint_frame, frame_pc_unwind,
	get_frame_func, create_new_frame): Update.
	* hppa-tdep.c (find_unwind_entry, unwind_command): Update.
	* ia64-tdep.c (get_kernel_table, ia64_find_proc_info_x,
	ia64_get_dyn_info_list): Update.
	* maint.c (maintenance_translate_address): Update.
	* mi/mi-cmd-var.c (mi_cmd_var_create): Update.
	* target.c (target_flash_erase): Update.

	Update callers of paddr/paddr_nz to use phex/phex_nz instead,
	using an appropriate address size.  Remove use of strlen_paddr.
	* exec.c (exec_files_info): Update.
	* i386-nat.c (i386_show_dr): Update.
	* remote.c (remote_flash_erase): Update.
	* m32r-rom.c (m32r_load_section): Update.
	* monitor.c (monitor_vsprintf, monitor_store_register): Update.
	* remote.c (remote_check_symbols, remote_search_memory): Update.
	* remote-mips.c (mips_request, mips_common_breakpoint): Update.
	* scm-valprint.c (scm_ipruk, scm_scmval_print): Update.
	* sh64-tdep.c (sh64_show_media_regs, sh64_show_compact_regs): Update.
	* sh-tdep.c (sh_generic_show_regs, sh3_show_regs, sh2e_show_regs,
	sh2a_show_regs, sh2a_nofpu_show_regs, sh3e_show_regs,
	sh3_dsp_show_regs, sh4_show_regs, sh4_nofpu_show_regs,
	sh_dsp_show_regs): Update.
	* xcoffsolib.c (sharedlibrary_command): Update.


	* maint.c (maint_print_section_info): Add ADDR_SIZE parameter.
	Use hex_string_custom instead of paddr.
	(print_bfd_section_info): Pass address size.
	(print_objfile_section_info): Likewise.

	* annotate.h (annotate_source): Add GDBARCH parameter.
	(annotate_frame_begin): Likewise.
	* annotate.c (annotate_source): Add GDBARCH parameter.
	(annotate_frame_begin): Likewise.
	* source.c (identify_source_line): Update call to annotate_source.
	* stack.c (print_frame_info, print_frame): Update call to
	annotate_frame_begin.

	* breakpoint.c (describe_other_breakpoints): Add GDBARCH parameter.
	(create_breakpoint, create_ada_exception_breakpoint): Update call.

	* stack.c (print_block_frame_labels): Add GDBARCH parameter.
	(print_frame_label_vars): Update call.

	* symmisc.c (print_partial_symbols): Add GDBARCH parameter.
	(dump_psymtab): Update call to print_partial_symbols.
	(struct print_symbol_args): Add GDBARCH member.
	(dump_symtab_1): Set print_symbol_args architecture member.
	(print_symbol): Use it.

	* windows-tdep.h (windows_xfer_shared_library): Add GDBARCH
	parameter.
	* windows-tdep.c (windows_xfer_shared_library): Likewise.
	* i386-cygwin-tdep.c (struct cpms_data): Add GDBARCH member.
	(core_process_module_section): Pass architecture from cpms_data to
	windows_xfer_shared_library.
	(windows_core_xfer_shared_libraries): Initialize cmps_data 
	architecture member.
	* windows-nat.c (windows_xfer_shared_libraries): Pass architecture
	to windows_xfer_shared_library.

	* defs.h (print_address): Add GDBARCH parameter.
	* printcmd.c (print_address): Add GDBARCH parameter.
	(print_scalar_formatted, do_examine): Update call.
	* findcmd.c (find_command): Update call.
	* tracepoint.c: Include "arch-utils.h".
	(trace_find_line_command): Update call.
	* tui/tui-disasm.c (tui_disassemble): Update call.

	* value.h (print_address_demangle): Add GDBARCH parameter.
	* printcmd.c (print_address_demangle): Add GDBARCH parameter.
	* c-valprint.c (print_function_pointer_address, c_val_print):
	Update call.
	* f-valprint.c (f_val_print): Update call.
	* gnu-v3-abi.c (gnuv3_print_method_ptr): Update call.
	* jv-valprint.c (java_val_print): Update call.
	* m2-valprint.c (print_function_pointer_address, m2_val_print):
	Update call.
	* p-valprint.c (pascal_val_print): Update call.

	* disasm.c (gdb_disassemble_info): Install architecture into
	di.application_data field.

testsuite/ChangeLog:

	* gdb.threads/tls-shared.exp: Update to locexpr_describe_location
	change to prefix TLS offset in hex with 0x.

doc/ChangeLog:

	* gdbint.texinfo (Item Output Functions): Update signature
	for ui_out_field_core_addr.


Index: gdb-head/gdb/ada-tasks.c
===================================================================
--- gdb-head.orig/gdb/ada-tasks.c
+++ gdb-head/gdb/ada-tasks.c
@@ -752,7 +752,8 @@ info_task (char *taskno_str, int from_tt
   task_info = VEC_index (ada_task_info_s, task_list, taskno - 1);
 
   /* Print the Ada task ID.  */
-  printf_filtered (_("Ada Task: %s\n"), paddr_nz (task_info->task_id));
+  printf_filtered (_("Ada Task: %s\n"),
+		   paddress (target_gdbarch, task_info->task_id));
 
   /* Print the name of the task.  */
   if (task_info->name[0] != '\0')
Index: gdb-head/gdb/ada-valprint.c
===================================================================
--- gdb-head.orig/gdb/ada-valprint.c
+++ gdb-head/gdb/ada-valprint.c
@@ -795,13 +795,12 @@ ada_val_print_1 (struct type *type, cons
 
 	      struct gdbarch *gdbarch = get_type_arch (type);
 	      struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
+	      CORE_ADDR addr = extract_typed_address (valaddr, ptr_type);
 
               fprintf_filtered (stream, "(");
               type_print (type, "", stream, -1);
               fprintf_filtered (stream, ") ");
-	      fputs_filtered (paddress (extract_typed_address
-					(valaddr, ptr_type)),
-			      stream);
+	      fputs_filtered (paddress (gdbarch, addr), stream);
             }
 	  else
 	    {
Index: gdb-head/gdb/alpha-tdep.c
===================================================================
--- gdb-head.orig/gdb/alpha-tdep.c
+++ gdb-head/gdb/alpha-tdep.c
@@ -959,10 +959,10 @@ alpha_heuristic_proc_start (struct gdbar
 
       if (fence == tdep->vm_min_address)
 	warning (_("Hit beginning of text section without finding \
-enclosing function for address 0x%s"), paddr_nz (orig_pc));
+enclosing function for address %s"), paddress (gdbarch, orig_pc));
       else
 	warning (_("Hit heuristic-fence-post without finding \
-enclosing function for address 0x%s"), paddr_nz (orig_pc));
+enclosing function for address %s"), paddress (gdbarch, orig_pc));
 
       if (!blurb_printed)
 	{
Index: gdb-head/gdb/annotate.c
===================================================================
--- gdb-head.orig/gdb/annotate.c
+++ gdb-head/gdb/annotate.c
@@ -410,7 +410,8 @@ annotate_arg_end (void)
 }
 
 void
-annotate_source (char *filename, int line, int character, int mid, CORE_ADDR pc)
+annotate_source (char *filename, int line, int character, int mid,
+		 struct gdbarch *gdbarch, CORE_ADDR pc)
 {
   if (annotation_level > 1)
     printf_filtered (("\n\032\032source "));
@@ -418,14 +419,15 @@ annotate_source (char *filename, int lin
     printf_filtered (("\032\032"));
 
   printf_filtered (("%s:%d:%d:%s:%s\n"), filename, line, character,
-		   mid ? "middle" : "beg", paddress (pc));
+		   mid ? "middle" : "beg", paddress (gdbarch, pc));
 }
 
 void
-annotate_frame_begin (int level, CORE_ADDR pc)
+annotate_frame_begin (int level, struct gdbarch *gdbarch, CORE_ADDR pc)
 {
   if (annotation_level > 1)
-    printf_filtered (("\n\032\032frame-begin %d %s\n"), level, paddress (pc));
+    printf_filtered (("\n\032\032frame-begin %d %s\n"),
+		     level, paddress (gdbarch, pc));
 }
 
 void
Index: gdb-head/gdb/annotate.h
===================================================================
--- gdb-head.orig/gdb/annotate.h
+++ gdb-head/gdb/annotate.h
@@ -76,9 +76,10 @@ extern void annotate_arg_name_end (void)
 extern void annotate_arg_value (struct type *);
 extern void annotate_arg_end (void);
 
-extern void annotate_source (char *, int, int, int, CORE_ADDR);
+extern void annotate_source (char *, int, int, int,
+			     struct gdbarch *, CORE_ADDR);
 
-extern void annotate_frame_begin (int, CORE_ADDR);
+extern void annotate_frame_begin (int, struct gdbarch *, CORE_ADDR);
 extern void annotate_function_call (void);
 extern void annotate_signal_handler_caller (void);
 extern void annotate_frame_address (void);
Index: gdb-head/gdb/arch-utils.c
===================================================================
--- gdb-head.orig/gdb/arch-utils.c
+++ gdb-head/gdb/arch-utils.c
@@ -51,8 +51,8 @@ simple_displaced_step_copy_insn (struct 
 
   if (debug_displaced)
     {
-      fprintf_unfiltered (gdb_stdlog, "displaced: copy 0x%s->0x%s: ",
-                          paddr_nz (from), paddr_nz (to));
+      fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
+                          paddress (gdbarch, from), paddress (gdbarch, to));
       displaced_step_dump_bytes (gdb_stdlog, buf, len);
     }
 
Index: gdb-head/gdb/arm-tdep.c
===================================================================
--- gdb-head.orig/gdb/arm-tdep.c
+++ gdb-head/gdb/arm-tdep.c
@@ -1423,9 +1423,9 @@ arm_push_dummy_call (struct gdbarch *gdb
   if (struct_return)
     {
       if (arm_debug)
-	fprintf_unfiltered (gdb_stdlog, "struct return in %s = 0x%s\n",
+	fprintf_unfiltered (gdb_stdlog, "struct return in %s = %s\n",
 			    gdbarch_register_name (gdbarch, argreg),
-			    paddr (struct_addr));
+			    paddress (gdbarch, struct_addr));
       regcache_cooked_write_unsigned (regcache, argreg, struct_addr);
       argreg++;
     }
Index: gdb-head/gdb/auxv.c
===================================================================
--- gdb-head.orig/gdb/auxv.c
+++ gdb-head/gdb/auxv.c
@@ -237,14 +237,14 @@ fprint_target_auxv (struct ui_file *file
 	  fprintf_filtered (file, "%s\n", plongest (val));
 	  break;
 	case hex:
-	  fprintf_filtered (file, "0x%s\n", paddr_nz (val));
+	  fprintf_filtered (file, "%s\n", paddress (target_gdbarch, val));
 	  break;
 	case str:
 	  {
 	    struct value_print_options opts;
 	    get_user_print_options (&opts);
 	    if (opts.addressprint)
-	      fprintf_filtered (file, "0x%s", paddr_nz (val));
+	      fprintf_filtered (file, "%s", paddress (target_gdbarch, val));
 	    val_print_string (builtin_type (target_gdbarch)->builtin_char,
 			      val, -1, file, &opts);
 	    fprintf_filtered (file, "\n");
Index: gdb-head/gdb/breakpoint.c
===================================================================
--- gdb-head.orig/gdb/breakpoint.c
+++ gdb-head/gdb/breakpoint.c
@@ -117,7 +117,8 @@ static CORE_ADDR adjust_breakpoint_addre
 					    CORE_ADDR bpaddr,
                                             enum bptype bptype);
 
-static void describe_other_breakpoints (CORE_ADDR, struct obj_section *, int);
+static void describe_other_breakpoints (struct gdbarch *, CORE_ADDR,
+					struct obj_section *, int);
 
 static void breakpoints_info (char *, int);
 
@@ -1140,7 +1141,7 @@ Note: automatically using hardware break
 	      else if (bpt->loc_type == bp_loc_software_breakpoint
 		       && mr->attrib.mode != MEM_RW)	    
 		warning (_("cannot set software breakpoint at readonly address %s"),
-			 paddr (bpt->address));
+			 paddress (bpt->gdbarch, bpt->address));
 	    }
 	}
         
@@ -1240,7 +1241,8 @@ Note: automatically using hardware break
 				      bpt->owner->number);
 		  fprintf_filtered (tmp_error_stream, 
 				    "Error accessing memory address ");
-		  fputs_filtered (paddress (bpt->address), tmp_error_stream);
+		  fputs_filtered (paddress (bpt->gdbarch, bpt->address),
+				  tmp_error_stream);
 		  fprintf_filtered (tmp_error_stream, ": %s.\n",
 				    safe_strerror (val));
 		}
@@ -3726,7 +3728,8 @@ print_one_breakpoint_location (struct br
 	    else if (b->loc == NULL || loc->shlib_disabled)
 	      ui_out_field_string (uiout, "addr", "<PENDING>");
 	    else
-	      ui_out_field_core_addr (uiout, "addr", loc->address);
+	      ui_out_field_core_addr (uiout, "addr",
+				      loc->gdbarch, loc->address);
 	  }
 	annotate_field (5);
 	if (!header_of_multiple)
@@ -3760,7 +3763,8 @@ print_one_breakpoint_location (struct br
       ui_out_text (uiout, "\tstop only in stack frame at ");
       /* FIXME: cagney/2002-12-01: Shouldn't be poeking around inside
          the frame ID.  */
-      ui_out_field_core_addr (uiout, "frame", b->frame_id.stack_addr);
+      ui_out_field_core_addr (uiout, "frame",
+			      b->gdbarch, b->frame_id.stack_addr);
       ui_out_text (uiout, "\n");
     }
   
@@ -4110,8 +4114,8 @@ breakpoint_has_pc (struct breakpoint *b,
 /* Print a message describing any breakpoints set at PC.  */
 
 static void
-describe_other_breakpoints (CORE_ADDR pc, struct obj_section *section,
-			    int thread)
+describe_other_breakpoints (struct gdbarch *gdbarch, CORE_ADDR pc,
+			    struct obj_section *section, int thread)
 {
   int others = 0;
   struct breakpoint *b;
@@ -4144,7 +4148,7 @@ describe_other_breakpoints (CORE_ADDR pc
 			     : ((others == 1) ? " and" : ""));
 	  }
       printf_filtered (_("also set at pc "));
-      fputs_filtered (paddress (pc), gdb_stdout);
+      fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
       printf_filtered (".\n");
     }
 }
@@ -4606,7 +4610,8 @@ create_thread_event_breakpoint (struct g
   
   b->enable_state = bp_enabled;
   /* addr_string has to be used or breakpoint_re_set will delete me.  */
-  b->addr_string = xstrprintf ("*0x%s", paddr (b->loc->address));
+  b->addr_string
+    = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
 
   update_global_location_list_nothrow (1);
 
@@ -5289,7 +5294,8 @@ mention (struct breakpoint *b)
 	  if (opts.addressprint || b->source_file == NULL)
 	    {
 	      printf_filtered (" at ");
-	      fputs_filtered (paddress (b->loc->address), gdb_stdout);
+	      fputs_filtered (paddress (b->loc->gdbarch, b->loc->address),
+			      gdb_stdout);
 	    }
 	  if (b->source_file)
 	    printf_filtered (": file %s, line %d.",
@@ -5408,7 +5414,14 @@ create_breakpoint (struct gdbarch *gdbar
       struct bp_location *loc;
 
       if (from_tty)
-	describe_other_breakpoints (sal.pc, sal.section, thread);
+	{
+	  struct gdbarch *loc_gdbarch = get_sal_arch (sal);
+	  if (!loc_gdbarch)
+	    loc_gdbarch = gdbarch;
+
+	  describe_other_breakpoints (loc_gdbarch,
+				      sal.pc, sal.section, thread);
+	}
 
       if (i == 0)
 	{
@@ -5447,7 +5460,8 @@ create_breakpoint (struct gdbarch *gdbar
   else
     /* addr_string has to be used or breakpoint_re_set will delete
        me.  */
-    b->addr_string = xstrprintf ("*0x%s", paddr (b->loc->address));
+    b->addr_string
+      = xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
 
   b->ops = ops;
   mention (b);
@@ -6859,7 +6873,8 @@ print_one_exception_catchpoint (struct b
       if (b->loc == NULL || b->loc->shlib_disabled)
 	ui_out_field_string (uiout, "addr", "<PENDING>");
       else
-	ui_out_field_core_addr (uiout, "addr", b->loc->address);
+	ui_out_field_core_addr (uiout, "addr",
+				b->loc->gdbarch, b->loc->address);
     }
   annotate_field (5);
   if (b->loc)
@@ -6980,7 +6995,11 @@ create_ada_exception_breakpoint (struct 
 
   if (from_tty)
     {
-      describe_other_breakpoints (sal.pc, sal.section, -1);
+      struct gdbarch *loc_gdbarch = get_sal_arch (sal);
+      if (!loc_gdbarch)
+	loc_gdbarch = gdbarch;
+
+      describe_other_breakpoints (loc_gdbarch, sal.pc, sal.section, -1);
       /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
          version for exception catchpoints, because two catchpoints
          used for different exception names will use the same address.
@@ -8386,8 +8405,8 @@ insert_single_step_breakpoint (struct gd
 
   *bpt_p = deprecated_insert_raw_breakpoint (gdbarch, next_pc);
   if (*bpt_p == NULL)
-    error (_("Could not insert single-step breakpoint at 0x%s"),
-	     paddr_nz (next_pc));
+    error (_("Could not insert single-step breakpoint at %s"),
+	     paddress (gdbarch, next_pc));
 }
 
 /* Remove and delete any breakpoints used for software single step.  */
Index: gdb-head/gdb/buildsym.c
===================================================================
--- gdb-head.orig/gdb/buildsym.c
+++ gdb-head/gdb/buildsym.c
@@ -235,6 +235,7 @@ finish_block (struct symbol *symbol, str
 	      CORE_ADDR start, CORE_ADDR end,
 	      struct objfile *objfile)
 {
+  struct gdbarch *gdbarch = get_objfile_arch (objfile);
   struct pending *next, *next1;
   struct block *block;
   struct pending_block *pblock;
@@ -331,8 +332,9 @@ finish_block (struct symbol *symbol, str
       else
 	{
 	  complaint (&symfile_complaints,
-		     _("block end address 0x%s less than block start address 0x%s (patched it)"),
-		     paddr_nz (BLOCK_END (block)), paddr_nz (BLOCK_START (block)));
+		     _("block end address %s less than block start address %s (patched it)"),
+		     paddress (gdbarch, BLOCK_END (block)),
+		     paddress (gdbarch, BLOCK_START (block)));
 	}
       /* Better than nothing */
       BLOCK_END (block) = BLOCK_START (block);
@@ -368,11 +370,11 @@ finish_block (struct symbol *symbol, str
 	      else
 		{
 		  complaint (&symfile_complaints,
-			     _("inner block (0x%s-0x%s) not inside outer block (0x%s-0x%s)"),
-			     paddr_nz (BLOCK_START (pblock->block)),
-			     paddr_nz (BLOCK_END (pblock->block)),
-			     paddr_nz (BLOCK_START (block)),
-			     paddr_nz (BLOCK_END (block)));
+			     _("inner block (%s-%s) not inside outer block (%s-%s)"),
+			     paddress (gdbarch, BLOCK_START (pblock->block)),
+			     paddress (gdbarch, BLOCK_END (pblock->block)),
+			     paddress (gdbarch, BLOCK_START (block)),
+			     paddress (gdbarch, BLOCK_END (block)));
 		}
 	      if (BLOCK_START (pblock->block) < BLOCK_START (block))
 		BLOCK_START (pblock->block) = BLOCK_START (block);
Index: gdb-head/gdb/cli/cli-cmds.c
===================================================================
--- gdb-head.orig/gdb/cli/cli-cmds.c
+++ gdb-head/gdb/cli/cli-cmds.c
@@ -672,17 +672,22 @@ edit_command (char *arg, int from_tty)
          of all known source files, not that user failed to give a filename.  */
       if (*arg == '*')
         {
+	  struct gdbarch *gdbarch;
           if (sal.symtab == 0)
 	    /* FIXME-32x64--assumes sal.pc fits in long.  */
 	    error (_("No source file for address %s."),
 		   hex_string ((unsigned long) sal.pc));
+
+	  gdbarch = get_objfile_arch (sal.symtab->objfile);
           sym = find_pc_function (sal.pc);
           if (sym)
-	    printf_filtered ("%s is in %s (%s:%d).\n", paddress (sal.pc),
-			     SYMBOL_PRINT_NAME (sym), sal.symtab->filename,
-			     sal.line);
+	    printf_filtered ("%s is in %s (%s:%d).\n",
+			     paddress (gdbarch, sal.pc),
+			     SYMBOL_PRINT_NAME (sym),
+			     sal.symtab->filename, sal.line);
           else
-	    printf_filtered ("%s is at %s:%d.\n", paddress (sal.pc),
+	    printf_filtered ("%s is at %s:%d.\n",
+			     paddress (gdbarch, sal.pc),
 			     sal.symtab->filename, sal.line);
         }
 
@@ -832,17 +837,22 @@ list_command (char *arg, int from_tty)
      of all known source files, not that user failed to give a filename.  */
   if (*arg == '*')
     {
+      struct gdbarch *gdbarch;
       if (sal.symtab == 0)
 	/* FIXME-32x64--assumes sal.pc fits in long.  */
 	error (_("No source file for address %s."),
 	       hex_string ((unsigned long) sal.pc));
+
+      gdbarch = get_objfile_arch (sal.symtab->objfile);
       sym = find_pc_function (sal.pc);
       if (sym)
 	printf_filtered ("%s is in %s (%s:%d).\n",
-			 paddress (sal.pc), SYMBOL_PRINT_NAME (sym),
+			 paddress (gdbarch, sal.pc),
+			 SYMBOL_PRINT_NAME (sym),
 			 sal.symtab->filename, sal.line);
       else
-	printf_filtered ("%s is at %s:%d.\n", paddress (sal.pc),
+	printf_filtered ("%s is at %s:%d.\n",
+			 paddress (gdbarch, sal.pc),
 			 sal.symtab->filename, sal.line);
     }
 
@@ -904,7 +914,8 @@ print_disassembly (struct gdbarch *gdbar
       if (name != NULL)
         printf_filtered ("for function %s:\n", name);
       else
-        printf_filtered ("from %s to %s:\n", paddress (low), paddress (high));
+        printf_filtered ("from %s to %s:\n",
+			 paddress (gdbarch, low), paddress (gdbarch, high));
 
       /* Dump the specified range.  */
       gdb_disassembly (gdbarch, uiout, 0, mixed, -1, low, high);
Index: gdb-head/gdb/cli/cli-dump.c
===================================================================
--- gdb-head.orig/gdb/cli/cli-dump.c
+++ gdb-head/gdb/cli/cli-dump.c
@@ -488,11 +488,13 @@ restore_section_callback (bfd *ibfd, ase
 		   (unsigned long) sec_end);
 
   if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
-    printf_filtered (" into memory (0x%s to 0x%s)\n", 
-		     paddr_nz ((unsigned long) sec_start 
+    printf_filtered (" into memory (%s to %s)\n",
+		     paddress (target_gdbarch,
+			       (unsigned long) sec_start
 			       + sec_offset + data->load_offset), 
-		     paddr_nz ((unsigned long) sec_start + sec_offset 
-		       + data->load_offset + sec_load_count));
+		     paddress (target_gdbarch,
+			       (unsigned long) sec_start + sec_offset
+				+ data->load_offset + sec_load_count));
   else
     puts_filtered ("\n");
 
Index: gdb-head/gdb/corefile.c
===================================================================
--- gdb-head.orig/gdb/corefile.c
+++ gdb-head/gdb/corefile.c
@@ -219,11 +219,11 @@ memory_error (int status, CORE_ADDR mema
        bounds.  */
     throw_error (MEMORY_ERROR,
 		 _("Cannot access memory at address %s"),
-		 paddress (memaddr));
+		 paddress (target_gdbarch, memaddr));
   else
     throw_error (MEMORY_ERROR,
 		 _("Error accessing memory address %s: %s."),
-		 paddress (memaddr),
+		 paddress (target_gdbarch, memaddr),
 		 safe_strerror (status));
 }
 
Index: gdb-head/gdb/c-valprint.c
===================================================================
--- gdb-head.orig/gdb/c-valprint.c
+++ gdb-head/gdb/c-valprint.c
@@ -47,10 +47,10 @@ print_function_pointer_address (struct g
   if (addressprint && func_addr != address)
     {
       fputs_filtered ("@", stream);
-      fputs_filtered (paddress (address), stream);
+      fputs_filtered (paddress (gdbarch, address), stream);
       fputs_filtered (": ", stream);
     }
-  print_address_demangle (func_addr, stream, demangle);
+  print_address_demangle (gdbarch, func_addr, stream, demangle);
 }
 
 
@@ -272,7 +272,7 @@ c_val_print (struct type *type, const gd
 	    }
 
 	  if (options->addressprint)
-	    fputs_filtered (paddress (addr), stream);
+	    fputs_filtered (paddress (gdbarch, addr), stream);
 
 	  /* For a pointer to a textual type, also print the string
 	     pointed to, unless pointer is null.  */
@@ -342,7 +342,7 @@ c_val_print (struct type *type, const gd
 	  CORE_ADDR addr
 	    = extract_typed_address (valaddr + embedded_offset, type);
 	  fprintf_filtered (stream, "@");
-	  fputs_filtered (paddress (addr), stream);
+	  fputs_filtered (paddress (gdbarch, addr), stream);
 	  if (options->deref_ref)
 	    fputs_filtered (": ", stream);
 	}
@@ -440,7 +440,7 @@ c_val_print (struct type *type, const gd
       type_print (type, "", stream, -1);
       fprintf_filtered (stream, "} ");
       /* Try to print what function it points to, and its address.  */
-      print_address_demangle (address, stream, demangle);
+      print_address_demangle (gdbarch, address, stream, demangle);
       break;
 
     case TYPE_CODE_BOOL:
Index: gdb-head/gdb/dcache.c
===================================================================
--- gdb-head.orig/gdb/dcache.c
+++ gdb-head/gdb/dcache.c
@@ -569,7 +569,7 @@ dcache_info (char *exp, int tty)
 	{
 	  int j;
 	  printf_filtered (_("Line at %s, referenced %d times\n"),
-			   paddr (p->addr), p->refs);
+			   paddress (target_gdbarch, p->addr), p->refs);
 
 	  for (j = 0; j < LINE_SIZE; j++)
 	    printf_filtered ("%02x", p->data[j] & 0xFF);
Index: gdb-head/gdb/defs.h
===================================================================
--- gdb-head.orig/gdb/defs.h
+++ gdb-head/gdb/defs.h
@@ -515,14 +515,9 @@ extern void gdb_print_host_address (cons
 
 extern const char *host_address_to_string (const void *addr);
 
-/* Convert a CORE_ADDR into a HEX string.  paddr() is like %08lx.
-   paddr_nz() is like %lx.  */
-extern int strlen_paddr (void);
-extern char *paddr (CORE_ADDR addr);
-extern char *paddr_nz (CORE_ADDR addr);
-
-/* Like 0x%lx.  */
-extern const char *paddress (CORE_ADDR addr);
+/* Convert CORE_ADDR to string in platform-specific manner.
+   This is usually formatted similar to 0x%lx.  */
+extern const char *paddress (struct gdbarch *gdbarch, CORE_ADDR addr);
 
 /* %d for LONGEST */
 extern char *plongest (LONGEST l);
@@ -533,8 +528,8 @@ extern char *phex (ULONGEST l, int sizeo
 extern char *phex_nz (ULONGEST l, int sizeof_l);
 extern char *int_string (LONGEST, int, int, int, int);
 
-/* Like paddr() only print/scan raw CORE_ADDR.  The output from
-   core_addr_to_string() can be passed direct to
+/* Convert a CORE_ADDR into a HEX string with leading zeros.
+   The output from core_addr_to_string() can be passed direct to
    string_to_core_addr().  */
 extern const char *core_addr_to_string (const CORE_ADDR addr);
 extern const char *core_addr_to_string_nz (const CORE_ADDR addr);
@@ -612,7 +607,7 @@ extern int build_address_symbolic (CORE_
 				   int *line, 	
 				   int *unmapped);
 
-extern void print_address (CORE_ADDR, struct ui_file *);
+extern void print_address (struct gdbarch *, CORE_ADDR, struct ui_file *);
 
 /* From source.c */
 
Index: gdb-head/gdb/disasm.c
===================================================================
--- gdb-head.orig/gdb/disasm.c
+++ gdb-head/gdb/disasm.c
@@ -63,7 +63,8 @@ dis_asm_memory_error (int status, bfd_vm
 static void
 dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
 {
-  print_address (addr, info->stream);
+  struct gdbarch *gdbarch = info->application_data;
+  print_address (gdbarch, addr, info->stream);
 }
 
 static int
@@ -112,7 +113,7 @@ dump_insns (struct gdbarch *gdbarch, str
 	    num_displayed++;
 	}
       ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
-      ui_out_field_core_addr (uiout, "address", pc);
+      ui_out_field_core_addr (uiout, "address", gdbarch, pc);
 
       if (!build_address_symbolic (pc, 0, &name, &offset, &filename,
 				   &line, &unmapped))
@@ -347,6 +348,7 @@ gdb_disassemble_info (struct gdbarch *gd
   di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
   di.endian = gdbarch_byte_order (gdbarch);
   di.endian_code = gdbarch_byte_order_for_code (gdbarch);
+  di.application_data = gdbarch;
   disassemble_init_for_target (&di);
   return di;
 }
Index: gdb-head/gdb/dsrec.c
===================================================================
--- gdb-head.orig/gdb/dsrec.c
+++ gdb-head/gdb/dsrec.c
@@ -97,10 +97,10 @@ load_srec (struct serial *desc, const ch
            In the below, GDB's is used so that the address is
            consistent with the rest of GDB.  BFD's printf_vma() could
            have also been used. cagney 1999-09-01 */
-	printf_filtered ("%s\t: 0x%s .. 0x%s  ",
+	printf_filtered ("%s\t: %s .. %s  ",
 			 section_name,
-			 paddr (addr),
-			 paddr (addr + size));
+			 paddress (target_gdbarch, addr),
+			 paddress (target_gdbarch, addr + size));
 	gdb_flush (gdb_stdout);
 
 	data_count += size;
@@ -252,8 +252,8 @@ make_srec (char *srec, CORE_ADDR targ_ad
     addr_size = 4;
   else
     internal_error (__FILE__, __LINE__,
-		    _("make_srec:  Bad address (0x%s), or bad flags (0x%x)."),
-		    paddr (targ_addr), flags);
+		    _("make_srec:  Bad address (%s), or bad flags (0x%x)."),
+		    paddress (target_gdbarch, targ_addr), flags);
 
   /* Now that we know the address size, we can figure out how much
      data this record can hold.  */
Index: gdb-head/gdb/dwarf2-frame.c
===================================================================
--- gdb-head.orig/gdb/dwarf2-frame.c
+++ gdb-head/gdb/dwarf2-frame.c
@@ -334,11 +334,11 @@ dwarf2_restore_rule (struct gdbarch *gdb
   if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
     complaint (&symfile_complaints, _("\
 incomplete CFI data; DW_CFA_restore unspecified\n\
-register %s (#%d) at 0x%s"),
+register %s (#%d) at %s"),
 		       gdbarch_register_name
 		       (gdbarch, gdbarch_dwarf2_reg_to_regnum (gdbarch, reg)),
 		       gdbarch_dwarf2_reg_to_regnum (gdbarch, reg),
-		       paddr (fs->pc));
+		       paddress (gdbarch, fs->pc));
 }
 
 static CORE_ADDR
@@ -490,7 +490,8 @@ execute_cfa_program (struct dwarf2_fde *
 		if (old_rs == NULL)
 		  {
 		    complaint (&symfile_complaints, _("\
-bad CFI data; mismatched DW_CFA_restore_state at 0x%s"), paddr (fs->pc));
+bad CFI data; mismatched DW_CFA_restore_state at %s"),
+			       paddress (gdbarch, fs->pc));
 		  }
 		else
 		  {
@@ -997,9 +998,9 @@ dwarf2_frame_cache (struct frame_info *t
 	  {
 	    if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
 	      complaint (&symfile_complaints, _("\
-incomplete CFI data; unspecified registers (e.g., %s) at 0x%s"),
+incomplete CFI data; unspecified registers (e.g., %s) at %s"),
 			 gdbarch_register_name (gdbarch, regnum),
-			 paddr_nz (fs->pc));
+			 paddress (gdbarch, fs->pc));
 	  }
 	else
 	  cache->reg[regnum] = fs->regs.reg[column];
Index: gdb-head/gdb/dwarf2loc.c
===================================================================
--- gdb-head.orig/gdb/dwarf2loc.c
+++ gdb-head/gdb/dwarf2loc.c
@@ -508,7 +508,7 @@ locexpr_describe_location (struct symbol
 	fprintf_filtered (stream, 
 			  "a thread-local variable at offset %s in the "
 			  "thread-local storage for `%s'",
-			  paddr_nz (offset), objfile->name);
+			  paddress (gdbarch, offset), objfile->name);
 	return 1;
       }
   
Index: gdb-head/gdb/dwarf2read.c
===================================================================
--- gdb-head.orig/gdb/dwarf2read.c
+++ gdb-head/gdb/dwarf2read.c
@@ -9534,7 +9534,7 @@ dump_die_shallow (struct ui_file *f, int
 	case DW_FORM_ref_addr:
 	case DW_FORM_addr:
 	  fprintf_unfiltered (f, "address: ");
-	  fputs_filtered (paddress (DW_ADDR (&die->attrs[i])), f);
+	  fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
 	  break;
 	case DW_FORM_block2:
 	case DW_FORM_block4:
Index: gdb-head/gdb/exec.c
===================================================================
--- gdb-head.orig/gdb/exec.c
+++ gdb-head/gdb/exec.c
@@ -647,16 +647,17 @@ exec_xfer_partial (struct target_ops *op
 void
 print_section_info (struct target_section_table *t, bfd *abfd)
 {
+  struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
   struct target_section *p;
   /* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64.  */
-  int wid = gdbarch_addr_bit (gdbarch_from_bfd (abfd)) <= 32 ? 8 : 16;
+  int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16;
 
   printf_filtered ("\t`%s', ", bfd_get_filename (abfd));
   wrap_here ("        ");
   printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
   if (abfd == exec_bfd)
     printf_filtered (_("\tEntry point: %s\n"),
-                     paddress (bfd_get_start_address (abfd)));
+                     paddress (gdbarch, bfd_get_start_address (abfd)));
   for (p = t->sections; p < t->sections_end; p++)
     {
       printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
@@ -685,23 +686,24 @@ exec_files_info (struct target_ops *t)
 
   if (vmap)
     {
+      int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
       struct vmap *vp;
 
       printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name);
       printf_unfiltered ("\t  %*s   %*s   %*s   %*s %8.8s %s\n",
-			 strlen_paddr (), "tstart",
-			 strlen_paddr (), "tend",
-			 strlen_paddr (), "dstart",
-			 strlen_paddr (), "dend",
+			 addr_size * 2, "tstart",
+			 addr_size * 2, "tend",
+			 addr_size * 2, "dstart",
+			 addr_size * 2, "dend",
 			 "section",
 			 "file(member)");
 
       for (vp = vmap; vp; vp = vp->nxt)
 	printf_unfiltered ("\t0x%s 0x%s 0x%s 0x%s %s%s%s%s\n",
-			   paddr (vp->tstart),
-			   paddr (vp->tend),
-			   paddr (vp->dstart),
-			   paddr (vp->dend),
+			   phex (vp->tstart, addr_size),
+			   phex (vp->tend, addr_size),
+			   phex (vp->dstart, addr_size),
+			   phex (vp->dend, addr_size),
 			   vp->name,
 			   *vp->member ? "(" : "", vp->member,
 			   *vp->member ? ")" : "");
Index: gdb-head/gdb/fbsd-nat.c
===================================================================
--- gdb-head.orig/gdb/fbsd-nat.c
+++ gdb-head/gdb/fbsd-nat.c
@@ -127,8 +127,8 @@ fbsd_find_memory_regions (int (*func) (C
       if (info_verbose)
 	{
 	  fprintf_filtered (gdb_stdout, 
-			    "Save segment, %ld bytes at 0x%s (%c%c%c)\n", 
-			    size, paddr_nz (start),
+			    "Save segment, %ld bytes at %s (%c%c%c)\n",
+			    size, paddress (target_gdbarch, start),
 			    read ? 'r' : '-',
 			    write ? 'w' : '-',
 			    exec ? 'x' : '-');
Index: gdb-head/gdb/findcmd.c
===================================================================
--- gdb-head.orig/gdb/findcmd.c
+++ gdb-head/gdb/findcmd.c
@@ -276,7 +276,7 @@ find_command (char *args, int from_tty)
       if (found <= 0)
 	break;
 
-      print_address (found_addr, gdb_stdout);
+      print_address (gdbarch, found_addr, gdb_stdout);
       printf_filtered ("\n");
       ++found_count;
       last_found_addr = found_addr;
Index: gdb-head/gdb/frame.c
===================================================================
--- gdb-head.orig/gdb/frame.c
+++ gdb-head/gdb/frame.c
@@ -169,7 +169,7 @@ static void
 fprint_field (struct ui_file *file, const char *name, int p, CORE_ADDR addr)
 {
   if (p)
-    fprintf_unfiltered (file, "%s=0x%s", name, paddr_nz (addr));
+    fprintf_unfiltered (file, "%s=%s", name, hex_string (addr));
   else
     fprintf_unfiltered (file, "!%s", name);
 }
@@ -242,7 +242,7 @@ fprint_frame (struct ui_file *file, stru
   fprintf_unfiltered (file, ",");
   fprintf_unfiltered (file, "pc=");
   if (fi->next != NULL && fi->next->prev_pc.p)
-    fprintf_unfiltered (file, "0x%s", paddr_nz (fi->next->prev_pc.value));
+    fprintf_unfiltered (file, "%s", hex_string (fi->next->prev_pc.value));
   else
     fprintf_unfiltered (file, "<unknown>");
   fprintf_unfiltered (file, ",");
@@ -254,7 +254,7 @@ fprint_frame (struct ui_file *file, stru
   fprintf_unfiltered (file, ",");
   fprintf_unfiltered (file, "func=");
   if (fi->next != NULL && fi->next->prev_func.p)
-    fprintf_unfiltered (file, "0x%s", paddr_nz (fi->next->prev_func.addr));
+    fprintf_unfiltered (file, "%s", hex_string (fi->next->prev_func.addr));
   else
     fprintf_unfiltered (file, "<unknown>");
   fprintf_unfiltered (file, "}");
@@ -573,7 +573,7 @@ frame_unwind_pc (struct frame_info *this
 	fprintf_unfiltered (gdb_stdlog,
 			    "{ frame_unwind_caller_pc (this_frame=%d) -> 0x%s }\n",
 			    this_frame->level,
-			    paddr_nz (this_frame->prev_pc.value));
+			    hex_string (this_frame->prev_pc.value));
     }
   return this_frame->prev_pc.value;
 }
@@ -598,9 +598,9 @@ get_frame_func (struct frame_info *this_
       next_frame->prev_func.addr = get_pc_function_start (addr_in_block);
       if (frame_debug)
 	fprintf_unfiltered (gdb_stdlog,
-			    "{ get_frame_func (this_frame=%d) -> 0x%s }\n",
+			    "{ get_frame_func (this_frame=%d) -> %s }\n",
 			    this_frame->level,
-			    paddr_nz (next_frame->prev_func.addr));
+			    hex_string (next_frame->prev_func.addr));
     }
   return next_frame->prev_func.addr;
 }
@@ -774,8 +774,9 @@ frame_unwind_register_value (struct fram
 	    fprintf_unfiltered (gdb_stdlog, " register=%d",
 				VALUE_REGNUM (value));
 	  else if (VALUE_LVAL (value) == lval_memory)
-	    fprintf_unfiltered (gdb_stdlog, " address=0x%s",
-				paddr_nz (value_address (value)));
+	    fprintf_unfiltered (gdb_stdlog, " address=%s",
+				paddress (gdbarch,
+					  value_address (value)));
 	  else
 	    fprintf_unfiltered (gdb_stdlog, " computed");
 
@@ -1202,8 +1203,8 @@ create_new_frame (CORE_ADDR addr, CORE_A
   if (frame_debug)
     {
       fprintf_unfiltered (gdb_stdlog,
-			  "{ create_new_frame (addr=0x%s, pc=0x%s) ",
-			  paddr_nz (addr), paddr_nz (pc));
+			  "{ create_new_frame (addr=%s, pc=%s) ",
+			  hex_string (addr), hex_string (pc));
     }
 
   fi = FRAME_OBSTACK_ZALLOC (struct frame_info);
Index: gdb-head/gdb/f-valprint.c
===================================================================
--- gdb-head.orig/gdb/f-valprint.c
+++ gdb-head/gdb/f-valprint.c
@@ -281,13 +281,13 @@ f_val_print (struct type *type, const gd
 	  if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
 	    {
 	      /* Try to print what function it points to.  */
-	      print_address_demangle (addr, stream, demangle);
+	      print_address_demangle (gdbarch, addr, stream, demangle);
 	      /* Return value is irrelevant except for string pointers.  */
 	      return 0;
 	    }
 
 	  if (options->addressprint && options->format != 's')
-	    fputs_filtered (paddress (addr), stream);
+	    fputs_filtered (paddress (gdbarch, addr), stream);
 
 	  /* For a pointer to char or unsigned char, also print the string
 	     pointed to, unless pointer is null.  */
@@ -312,7 +312,7 @@ f_val_print (struct type *type, const gd
 	  CORE_ADDR addr
 	    = extract_typed_address (valaddr + embedded_offset, type);
 	  fprintf_filtered (stream, "@");
-	  fputs_filtered (paddress (addr), stream);
+	  fputs_filtered (paddress (gdbarch, addr), stream);
 	  if (options->deref_ref)
 	    fputs_filtered (": ", stream);
 	}
@@ -345,7 +345,7 @@ f_val_print (struct type *type, const gd
       type_print (type, "", stream, -1);
       fprintf_filtered (stream, "} ");
       /* Try to print what function it points to, and its address.  */
-      print_address_demangle (address, stream, demangle);
+      print_address_demangle (gdbarch, address, stream, demangle);
       break;
 
     case TYPE_CODE_INT:
Index: gdb-head/gdb/gcore.c
===================================================================
--- gdb-head.orig/gdb/gcore.c
+++ gdb-head/gdb/gcore.c
@@ -331,8 +331,8 @@ gcore_create_callback (CORE_ADDR vaddr, 
     {
       if (info_verbose)
         {
-          fprintf_filtered (gdb_stdout, "Ignore segment, %s bytes at 0x%s\n",
-                            plongest (size), paddr_nz (vaddr));
+          fprintf_filtered (gdb_stdout, "Ignore segment, %s bytes at %s\n",
+                            plongest (size), paddress (target_gdbarch, vaddr));
         }
 
       return 0;
@@ -389,8 +389,8 @@ gcore_create_callback (CORE_ADDR vaddr, 
 
   if (info_verbose)
     {
-      fprintf_filtered (gdb_stdout, "Save segment, %s bytes at 0x%s\n",
-			plongest (size), paddr_nz (vaddr));
+      fprintf_filtered (gdb_stdout, "Save segment, %s bytes at %s\n",
+			plongest (size), paddress (target_gdbarch, vaddr));
     }
 
   bfd_set_section_size (obfd, osec, size);
@@ -482,8 +482,9 @@ gcore_copy_callback (bfd *obfd, asection
       if (target_read_memory (bfd_section_vma (obfd, osec) + offset,
 			      memhunk, size) != 0)
 	{
-	  warning (_("Memory read failed for corefile section, %s bytes at 0x%s."),
-		   plongest (size), paddr (bfd_section_vma (obfd, osec)));
+	  warning (_("Memory read failed for corefile section, %s bytes at %s."),
+		   plongest (size),
+		   paddress (target_gdbarch, bfd_section_vma (obfd, osec)));
 	  break;
 	}
       if (!bfd_set_section_contents (obfd, osec, memhunk, offset, size))
Index: gdb-head/gdb/gnu-v3-abi.c
===================================================================
--- gdb-head.orig/gdb/gnu-v3-abi.c
+++ gdb-head/gdb/gnu-v3-abi.c
@@ -604,7 +604,7 @@ gnuv3_print_method_ptr (const gdb_byte *
       print_longest (stream, 'd', 1, ptr_value);
     }
   else
-    print_address_demangle (ptr_value, stream, demangle);
+    print_address_demangle (gdbarch, ptr_value, stream, demangle);
 
   if (adjustment)
     {
Index: gdb-head/gdb/hppa-tdep.c
===================================================================
--- gdb-head.orig/gdb/hppa-tdep.c
+++ gdb-head/gdb/hppa-tdep.c
@@ -461,8 +461,8 @@ find_unwind_entry (CORE_ADDR pc)
   struct hppa_objfile_private *priv;
 
   if (hppa_debug)
-    fprintf_unfiltered (gdb_stdlog, "{ find_unwind_entry 0x%s -> ",
-		        paddr_nz (pc));
+    fprintf_unfiltered (gdb_stdlog, "{ find_unwind_entry %s -> ",
+		        hex_string (pc));
 
   /* A function at address 0?  Not in HP-UX! */
   if (pc == (CORE_ADDR) 0)
@@ -496,8 +496,8 @@ find_unwind_entry (CORE_ADDR pc)
 	&& pc <= ui->cache->region_end)
       {
 	if (hppa_debug)
-	  fprintf_unfiltered (gdb_stdlog, "0x%s (cached) }\n",
-            paddr_nz ((uintptr_t) ui->cache));
+	  fprintf_unfiltered (gdb_stdlog, "%s (cached) }\n",
+            hex_string ((uintptr_t) ui->cache));
         return ui->cache;
       }
 
@@ -514,8 +514,8 @@ find_unwind_entry (CORE_ADDR pc)
 	  {
 	    ui->cache = &ui->table[middle];
 	    if (hppa_debug)
-	      fprintf_unfiltered (gdb_stdlog, "0x%s }\n",
-                paddr_nz ((uintptr_t) ui->cache));
+	      fprintf_unfiltered (gdb_stdlog, "%s }\n",
+                hex_string ((uintptr_t) ui->cache));
 	    return &ui->table[middle];
 	  }
 
@@ -1833,8 +1833,8 @@ hppa_frame_cache (struct frame_info *thi
   if ((*this_cache) != NULL)
     {
       if (hppa_debug)
-        fprintf_unfiltered (gdb_stdlog, "base=0x%s (cached) }", 
-          paddr_nz (((struct hppa_frame_cache *)*this_cache)->base));
+        fprintf_unfiltered (gdb_stdlog, "base=%s (cached) }",
+          paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
       return (*this_cache);
     }
   cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
@@ -1935,7 +1935,8 @@ hppa_frame_cache (struct frame_info *thi
 
 	if (!safe_frame_unwind_memory (this_frame, pc, buf4, sizeof buf4)) 
 	  {
-	    error (_("Cannot read instruction at 0x%s."), paddr_nz (pc));
+	    error (_("Cannot read instruction at %s."),
+		   paddress (gdbarch, pc));
 	    return (*this_cache);
 	  }
 
@@ -2064,11 +2065,11 @@ hppa_frame_cache (struct frame_info *thi
     CORE_ADDR fp;
 
     if (hppa_debug)
-      fprintf_unfiltered (gdb_stdlog, " (this_sp=0x%s, pc=0x%s, "
-		          "prologue_end=0x%s) ",
-		          paddr_nz (this_sp),
-			  paddr_nz (get_frame_pc (this_frame)),
-			  paddr_nz (prologue_end));
+      fprintf_unfiltered (gdb_stdlog, " (this_sp=%s, pc=%s, "
+		          "prologue_end=%s) ",
+		          paddress (gdbarch, this_sp),
+			  paddress (gdbarch, get_frame_pc (this_frame)),
+			  paddress (gdbarch, prologue_end));
 
      /* Check to see if a frame pointer is available, and use it for
         frame unwinding if it is.
@@ -2099,8 +2100,8 @@ hppa_frame_cache (struct frame_info *thi
  	cache->base = fp;
  
  	if (hppa_debug)
-	  fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [frame pointer]",
- 	    paddr_nz (cache->base));
+	  fprintf_unfiltered (gdb_stdlog, " (base=%s) [frame pointer]",
+			      paddress (gdbarch, cache->base));
       }
      else if (u->Save_SP 
 	      && trad_frame_addr_p (cache->saved_regs, HPPA_SP_REGNUM))
@@ -2112,8 +2113,8 @@ hppa_frame_cache (struct frame_info *thi
 			    (this_sp, gdbarch_ptr_bit (gdbarch) / 8);
 
 	    if (hppa_debug)
-	      fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [saved]",
-			          paddr_nz (cache->base));
+	      fprintf_unfiltered (gdb_stdlog, " (base=%s) [saved]",
+			          paddress (gdbarch, cache->base));
       }
     else
       {
@@ -2121,8 +2122,8 @@ hppa_frame_cache (struct frame_info *thi
 	   the SP back.  */
         cache->base = this_sp - frame_size;
 	if (hppa_debug)
-	  fprintf_unfiltered (gdb_stdlog, " (base=0x%s) [unwind adjust]",
-			      paddr_nz (cache->base));
+	  fprintf_unfiltered (gdb_stdlog, " (base=%s) [unwind adjust]",
+			      paddress (gdbarch, cache->base));
 
       }
     trad_frame_set_value (cache->saved_regs, HPPA_SP_REGNUM, cache->base);
@@ -2206,8 +2207,8 @@ hppa_frame_cache (struct frame_info *thi
   }
 
   if (hppa_debug)
-    fprintf_unfiltered (gdb_stdlog, "base=0x%s }", 
-      paddr_nz (((struct hppa_frame_cache *)*this_cache)->base));
+    fprintf_unfiltered (gdb_stdlog, "base=%s }",
+      paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
   return (*this_cache);
 }
 
@@ -2533,12 +2534,10 @@ unwind_command (char *exp, int from_tty)
 
   printf_unfiltered ("unwind_table_entry (0x%lx):\n", (unsigned long)u);
 
-  printf_unfiltered ("\tregion_start = ");
-  print_address (u->region_start, gdb_stdout);
+  printf_unfiltered ("\tregion_start = %s\n", hex_string (u->region_start));
   gdb_flush (gdb_stdout);
 
-  printf_unfiltered ("\n\tregion_end = ");
-  print_address (u->region_end, gdb_stdout);
+  printf_unfiltered ("\tregion_end = %s\n", hex_string (u->region_end));
   gdb_flush (gdb_stdout);
 
 #define pif(FLD) if (u->FLD) printf_unfiltered (" "#FLD);
@@ -2943,7 +2942,8 @@ hppa_skip_trampoline_code (struct frame_
 	  /* Sanity check: are we pointing to the PLT stub?  */
   	  if (!hppa_match_insns (pc, hppa_plt_stub, insn))
 	    {
-	      warning (_("Cannot resolve PLT stub at 0x%s."), paddr_nz (pc));
+	      warning (_("Cannot resolve PLT stub at %s."),
+		       paddress (gdbarch, pc));
 	      return 0;
 	    }
 
Index: gdb-head/gdb/i386-cygwin-tdep.c
===================================================================
--- gdb-head.orig/gdb/i386-cygwin-tdep.c
+++ gdb-head/gdb/i386-cygwin-tdep.c
@@ -113,6 +113,7 @@ i386_windows_regset_from_core_section (s
 
 struct cpms_data
 {
+  struct gdbarch *gdbarch;
   struct obstack *obstack;
   int module_count;
 };
@@ -157,7 +158,8 @@ core_process_module_section (bfd *abfd, 
 
   /* The first module is the .exe itself.  */
   if (data->module_count != 0)
-    windows_xfer_shared_library (module_name, base_addr, data->obstack);
+    windows_xfer_shared_library (module_name, base_addr,
+				 data->gdbarch, data->obstack);
   data->module_count++;
 
 out:
@@ -174,7 +176,7 @@ windows_core_xfer_shared_libraries (stru
   struct obstack obstack;
   const char *buf;
   LONGEST len_avail;
-  struct cpms_data data = { &obstack, 0 };
+  struct cpms_data data = { gdbarch, &obstack, 0 };
 
   obstack_init (&obstack);
   obstack_grow_str (&obstack, "<library-list>\n");
Index: gdb-head/gdb/i386-nat.c
===================================================================
--- gdb-head.orig/gdb/i386-nat.c
+++ gdb-head/gdb/i386-nat.c
@@ -217,6 +217,7 @@ static void
 i386_show_dr (const char *func, CORE_ADDR addr,
 	      int len, enum target_hw_bp_type type)
 {
+  int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
   int i;
 
   puts_unfiltered (func);
@@ -240,8 +241,8 @@ i386_show_dr (const char *func, CORE_ADD
     {
       printf_unfiltered ("\
 \tDR%d: addr=0x%s, ref.count=%d  DR%d: addr=0x%s, ref.count=%d\n",
-			 i, paddr(dr_mirror[i]), dr_ref_count[i],
-			 i+1, paddr(dr_mirror[i+1]), dr_ref_count[i+1]);
+		 i, phex (dr_mirror[i], addr_size), dr_ref_count[i],
+		 i+1, phex (dr_mirror[i+1], addr_size), dr_ref_count[i+1]);
       i++;
     }
 }
Index: gdb-head/gdb/i386-tdep.c
===================================================================
--- gdb-head.orig/gdb/i386-tdep.c
+++ gdb-head/gdb/i386-tdep.c
@@ -428,9 +428,10 @@ i386_displaced_step_fixup (struct gdbarc
 
   if (debug_displaced)
     fprintf_unfiltered (gdb_stdlog,
-                        "displaced: fixup (0x%s, 0x%s), "
+                        "displaced: fixup (%s, %s), "
                         "insn = 0x%02x 0x%02x ...\n",
-                        paddr_nz (from), paddr_nz (to), insn[0], insn[1]);
+                        paddress (gdbarch, from), paddress (gdbarch, to),
+			insn[0], insn[1]);
 
   /* The list of issues to contend with here is taken from
      resume_execution in arch/i386/kernel/kprobes.c, Linux 2.6.20.
@@ -499,8 +500,9 @@ i386_displaced_step_fixup (struct gdbarc
           if (debug_displaced)
             fprintf_unfiltered (gdb_stdlog,
                                 "displaced: "
-                                "relocated %%eip from 0x%s to 0x%s\n",
-                                paddr_nz (orig_eip), paddr_nz (eip));
+                                "relocated %%eip from %s to %s\n",
+                                paddress (gdbarch, orig_eip),
+				paddress (gdbarch, eip));
         }
     }
 
@@ -525,10 +527,9 @@ i386_displaced_step_fixup (struct gdbarc
 
       if (debug_displaced)
         fprintf_unfiltered (gdb_stdlog,
-                            "displaced: relocated return addr at 0x%s "
-                            "to 0x%s\n",
-                            paddr_nz (esp),
-                            paddr_nz (retaddr));
+                            "displaced: relocated return addr at %s to %s\n",
+                            paddress (gdbarch, esp),
+                            paddress (gdbarch, retaddr));
     }
 }
 
@@ -2764,12 +2765,14 @@ struct i386_record_s
 static int
 i386_record_modrm (struct i386_record_s *irp)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (irp->regcache);
+
   if (target_read_memory (irp->addr, &irp->modrm, 1))
     {
       if (record_debug)
 	printf_unfiltered (_("Process record: error reading memory at "
-			     "addr 0x%s len = 1.\n"),
-			   paddr_nz (irp->addr));
+			     "addr %s len = 1.\n"),
+			   paddress (gdbarch, irp->addr));
       return -1;
     }
   irp->addr++;
@@ -2787,6 +2790,7 @@ i386_record_modrm (struct i386_record_s 
 static int
 i386_record_lea_modrm_addr (struct i386_record_s *irp, uint32_t * addr)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (irp->regcache);
   uint8_t tmpu8;
   uint16_t tmpu16;
   uint32_t tmpu32;
@@ -2807,8 +2811,8 @@ i386_record_lea_modrm_addr (struct i386_
 	    {
 	      if (record_debug)
 		printf_unfiltered (_("Process record: error reading memory "
-				     "at addr 0x%s len = 1.\n"),
-				   paddr_nz (irp->addr));
+				     "at addr %s len = 1.\n"),
+				   paddress (gdbarch, irp->addr));
 	      return -1;
 	    }
 	  irp->addr++;
@@ -2827,8 +2831,8 @@ i386_record_lea_modrm_addr (struct i386_
 		{
 		  if (record_debug)
 		    printf_unfiltered (_("Process record: error reading "
-				         "memory at addr 0x%s len = 4.\n"),
-				       paddr_nz (irp->addr));
+				         "memory at addr %s len = 4.\n"),
+				       paddress (gdbarch, irp->addr));
 		  return -1;
 		}
 	      irp->addr += 4;
@@ -2843,8 +2847,8 @@ i386_record_lea_modrm_addr (struct i386_
 	    {
 	      if (record_debug)
 		printf_unfiltered (_("Process record: error reading memory "
-				     "at addr 0x%s len = 1.\n"),
-				   paddr_nz (irp->addr));
+				     "at addr %s len = 1.\n"),
+				   paddress (gdbarch, irp->addr));
 	      return -1;
 	    }
 	  irp->addr++;
@@ -2855,8 +2859,8 @@ i386_record_lea_modrm_addr (struct i386_
 	    {
 	      if (record_debug)
 		printf_unfiltered (_("Process record: error reading memory "
-				     "at addr 0x%s len = 4.\n"),
-				   paddr_nz (irp->addr));
+				     "at addr %s len = 4.\n"),
+				   paddress (gdbarch, irp->addr));
 	      return -1;
 	    }
 	  irp->addr += 4;
@@ -2889,8 +2893,8 @@ i386_record_lea_modrm_addr (struct i386_
 		{
 		  if (record_debug)
 		    printf_unfiltered (_("Process record: error reading "
-					 "memory at addr 0x%s len = 2.\n"),
-				       paddr_nz (irp->addr));
+					 "memory at addr %s len = 2.\n"),
+				       paddress (gdbarch, irp->addr));
 		  return -1;
 		}
 	      irp->addr += 2;
@@ -2908,8 +2912,8 @@ i386_record_lea_modrm_addr (struct i386_
 	    {
 	      if (record_debug)
 		printf_unfiltered (_("Process record: error reading memory "
-				     "at addr 0x%s len = 1.\n"),
-				   paddr_nz (irp->addr));
+				     "at addr %s len = 1.\n"),
+				   paddress (gdbarch, irp->addr));
 	      return -1;
 	    }
 	  irp->addr++;
@@ -2920,8 +2924,8 @@ i386_record_lea_modrm_addr (struct i386_
 	    {
 	      if (record_debug)
 		printf_unfiltered (_("Process record: error reading memory "
-				     "at addr 0x%s len = 2.\n"),
-				   paddr_nz (irp->addr));
+				     "at addr %s len = 2.\n"),
+				   paddress (gdbarch, irp->addr));
 	      return -1;
 	    }
 	  irp->addr += 2;
@@ -2998,15 +3002,16 @@ no_rm:
 static int
 i386_record_lea_modrm (struct i386_record_s *irp)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (irp->regcache);
   uint32_t addr;
 
   if (irp->override)
     {
       if (record_debug)
 	printf_unfiltered (_("Process record ignores the memory change "
-			     "of instruction at address 0x%s because it "
+			     "of instruction at address %s because it "
 			     "can't get the value of the segment register.\n"),
-			   paddr_nz (irp->addr));
+			   paddress (gdbarch, irp->addr));
       return 0;
     }
 
@@ -3042,8 +3047,8 @@ i386_process_record (struct gdbarch *gdb
 
   if (record_debug > 1)
     fprintf_unfiltered (gdb_stdlog, "Process record: i386_process_record "
-			            "addr = 0x%s\n",
-			paddr_nz (ir.addr));
+			            "addr = %s\n",
+			paddress (gdbarch, ir.addr));
 
   /* prefixes */
   while (1)
@@ -3052,8 +3057,8 @@ i386_process_record (struct gdbarch *gdb
 	{
 	  if (record_debug)
 	    printf_unfiltered (_("Process record: error reading memory at "
-				 "addr 0x%s len = 1.\n"),
-			       paddr_nz (ir.addr));
+				 "addr %s len = 1.\n"),
+			       paddress (gdbarch, ir.addr));
 	  return -1;
 	}
       ir.addr++;
@@ -3113,8 +3118,8 @@ reswitch:
 	{
 	  if (record_debug)
 	    printf_unfiltered (_("Process record: error reading memory at "
-				 "addr 0x%s len = 1.\n"),
-			       paddr_nz (ir.addr));
+				 "addr %s len = 1.\n"),
+			       paddress (gdbarch, ir.addr));
 	  return -1;
 	}
       ir.addr++;
@@ -3852,10 +3857,10 @@ reswitch:
 	  {
 	    if (record_debug)
 	      printf_unfiltered (_("Process record ignores the memory change "
-				   "of instruction at address 0x%s because "
+				   "of instruction at address %s because "
 				   "it can't get the value of the segment "
 				   "register.\n"),
-				 paddr_nz (ir.addr));
+				 paddress (gdbarch, ir.addr));
 	  }
 	else
 	  {
@@ -3870,8 +3875,8 @@ reswitch:
 		  {
 		    if (record_debug)
 		      printf_unfiltered (_("Process record: error reading "
-					   "memory at addr 0x%s len = 4.\n"),
-					 paddr_nz (ir.addr));
+					   "memory at addr %s len = 4.\n"),
+					 paddress (gdbarch, ir.addr));
 		    return -1;
 		  }
 		ir.addr += 4;
@@ -3883,8 +3888,8 @@ reswitch:
 		  {
 		    if (record_debug)
 		      printf_unfiltered (_("Process record: error reading "
-					   "memory at addr 0x%s len = 4.\n"),
-					 paddr_nz (ir.addr));
+					   "memory at addr %s len = 4.\n"),
+					 paddress (gdbarch, ir.addr));
 		    return -1;
 		  }
 		ir.addr += 2;
@@ -4272,10 +4277,10 @@ reswitch:
 	    /* addr += ((uint32_t)read_register (I386_ES_REGNUM)) << 4; */
 	    if (record_debug)
 	      printf_unfiltered (_("Process record ignores the memory change "
-				   "of instruction at address 0x%s because "
+				   "of instruction at address %s because "
 				   "it can't get the value of the segment "
 				   "register.\n"),
-				 paddr_nz (ir.addr));
+				 paddress (gdbarch, ir.addr));
 	  }
 
 	if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ))
@@ -4681,8 +4686,8 @@ reswitch:
 	  {
 	    if (record_debug)
 	      printf_unfiltered (_("Process record: error reading memory "
-				   "at addr 0x%s len = 1.\n"),
-				 paddr_nz (ir.addr));
+				   "at addr %s len = 1.\n"),
+				 paddress (gdbarch, ir.addr));
 	    return -1;
 	  }
 	ir.addr++;
@@ -4889,10 +4894,10 @@ reswitch:
 		if (record_debug)
 		  printf_unfiltered (_("Process record ignores the memory "
 				       "change of instruction at "
-				       "address 0x%s because it can't get "
+				       "address %s because it can't get "
 				       "the value of the segment "
 				       "register.\n"),
-				     paddr_nz (ir.addr));
+				     paddress (gdbarch, ir.addr));
 	      }
 	    else
 	      {
@@ -4934,10 +4939,10 @@ reswitch:
 		  if (record_debug)
 		    printf_unfiltered (_("Process record ignores the memory "
 					 "change of instruction at "
-					 "address 0x%s because it can't get "
+					 "address %s because it can't get "
 					 "the value of the segment "
 					 "register.\n"),
-				       paddr_nz (ir.addr));
+				       paddress (gdbarch, ir.addr));
 		}
 	      else
 		{
@@ -5122,8 +5127,8 @@ reswitch:
 
 no_support:
   printf_unfiltered (_("Process record doesn't support instruction 0x%02x "
-		       "at address 0x%s.\n"),
-		     (unsigned int) (opcode), paddr_nz (ir.addr));
+		       "at address %s.\n"),
+		     (unsigned int) (opcode), paddress (gdbarch, ir.addr));
   return -1;
 }
 
Index: gdb-head/gdb/ia64-tdep.c
===================================================================
--- gdb-head.orig/gdb/ia64-tdep.c
+++ gdb-head/gdb/ia64-tdep.c
@@ -650,7 +650,7 @@ ia64_memory_insert_breakpoint (struct gd
   if (instr_breakpoint == IA64_BREAKPOINT)
     internal_error (__FILE__, __LINE__,
 		    _("Address %s already contains a breakpoint."),
-		    paddr_nz (bp_tgt->placed_address));
+		    paddress (gdbarch, bp_tgt->placed_address));
   replace_slotN_contents (bundle, IA64_BREAKPOINT, slotnum);
 
   if (val == 0)
@@ -697,7 +697,7 @@ ia64_memory_remove_breakpoint (struct gd
     {
       warning (_("Cannot remove breakpoint at address %s, "
 		 "no break instruction at such address."),
-	       paddr_nz (bp_tgt->placed_address));
+	       paddress (gdbarch, bp_tgt->placed_address));
       return -1;
     }
 
@@ -1720,6 +1720,7 @@ static void
 ia64_frame_this_id (struct frame_info *this_frame, void **this_cache,
 		    struct frame_id *this_id)
 {
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
   struct ia64_frame_cache *cache =
     ia64_frame_cache (this_frame, this_cache);
 
@@ -1730,10 +1731,10 @@ ia64_frame_this_id (struct frame_info *t
     (*this_id) = frame_id_build_special (cache->base, cache->pc, cache->bsp);
   if (gdbarch_debug >= 1)
     fprintf_unfiltered (gdb_stdlog,
-			"regular frame id: code 0x%s, stack 0x%s, special 0x%s, this_frame %s\n",
-			paddr_nz (this_id->code_addr), 
-			paddr_nz (this_id->stack_addr), 
-			paddr_nz (cache->bsp),
+			"regular frame id: code %s, stack %s, special %s, this_frame %s\n",
+			paddress (gdbarch, this_id->code_addr),
+			paddress (gdbarch, this_id->stack_addr),
+			paddress (gdbarch, cache->bsp),
 			host_address_to_string (this_frame));
 }
 
@@ -2078,6 +2079,7 @@ static void
 ia64_sigtramp_frame_this_id (struct frame_info *this_frame,
 			     void **this_cache, struct frame_id *this_id)
 {
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
   struct ia64_frame_cache *cache =
     ia64_sigtramp_frame_cache (this_frame, this_cache);
 
@@ -2086,10 +2088,10 @@ ia64_sigtramp_frame_this_id (struct fram
                                        cache->bsp);
   if (gdbarch_debug >= 1)
     fprintf_unfiltered (gdb_stdlog,
-			"sigtramp frame id: code 0x%s, stack 0x%s, special 0x%s, this_frame %s\n",
-			paddr_nz (this_id->code_addr), 
-			paddr_nz (this_id->stack_addr), 
-			paddr_nz (cache->bsp),
+			"sigtramp frame id: code %s, stack %s, special %s, this_frame %s\n",
+			paddress (gdbarch, this_id->code_addr),
+			paddress (gdbarch, this_id->stack_addr),
+			paddress (gdbarch, cache->bsp),
 			host_address_to_string (this_frame));
 }
 
@@ -2298,6 +2300,7 @@ ia64_access_reg (unw_addr_space_t as, un
   int regnum = ia64_uw2gdb_regnum (uw_regnum);
   unw_word_t bsp, sof, sol, cfm, psr, ip;
   struct frame_info *this_frame = arg;
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
   long new_sof, old_sof;
   char buf[MAX_REGISTER_SIZE];
   
@@ -2344,10 +2347,10 @@ ia64_access_reg (unw_addr_space_t as, un
       
   if (gdbarch_debug >= 1)
     fprintf_unfiltered (gdb_stdlog, 
-			"  access_reg: from cache: %4s=0x%s\n",
+			"  access_reg: from cache: %4s=%s\n",
 			(((unsigned) regnum <= IA64_NAT127_REGNUM)
 			? ia64_register_names[regnum] : "r??"), 
-			paddr_nz (*val));
+			paddress (*val));
   return 0;
 }
 
@@ -2375,6 +2378,7 @@ ia64_access_rse_reg (unw_addr_space_t as
   int regnum = ia64_uw2gdb_regnum (uw_regnum);
   unw_word_t bsp, sof, sol, cfm, psr, ip;
   struct regcache *regcache = arg;
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   long new_sof, old_sof;
   char buf[MAX_REGISTER_SIZE];
   
@@ -2421,10 +2425,10 @@ ia64_access_rse_reg (unw_addr_space_t as
       
   if (gdbarch_debug >= 1)
     fprintf_unfiltered (gdb_stdlog, 
-			"  access_rse_reg: from cache: %4s=0x%s\n",
+			"  access_rse_reg: from cache: %4s=%s\n",
 			(((unsigned) regnum <= IA64_NAT127_REGNUM)
 			 ? ia64_register_names[regnum] : "r??"), 
-			paddr_nz (*val));
+			paddress (gdbarch, *val));
 
   return 0;
 }
@@ -2526,11 +2530,11 @@ get_kernel_table (unw_word_t ip, unw_dyn
   
   if (gdbarch_debug >= 1)
     fprintf_unfiltered (gdb_stdlog, "get_kernel_table: found table `%s': "
-			"segbase=0x%s, length=%s, gp=0x%s\n",
+			"segbase=%s, length=%s, gp=%s\n",
 			(char *) di->u.ti.name_ptr, 
-			paddr_nz (di->u.ti.segbase), 
+			hex_string (di->u.ti.segbase),
 			pulongest (di->u.ti.table_len), 
-			paddr_nz (di->gp));
+			hex_string (di->gp));
   return 0;
 }
 
@@ -2631,15 +2635,15 @@ ia64_find_proc_info_x (unw_addr_space_t 
 	return -UNW_ENOINFO;
 
       if (gdbarch_debug >= 1)
-	fprintf_unfiltered (gdb_stdlog, "ia64_find_proc_info_x: 0x%s -> "
-			    "(name=`%s',segbase=0x%s,start=0x%s,end=0x%s,gp=0x%s,"
-			    "length=%s,data=0x%s)\n",
-			    paddr_nz (ip), (char *)di.u.ti.name_ptr,
-			    paddr_nz (di.u.ti.segbase), 
-			    paddr_nz (di.start_ip), paddr_nz (di.end_ip),
-			    paddr_nz (di.gp), 
+	fprintf_unfiltered (gdb_stdlog, "ia64_find_proc_info_x: %s -> "
+			    "(name=`%s',segbase=%s,start=%s,end=%s,gp=%s,"
+			    "length=%s,data=%s)\n",
+			    hex_string (ip), (char *)di.u.ti.name_ptr,
+			    hex_string (di.u.ti.segbase),
+			    hex_string (di.start_ip), hex_string (di.end_ip),
+			    hex_string (di.gp),
 			    pulongest (di.u.ti.table_len), 
-			    paddr_nz ((CORE_ADDR)di.u.ti.table_data));
+			    hex_string ((CORE_ADDR)di.u.ti.table_data));
     }
   else
     {
@@ -2648,15 +2652,15 @@ ia64_find_proc_info_x (unw_addr_space_t 
 	return ret;
 
       if (gdbarch_debug >= 1)
-	fprintf_unfiltered (gdb_stdlog, "ia64_find_proc_info_x: 0x%s -> "
-			    "(name=`%s',segbase=0x%s,start=0x%s,end=0x%s,gp=0x%s,"
-			    "length=%s,data=0x%s)\n",
-			    paddr_nz (ip), (char *)di.u.rti.name_ptr,
-			    paddr_nz (di.u.rti.segbase), 
-			    paddr_nz (di.start_ip), paddr_nz (di.end_ip),
-			    paddr_nz (di.gp), 
+	fprintf_unfiltered (gdb_stdlog, "ia64_find_proc_info_x: %s -> "
+			    "(name=`%s',segbase=%s,start=%s,end=%s,gp=%s,"
+			    "length=%s,data=%s)\n",
+			    hex_string (ip), (char *)di.u.rti.name_ptr,
+			    hex_string (di.u.rti.segbase),
+			    hex_string (di.start_ip), hex_string (di.end_ip),
+			    hex_string (di.gp),
 			    pulongest (di.u.rti.table_len), 
-			    paddr_nz (di.u.rti.table_data));
+			    hex_string (di.u.rti.table_data));
     }
 
   ret = libunwind_search_unwind_table (&as, ip, &di, pi, need_unwind_info,
@@ -2709,9 +2713,9 @@ ia64_get_dyn_info_list (unw_addr_space_t
 	      if (gdbarch_debug >= 1)
 		fprintf_unfiltered (gdb_stdlog,
 				    "dynamic unwind table in objfile %s "
-				    "at 0x%s (gp=0x%s)\n",
+				    "at %s (gp=%s)\n",
 				    bfd_get_filename (objfile->obfd),
-				    paddr_nz (addr), paddr_nz (di.gp));
+				    hex_string (addr), hex_string (di.gp));
 	      *dilap = addr;
 	      return 0;
 	    }
@@ -2727,6 +2731,7 @@ static void
 ia64_libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache,
 			      struct frame_id *this_id)
 {
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
   struct frame_id id;
   char buf[8];
   CORE_ADDR bsp;
@@ -2748,9 +2753,10 @@ ia64_libunwind_frame_this_id (struct fra
 
   if (gdbarch_debug >= 1)
     fprintf_unfiltered (gdb_stdlog,
-			"libunwind frame id: code 0x%s, stack 0x%s, special 0x%s, this_frame %s\n",
-			paddr_nz (id.code_addr), paddr_nz (id.stack_addr), 
-			paddr_nz (bsp),
+			"libunwind frame id: code %s, stack %s, special %s, this_frame %s\n",
+			paddress (gdbarch, id.code_addr),
+			paddress (gdbarch, id.stack_addr),
+			paddress (gdbarch, bsp),
 			host_address_to_string (this_frame));
 }
 
@@ -2852,6 +2858,7 @@ ia64_libunwind_sigtramp_frame_this_id (s
                                        void **this_cache,
 				       struct frame_id *this_id)
 {
+  struct gdbarch *gdbarch = get_frame_arch (this_frame);
   char buf[8];
   CORE_ADDR bsp;
   struct frame_id id;
@@ -2874,9 +2881,10 @@ ia64_libunwind_sigtramp_frame_this_id (s
 
   if (gdbarch_debug >= 1)
     fprintf_unfiltered (gdb_stdlog,
-			"libunwind sigtramp frame id: code 0x%s, stack 0x%s, special 0x%s, this_frame %s\n",
-			paddr_nz (id.code_addr), paddr_nz (id.stack_addr), 
-			paddr_nz (bsp),
+			"libunwind sigtramp frame id: code %s, stack %s, special %s, this_frame %s\n",
+			paddress (gdbarch, id.code_addr),
+			paddress (gdbarch, id.stack_addr),
+			paddress (gdbarch, bsp),
 			host_address_to_string (this_frame));
 }
 
@@ -3574,9 +3582,9 @@ ia64_dummy_id (struct gdbarch *gdbarch, 
 
   if (gdbarch_debug >= 1)
     fprintf_unfiltered (gdb_stdlog,
-			"dummy frame id: code 0x%s, stack 0x%s, special 0x%s\n",
-			paddr_nz (get_frame_pc (this_frame)),
-			paddr_nz (sp), paddr_nz (bsp));
+			"dummy frame id: code %s, stack %s, special %s\n",
+			paddress (gdbarch, get_frame_pc (this_frame)),
+			paddress (gdbarch, sp), paddress (gdbarch, bsp));
 
   return frame_id_build_special (sp, get_frame_pc (this_frame), bsp);
 }
Index: gdb-head/gdb/infcmd.c
===================================================================
--- gdb-head.orig/gdb/infcmd.c
+++ gdb-head/gdb/infcmd.c
@@ -20,6 +20,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
+#include "arch-utils.h"
 #include <signal.h>
 #include "gdb_string.h"
 #include "symtab.h"
@@ -1029,6 +1030,7 @@ which has no line number information.\n"
 static void
 jump_command (char *arg, int from_tty)
 {
+  struct gdbarch *gdbarch = get_current_arch ();
   CORE_ADDR addr;
   struct symtabs_and_lines sals;
   struct symtab_and_line sal;
@@ -1098,7 +1100,7 @@ jump_command (char *arg, int from_tty)
   if (from_tty)
     {
       printf_filtered (_("Continuing at "));
-      fputs_filtered (paddress (addr), gdb_stdout);
+      fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
       printf_filtered (".\n");
     }
 
@@ -1655,7 +1657,8 @@ program_info (char *args, int from_tty)
   stat = bpstat_num (&bs, &num);
 
   target_files_info ();
-  printf_filtered (_("Program stopped at %s.\n"), paddress (stop_pc));
+  printf_filtered (_("Program stopped at %s.\n"),
+		   paddress (target_gdbarch, stop_pc));
   if (tp->stop_step)
     printf_filtered (_("It stopped after being stepped.\n"));
   else if (stat != 0)
Index: gdb-head/gdb/infrun.c
===================================================================
--- gdb-head.orig/gdb/infrun.c
+++ gdb-head/gdb/infrun.c
@@ -866,8 +866,8 @@ displaced_step_prepare (ptid_t ptid)
   read_memory (copy, displaced_step_saved_copy, len);
   if (debug_displaced)
     {
-      fprintf_unfiltered (gdb_stdlog, "displaced: saved 0x%s: ",
-			  paddr_nz (copy));
+      fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ",
+			  paddress (gdbarch, copy));
       displaced_step_dump_bytes (gdb_stdlog, displaced_step_saved_copy, len);
     };
 
@@ -895,8 +895,8 @@ displaced_step_prepare (ptid_t ptid)
   do_cleanups (old_cleanups);
 
   if (debug_displaced)
-    fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to 0x%s\n",
-			paddr_nz (copy));
+    fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n",
+			paddress (gdbarch, copy));
 
   return 1;
 }
@@ -928,8 +928,9 @@ displaced_step_fixup (ptid_t event_ptid,
     write_memory_ptid (displaced_step_ptid, displaced_step_copy,
 		       displaced_step_saved_copy, len);
     if (debug_displaced)
-      fprintf_unfiltered (gdb_stdlog, "displaced: restored 0x%s\n",
-                          paddr_nz (displaced_step_copy));
+      fprintf_unfiltered (gdb_stdlog, "displaced: restored %s\n",
+                          paddress (displaced_step_gdbarch,
+				    displaced_step_copy));
   }
 
   /* Did the instruction complete successfully?  */
@@ -962,6 +963,7 @@ displaced_step_fixup (ptid_t event_ptid,
     {
       struct displaced_step_request *head;
       ptid_t ptid;
+      struct regcache *regcache;
       CORE_ADDR actual_pc;
 
       head = displaced_step_request_queue;
@@ -971,7 +973,8 @@ displaced_step_fixup (ptid_t event_ptid,
 
       context_switch (ptid);
 
-      actual_pc = regcache_read_pc (get_thread_regcache (ptid));
+      regcache = get_thread_regcache (ptid);
+      actual_pc = regcache_read_pc (regcache);
 
       if (breakpoint_here_p (actual_pc))
 	{
@@ -984,10 +987,11 @@ displaced_step_fixup (ptid_t event_ptid,
 
 	  if (debug_displaced)
 	    {
+	      struct gdbarch *gdbarch = get_regcache_arch (regcache);
 	      gdb_byte buf[4];
 
-	      fprintf_unfiltered (gdb_stdlog, "displaced: run 0x%s: ",
-				  paddr_nz (actual_pc));
+	      fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
+				  paddress (gdbarch, actual_pc));
 	      read_memory (actual_pc, buf, sizeof (buf));
 	      displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
 	    }
@@ -1278,11 +1282,12 @@ a command like `return' or `jump' to con
           && tp->trap_expected)
         {
 	  struct regcache *resume_regcache = get_thread_regcache (resume_ptid);
+	  struct gdbarch *resume_gdbarch = get_regcache_arch (resume_regcache);
           CORE_ADDR actual_pc = regcache_read_pc (resume_regcache);
           gdb_byte buf[4];
 
-          fprintf_unfiltered (gdb_stdlog, "displaced: run 0x%s: ",
-                              paddr_nz (actual_pc));
+          fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ",
+                              paddress (resume_gdbarch, actual_pc));
           read_memory (actual_pc, buf, sizeof (buf));
           displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf));
         }
@@ -1507,8 +1512,8 @@ proceed (CORE_ADDR addr, enum target_sig
 
   if (debug_infrun)
     fprintf_unfiltered (gdb_stdlog,
-			"infrun: proceed (addr=0x%s, signal=%d, step=%d)\n",
-			paddr_nz (addr), siggnal, step);
+			"infrun: proceed (addr=%s, signal=%d, step=%d)\n",
+			paddress (gdbarch, addr), siggnal, step);
 
   if (non_stop)
     /* In non-stop, each thread is handled individually.  The context
@@ -2774,8 +2779,11 @@ targets should add new threads to the th
 
   if (debug_infrun)
     {
-      fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = 0x%s\n",
-                          paddr_nz (stop_pc));
+      struct regcache *regcache = get_thread_regcache (ecs->ptid);
+      struct gdbarch *gdbarch = get_regcache_arch (regcache);
+
+      fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n",
+                          paddress (gdbarch, stop_pc));
       if (target_stopped_by_watchpoint ())
 	{
           CORE_ADDR addr;
@@ -2783,8 +2791,8 @@ targets should add new threads to the th
 
           if (target_stopped_data_address (&current_target, &addr))
             fprintf_unfiltered (gdb_stdlog,
-                                "infrun: stopped data address = 0x%s\n",
-                                paddr_nz (addr));
+                                "infrun: stopped data address = %s\n",
+                                paddress (gdbarch, addr));
           else
             fprintf_unfiltered (gdb_stdlog,
                                 "infrun: (no data address available)\n");
@@ -3680,9 +3688,10 @@ infrun: not switching back to stepped th
 			  ecs->event_thread->step_frame_id)))
     {
       if (debug_infrun)
-	fprintf_unfiltered (gdb_stdlog, "infrun: stepping inside range [0x%s-0x%s]\n",
-			    paddr_nz (ecs->event_thread->step_range_start),
-			    paddr_nz (ecs->event_thread->step_range_end));
+	fprintf_unfiltered
+	  (gdb_stdlog, "infrun: stepping inside range [%s-%s]\n",
+	   paddress (gdbarch, ecs->event_thread->step_range_start),
+	   paddress (gdbarch, ecs->event_thread->step_range_end));
 
       /* When stepping backward, stop at beginning of line range
 	 (unless it's the function entry point, in which case
@@ -4279,8 +4288,8 @@ insert_step_resume_breakpoint_at_sal (st
 
   if (debug_infrun)
     fprintf_unfiltered (gdb_stdlog,
-			"infrun: inserting step-resume breakpoint at 0x%s\n",
-			paddr_nz (sr_sal.pc));
+			"infrun: inserting step-resume breakpoint at %s\n",
+			paddress (gdbarch, sr_sal.pc));
 
   inferior_thread ()->step_resume_breakpoint
     = set_momentary_breakpoint (gdbarch, sr_sal, sr_id, bp_step_resume);
@@ -4361,8 +4370,8 @@ insert_longjmp_resume_breakpoint (struct
 
   if (debug_infrun)
     fprintf_unfiltered (gdb_stdlog,
-			"infrun: inserting longjmp-resume breakpoint at 0x%s\n",
-			paddr_nz (pc));
+			"infrun: inserting longjmp-resume breakpoint at %s\n",
+			paddress (gdbarch, pc));
 
   inferior_thread ()->step_resume_breakpoint =
     set_momentary_breakpoint_at_pc (gdbarch, pc, bp_longjmp_resume);
Index: gdb-head/gdb/jv-valprint.c
===================================================================
--- gdb-head.orig/gdb/jv-valprint.c
+++ gdb-head/gdb/jv-valprint.c
@@ -134,7 +134,7 @@ java_value_print (struct value *val, str
 	      if (element == 0)
 		fprintf_filtered (stream, "null");
 	      else
-		fprintf_filtered (stream, "@%s", paddr_nz (element));
+		fprintf_filtered (stream, "@%s", paddress (gdbarch, element));
 
 	      things_printed++;
 	      i += reps;
@@ -461,6 +461,7 @@ java_val_print (struct type *type, const
 		struct ui_file *stream, int recurse,
 		const struct value_print_options *options)
 {
+  struct gdbarch *gdbarch = get_type_arch (type);
   unsigned int i = 0;	/* Number of characters printed */
   struct type *target_type;
   CORE_ADDR addr;
@@ -481,7 +482,8 @@ java_val_print (struct type *type, const
 	  /* Print vtable entry - we only get here if we ARE using
 	     -fvtable_thunks.  (Otherwise, look under TYPE_CODE_STRUCT.) */
 	  /* Extract an address, assume that it is unsigned.  */
-	  print_address_demangle (extract_unsigned_integer (valaddr, TYPE_LENGTH (type)),
+	  print_address_demangle (gdbarch,
+				  extract_unsigned_integer (valaddr, TYPE_LENGTH (type)),
 				  stream, demangle);
 	  break;
 	}
@@ -497,7 +499,7 @@ java_val_print (struct type *type, const
       if (TYPE_CODE (target_type) == TYPE_CODE_FUNC)
 	{
 	  /* Try to print what function it points to.  */
-	  print_address_demangle (addr, stream, demangle);
+	  print_address_demangle (gdbarch, addr, stream, demangle);
 	  /* Return value is irrelevant except for string pointers.  */
 	  return (0);
 	}
Index: gdb-head/gdb/linux-fork.c
===================================================================
--- gdb-head.orig/gdb/linux-fork.c
+++ gdb-head/gdb/linux-fork.c
@@ -18,6 +18,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
+#include "arch-utils.h"
 #include "inferior.h"
 #include "regcache.h"
 #include "gdbcmd.h"
@@ -480,6 +481,7 @@ detach_fork_command (char *args, int fro
 static void
 info_forks_command (char *arg, int from_tty)
 {
+  struct gdbarch *gdbarch = get_current_arch ();
   struct frame_info *cur_frame;
   struct symtab_and_line sal;
   struct symtab *cur_symtab;
@@ -512,7 +514,7 @@ info_forks_command (char *arg, int from_
       if (fp->num == 0)
 	printf_filtered (_(" (main process)"));
       printf_filtered (_(" at "));
-      fputs_filtered (paddress (pc), gdb_stdout);
+      fputs_filtered (paddress (gdbarch, pc), gdb_stdout);
 
       sal = find_pc_line (pc, 0);
       if (sal.symtab)
Index: gdb-head/gdb/linux-nat.c
===================================================================
--- gdb-head.orig/gdb/linux-nat.c
+++ gdb-head/gdb/linux-nat.c
@@ -3445,8 +3445,8 @@ linux_nat_find_memory_regions (int (*fun
       if (info_verbose)
 	{
 	  fprintf_filtered (gdb_stdout,
-			    "Save segment, %lld bytes at 0x%s (%c%c%c)",
-			    size, paddr_nz (addr),
+			    "Save segment, %lld bytes at %s (%c%c%c)",
+			    size, paddress (target_gdbarch, addr),
 			    read ? 'r' : ' ',
 			    write ? 'w' : ' ', exec ? 'x' : ' ');
 	  if (filename[0])
Index: gdb-head/gdb/m2-valprint.c
===================================================================
--- gdb-head.orig/gdb/m2-valprint.c
+++ gdb-head/gdb/m2-valprint.c
@@ -57,10 +57,10 @@ print_function_pointer_address (struct g
   if (addressprint && func_addr != address)
     {
       fputs_filtered ("@", stream);
-      fputs_filtered (paddress (address), stream);
+      fputs_filtered (paddress (gdbarch, address), stream);
       fputs_filtered (": ", stream);
     }
-  print_address_demangle (func_addr, stream, demangle);
+  print_address_demangle (gdbarch, func_addr, stream, demangle);
 }
 
 /* get_long_set_bounds - assigns the bounds of the long set to low and
@@ -225,7 +225,7 @@ print_unpacked_pointer (struct type *typ
     }
 
   if (options->addressprint && options->format != 's')
-    fputs_filtered (paddress (address), stream);
+    fputs_filtered (paddress (gdbarch, address), stream);
 
   /* For a pointer to char or unsigned char, also print the string
      pointed to, unless pointer is null.  */
@@ -247,11 +247,12 @@ print_variable_at_address (struct type *
 			   int recurse,
 			   const struct value_print_options *options)
 {
+  struct gdbarch *gdbarch = get_type_arch (type);
   CORE_ADDR addr = unpack_pointer (type, valaddr);
   struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
 
   fprintf_filtered (stream, "[");
-  fputs_filtered (paddress (addr), stream);
+  fputs_filtered (paddress (gdbarch, addr), stream);
   fprintf_filtered (stream, "] : ");
   
   if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
@@ -316,6 +317,7 @@ m2_val_print (struct type *type, const g
 	      CORE_ADDR address, struct ui_file *stream, int recurse,
 	      const struct value_print_options *options)
 {
+  struct gdbarch *gdbarch = get_type_arch (type);
   unsigned int i = 0;	/* Number of characters printed */
   unsigned len;
   struct type *elttype;
@@ -396,7 +398,7 @@ m2_val_print (struct type *type, const g
 	  CORE_ADDR addr
 	    = extract_typed_address (valaddr + embedded_offset, type);
 	  fprintf_filtered (stream, "@");
-	  fputs_filtered (paddress (addr), stream);
+	  fputs_filtered (paddress (gdbarch, addr), stream);
 	  if (options->deref_ref)
 	    fputs_filtered (": ", stream);
 	}
@@ -476,7 +478,7 @@ m2_val_print (struct type *type, const g
       type_print (type, "", stream, -1);
       fprintf_filtered (stream, "} ");
       /* Try to print what function it points to, and its address.  */
-      print_address_demangle (address, stream, demangle);
+      print_address_demangle (gdbarch, address, stream, demangle);
       break;
 
     case TYPE_CODE_BOOL:
Index: gdb-head/gdb/m32c-tdep.c
===================================================================
--- gdb-head.orig/gdb/m32c-tdep.c
+++ gdb-head/gdb/m32c-tdep.c
@@ -2421,7 +2421,7 @@ m32c_m16c_address_to_pointer (struct gdb
       if (! func_msym)
         error ("Cannot convert code address %s to function pointer:\n"
                "couldn't find a symbol at that address, to find trampoline.",
-               paddr_nz (addr));
+               paddress (gdbarch, addr));
 
       func_name = SYMBOL_LINKAGE_NAME (func_msym);
       tramp_name = xmalloc (strlen (func_name) + 5);
@@ -2438,7 +2438,7 @@ m32c_m16c_address_to_pointer (struct gdb
       if (! tramp_msym)
         error ("Cannot convert code address %s to function pointer:\n"
                "couldn't find trampoline named '%s.plt'.",
-               paddr_nz (addr), func_name);
+               paddress (gdbarch, addr), func_name);
 
       /* The trampoline's address is our pointer.  */
       addr = SYMBOL_VALUE_ADDRESS (tramp_msym);
Index: gdb-head/gdb/m32r-rom.c
===================================================================
--- gdb-head.orig/gdb/m32r-rom.c
+++ gdb-head/gdb/m32r-rom.c
@@ -78,6 +78,7 @@ m32r_load_section (bfd *abfd, asection *
   unsigned int *data_count = obj;
   if (s->flags & SEC_LOAD)
     {
+      int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
       bfd_size_type section_size = bfd_section_size (abfd, s);
       bfd_vma section_base = bfd_section_lma (abfd, s);
       unsigned int buffer, i;
@@ -87,10 +88,10 @@ m32r_load_section (bfd *abfd, asection *
       printf_filtered ("Loading section %s, size 0x%lx lma ",
 		       bfd_section_name (abfd, s),
 		       (unsigned long) section_size);
-      fputs_filtered (paddress (section_base), gdb_stdout);
+      fputs_filtered (paddress (target_gdbarch, section_base), gdb_stdout);
       printf_filtered ("\n");
       gdb_flush (gdb_stdout);
-      monitor_printf ("%s mw\r", paddr_nz (section_base));
+      monitor_printf ("%s mw\r", phex_nz (section_base, addr_size));
       for (i = 0; i < section_size; i += 4)
 	{
 	  QUIT;
@@ -146,7 +147,7 @@ m32r_load (char *filename, int from_tty)
 
 	printf_filtered ("Loading section %s, size 0x%lx vma ",
 			 bfd_section_name (abfd, s), section_size);
-	fputs_filtered (paddress (section_base), gdb_stdout);
+	fputs_filtered (paddress (target_gdbarch, section_base), gdb_stdout);
 	printf_filtered ("\n");
 	gdb_flush (gdb_stdout);
 	monitor_printf ("%x mw\r", section_base);
@@ -528,7 +529,8 @@ m32r_upload_command (char *args, int fro
 	    printf_filtered ("Loading section %s, size 0x%lx lma ",
 			     bfd_section_name (abfd, s),
 			     (unsigned long) section_size);
-	    fputs_filtered (paddress (section_base), gdb_stdout);
+	    fputs_filtered (paddress (target_gdbarch, section_base),
+			    gdb_stdout);
 	    printf_filtered ("\n");
 	    gdb_flush (gdb_stdout);
 	  }
Index: gdb-head/gdb/maint.c
===================================================================
--- gdb-head.orig/gdb/maint.c
+++ gdb-head/gdb/maint.c
@@ -306,11 +306,10 @@ print_bfd_flags (flagword flags)
 static void
 maint_print_section_info (const char *name, flagword flags, 
 			  CORE_ADDR addr, CORE_ADDR endaddr, 
-			  unsigned long filepos)
+			  unsigned long filepos, int addr_size)
 {
-  /* FIXME-32x64: Need paddress with field width.  */
-  printf_filtered ("    0x%s", paddr (addr));
-  printf_filtered ("->0x%s", paddr (endaddr));
+  printf_filtered ("    %s", hex_string_custom (addr, addr_size));
+  printf_filtered ("->%s", hex_string_custom (endaddr, addr_size));
   printf_filtered (" at %s",
 		   hex_string_custom ((unsigned long) filepos, 8));
   printf_filtered (": %s", name);
@@ -330,11 +329,14 @@ print_bfd_section_info (bfd *abfd, 
       || match_substring ((char *) arg, name)
       || match_bfd_flags ((char *) arg, flags))
     {
+      struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
+      int addr_size = gdbarch_addr_bit (gdbarch) / 8;
       CORE_ADDR addr, endaddr;
 
       addr = bfd_section_vma (abfd, asect);
       endaddr = addr + bfd_section_size (abfd, asect);
-      maint_print_section_info (name, flags, addr, endaddr, asect->filepos);
+      maint_print_section_info (name, flags, addr, endaddr,
+				asect->filepos, addr_size);
     }
 }
 
@@ -350,10 +352,13 @@ print_objfile_section_info (bfd *abfd, 
       || match_substring (string, name)
       || match_bfd_flags (string, flags))
     {
+      struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
+      int addr_size = gdbarch_addr_bit (gdbarch) / 8;
       maint_print_section_info (name, flags,
 				obj_section_addr (asect),
 				obj_section_endaddr (asect),
-				asect->the_bfd_section->filepos);
+				asect->the_bfd_section->filepos,
+				addr_size);
     }
 }
 
@@ -515,10 +520,10 @@ maintenance_translate_address (char *arg
 	printf_filtered (_("%s + %s\n"), symbol_name, symbol_offset);
     }
   else if (sect)
-    printf_filtered (_("no symbol at %s:0x%s\n"),
-		     sect->the_bfd_section->name, paddr (address));
+    printf_filtered (_("no symbol at %s:%s\n"),
+		     sect->the_bfd_section->name, hex_string (address));
   else
-    printf_filtered (_("no symbol at 0x%s\n"), paddr (address));
+    printf_filtered (_("no symbol at %s\n"), hex_string (address));
 
   return;
 }
Index: gdb-head/gdb/mi/mi-cmd-var.c
===================================================================
--- gdb-head.orig/gdb/mi/mi-cmd-var.c
+++ gdb-head/gdb/mi/mi-cmd-var.c
@@ -128,8 +128,8 @@ mi_cmd_var_create (char *command, char *
 
   if (varobjdebug)
     fprintf_unfiltered (gdb_stdlog,
-		    "Name=\"%s\", Frame=\"%s\" (0x%s), Expression=\"%s\"\n",
-			name, frame, paddr (frameaddr), expr);
+		    "Name=\"%s\", Frame=\"%s\" (%s), Expression=\"%s\"\n",
+			name, frame, hex_string (frameaddr), expr);
 
   var = varobj_create (name, expr, frameaddr, var_type);
 
Index: gdb-head/gdb/mips-tdep.c
===================================================================
--- gdb-head.orig/gdb/mips-tdep.c
+++ gdb-head/gdb/mips-tdep.c
@@ -2548,8 +2548,8 @@ heuristic_proc_start (struct gdbarch *gd
 	  {
 	    static int blurb_printed = 0;
 
-	    warning (_("GDB can't find the start of the function at 0x%s."),
-		     paddr_nz (pc));
+	    warning (_("GDB can't find the start of the function at %s."),
+		     paddress (gdbarch, pc));
 
 	    if (!blurb_printed)
 	      {
@@ -2560,16 +2560,17 @@ heuristic_proc_start (struct gdbarch *gd
 		   in that situation enough information to
 		   determine that it's no big deal.  */
 		printf_filtered ("\n\
-    GDB is unable to find the start of the function at 0x%s\n\
+    GDB is unable to find the start of the function at %s\n\
 and thus can't determine the size of that function's stack frame.\n\
 This means that GDB may be unable to access that stack frame, or\n\
 the frames below it.\n\
     This problem is most likely caused by an invalid program counter or\n\
 stack pointer.\n\
     However, if you think GDB should simply search farther back\n\
-from 0x%s for code which looks like the beginning of a\n\
+from %s for code which looks like the beginning of a\n\
 function, you can increase the range of the search using the `set\n\
-heuristic-fence-post' command.\n", paddr_nz (pc), paddr_nz (pc));
+heuristic-fence-post' command.\n",
+			paddress (gdbarch, pc), paddress (gdbarch, pc));
 		blurb_printed = 1;
 	      }
 	  }
@@ -2725,8 +2726,8 @@ mips_eabi_push_dummy_call (struct gdbarc
 
   if (mips_debug)
     fprintf_unfiltered (gdb_stdlog,
-			"mips_eabi_push_dummy_call: sp=0x%s allocated %ld\n",
-			paddr_nz (sp), (long) align_up (len, 16));
+			"mips_eabi_push_dummy_call: sp=%s allocated %ld\n",
+			paddress (gdbarch, sp), (long) align_up (len, 16));
 
   /* Initialize the integer and float register pointers.  */
   argreg = MIPS_A0_REGNUM;
@@ -2737,8 +2738,8 @@ mips_eabi_push_dummy_call (struct gdbarc
     {
       if (mips_debug)
 	fprintf_unfiltered (gdb_stdlog,
-			    "mips_eabi_push_dummy_call: struct_return reg=%d 0x%s\n",
-			    argreg, paddr_nz (struct_addr));
+			    "mips_eabi_push_dummy_call: struct_return reg=%d %s\n",
+			    argreg, paddress (gdbarch, struct_addr));
       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
     }
 
@@ -2887,10 +2888,10 @@ mips_eabi_push_dummy_call (struct gdbarc
 
 		  if (mips_debug)
 		    {
-		      fprintf_unfiltered (gdb_stdlog, " - stack_offset=0x%s",
-					  paddr_nz (stack_offset));
-		      fprintf_unfiltered (gdb_stdlog, " longword_offset=0x%s",
-					  paddr_nz (longword_offset));
+		      fprintf_unfiltered (gdb_stdlog, " - stack_offset=%s",
+					  paddress (gdbarch, stack_offset));
+		      fprintf_unfiltered (gdb_stdlog, " longword_offset=%s",
+					  paddress (gdbarch, longword_offset));
 		    }
 
 		  addr = sp + stack_offset + longword_offset;
@@ -2898,8 +2899,8 @@ mips_eabi_push_dummy_call (struct gdbarc
 		  if (mips_debug)
 		    {
 		      int i;
-		      fprintf_unfiltered (gdb_stdlog, " @0x%s ",
-					  paddr_nz (addr));
+		      fprintf_unfiltered (gdb_stdlog, " @%s ",
+					  paddress (gdbarch, addr));
 		      for (i = 0; i < partial_len; i++)
 			{
 			  fprintf_unfiltered (gdb_stdlog, "%02x",
@@ -3109,8 +3110,8 @@ mips_n32n64_push_dummy_call (struct gdba
 
   if (mips_debug)
     fprintf_unfiltered (gdb_stdlog,
-			"mips_n32n64_push_dummy_call: sp=0x%s allocated %ld\n",
-			paddr_nz (sp), (long) align_up (len, 16));
+			"mips_n32n64_push_dummy_call: sp=%s allocated %ld\n",
+			paddress (gdbarch, sp), (long) align_up (len, 16));
 
   /* Initialize the integer and float register pointers.  */
   argreg = MIPS_A0_REGNUM;
@@ -3121,8 +3122,8 @@ mips_n32n64_push_dummy_call (struct gdba
     {
       if (mips_debug)
 	fprintf_unfiltered (gdb_stdlog,
-			    "mips_n32n64_push_dummy_call: struct_return reg=%d 0x%s\n",
-			    argreg, paddr_nz (struct_addr));
+			    "mips_n32n64_push_dummy_call: struct_return reg=%d %s\n",
+			    argreg, paddress (gdbarch, struct_addr));
       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
     }
 
@@ -3234,10 +3235,10 @@ mips_n32n64_push_dummy_call (struct gdba
 
 		  if (mips_debug)
 		    {
-		      fprintf_unfiltered (gdb_stdlog, " - stack_offset=0x%s",
-					  paddr_nz (stack_offset));
-		      fprintf_unfiltered (gdb_stdlog, " longword_offset=0x%s",
-					  paddr_nz (longword_offset));
+		      fprintf_unfiltered (gdb_stdlog, " - stack_offset=%s",
+					  paddress (gdbarch, stack_offset));
+		      fprintf_unfiltered (gdb_stdlog, " longword_offset=%s",
+					  paddress (gdbarch, longword_offset));
 		    }
 
 		  addr = sp + stack_offset + longword_offset;
@@ -3245,8 +3246,8 @@ mips_n32n64_push_dummy_call (struct gdba
 		  if (mips_debug)
 		    {
 		      int i;
-		      fprintf_unfiltered (gdb_stdlog, " @0x%s ",
-					  paddr_nz (addr));
+		      fprintf_unfiltered (gdb_stdlog, " @%s ",
+					  paddress (gdbarch, addr));
 		      for (i = 0; i < partial_len; i++)
 			{
 			  fprintf_unfiltered (gdb_stdlog, "%02x",
@@ -3556,8 +3557,8 @@ mips_o32_push_dummy_call (struct gdbarch
 
   if (mips_debug)
     fprintf_unfiltered (gdb_stdlog,
-			"mips_o32_push_dummy_call: sp=0x%s allocated %ld\n",
-			paddr_nz (sp), (long) align_up (len, 16));
+			"mips_o32_push_dummy_call: sp=%s allocated %ld\n",
+			paddress (gdbarch, sp), (long) align_up (len, 16));
 
   /* Initialize the integer and float register pointers.  */
   argreg = MIPS_A0_REGNUM;
@@ -3568,8 +3569,8 @@ mips_o32_push_dummy_call (struct gdbarch
     {
       if (mips_debug)
 	fprintf_unfiltered (gdb_stdlog,
-			    "mips_o32_push_dummy_call: struct_return reg=%d 0x%s\n",
-			    argreg, paddr_nz (struct_addr));
+			    "mips_o32_push_dummy_call: struct_return reg=%d %s\n",
+			    argreg, paddress (gdbarch, struct_addr));
       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
       stack_offset += MIPS32_REGSIZE;
     }
@@ -3711,10 +3712,10 @@ mips_o32_push_dummy_call (struct gdbarch
 
 		  if (mips_debug)
 		    {
-		      fprintf_unfiltered (gdb_stdlog, " - stack_offset=0x%s",
-					  paddr_nz (stack_offset));
-		      fprintf_unfiltered (gdb_stdlog, " longword_offset=0x%s",
-					  paddr_nz (longword_offset));
+		      fprintf_unfiltered (gdb_stdlog, " - stack_offset=%s",
+					  paddress (gdbarch, stack_offset));
+		      fprintf_unfiltered (gdb_stdlog, " longword_offset=%s",
+					  paddress (gdbarch, longword_offset));
 		    }
 
 		  addr = sp + stack_offset + longword_offset;
@@ -3722,8 +3723,8 @@ mips_o32_push_dummy_call (struct gdbarch
 		  if (mips_debug)
 		    {
 		      int i;
-		      fprintf_unfiltered (gdb_stdlog, " @0x%s ",
-					  paddr_nz (addr));
+		      fprintf_unfiltered (gdb_stdlog, " @%s ",
+					  paddress (gdbarch, addr));
 		      for (i = 0; i < partial_len; i++)
 			{
 			  fprintf_unfiltered (gdb_stdlog, "%02x",
@@ -4013,8 +4014,8 @@ mips_o64_push_dummy_call (struct gdbarch
 
   if (mips_debug)
     fprintf_unfiltered (gdb_stdlog,
-			"mips_o64_push_dummy_call: sp=0x%s allocated %ld\n",
-			paddr_nz (sp), (long) align_up (len, 16));
+			"mips_o64_push_dummy_call: sp=%s allocated %ld\n",
+			paddress (gdbarch, sp), (long) align_up (len, 16));
 
   /* Initialize the integer and float register pointers.  */
   argreg = MIPS_A0_REGNUM;
@@ -4025,8 +4026,8 @@ mips_o64_push_dummy_call (struct gdbarch
     {
       if (mips_debug)
 	fprintf_unfiltered (gdb_stdlog,
-			    "mips_o64_push_dummy_call: struct_return reg=%d 0x%s\n",
-			    argreg, paddr_nz (struct_addr));
+			    "mips_o64_push_dummy_call: struct_return reg=%d %s\n",
+			    argreg, paddress (gdbarch, struct_addr));
       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
       stack_offset += MIPS64_REGSIZE;
     }
@@ -4116,10 +4117,10 @@ mips_o64_push_dummy_call (struct gdbarch
 
 		  if (mips_debug)
 		    {
-		      fprintf_unfiltered (gdb_stdlog, " - stack_offset=0x%s",
-					  paddr_nz (stack_offset));
-		      fprintf_unfiltered (gdb_stdlog, " longword_offset=0x%s",
-					  paddr_nz (longword_offset));
+		      fprintf_unfiltered (gdb_stdlog, " - stack_offset=%s",
+					  paddress (gdbarch, stack_offset));
+		      fprintf_unfiltered (gdb_stdlog, " longword_offset=%s",
+					  paddress (gdbarch, longword_offset));
 		    }
 
 		  addr = sp + stack_offset + longword_offset;
@@ -4127,8 +4128,8 @@ mips_o64_push_dummy_call (struct gdbarch
 		  if (mips_debug)
 		    {
 		      int i;
-		      fprintf_unfiltered (gdb_stdlog, " @0x%s ",
-					  paddr_nz (addr));
+		      fprintf_unfiltered (gdb_stdlog, " @%s ",
+					  paddress (gdbarch, addr));
 		      for (i = 0; i < partial_len; i++)
 			{
 			  fprintf_unfiltered (gdb_stdlog, "%02x",
Index: gdb-head/gdb/monitor.c
===================================================================
--- gdb-head.orig/gdb/monitor.c
+++ gdb-head/gdb/monitor.c
@@ -214,9 +214,13 @@ monitor_error (char *function, char *mes
   monitor_printable_string (safe_string, string, real_len);
 
   if (final_char)
-    error (_("%s (0x%s): %s: %s%c"), function, paddr_nz (memaddr), message, safe_string, final_char);
-  else
-    error (_("%s (0x%s): %s: %s"), function, paddr_nz (memaddr), message, safe_string);
+    error (_("%s (%s): %s: %s%c"),
+	   function, paddress (target_gdbarch, memaddr),
+	   message, safe_string, final_char);
+  else
+    error (_("%s (%s): %s: %s"),
+	   function, paddress (target_gdbarch, memaddr),
+	   message, safe_string);
 }
 
 /* Convert hex digit A to a number.  */
@@ -251,6 +255,7 @@ fromhex (int a)
 static void
 monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
 {
+  int addr_bit = gdbarch_addr_bit (target_gdbarch);
   char format[10];
   char fmt;
   char *p;
@@ -279,7 +284,7 @@ monitor_vsprintf (char *sndbuf, char *pa
 	      break;
 	    case 'A':
 	      arg_addr = va_arg (args, CORE_ADDR);
-	      strcpy (sndbuf, paddr_nz (arg_addr));
+	      strcpy (sndbuf, phex_nz (arg_addr, addr_bit / 8));
 	      break;
 	    case 's':
 	      arg_string = va_arg (args, char *);
@@ -1314,6 +1319,7 @@ monitor_fetch_registers (struct target_o
 static void
 monitor_store_register (struct regcache *regcache, int regno)
 {
+  int reg_size = register_size (get_regcache_arch (regcache), regno);
   const char *name;
   ULONGEST val;
   
@@ -1329,9 +1335,7 @@ monitor_store_register (struct regcache 
     }
 
   regcache_cooked_read_unsigned (regcache, regno, &val);
-  monitor_debug ("MON storeg %d %s\n", regno,
-		 phex (val,
-		       register_size (get_regcache_arch (regcache), regno)));
+  monitor_debug ("MON storeg %d %s\n", regno, phex (val, reg_size));
 
   /* send the register deposit command */
 
@@ -1347,14 +1351,14 @@ monitor_store_register (struct regcache 
       monitor_debug ("EXP setreg.resp_delim\n");
       monitor_expect_regexp (&setreg_resp_delim_pattern, NULL, 0);
       if (current_monitor->flags & MO_SETREG_INTERACTIVE)
-	monitor_printf ("%s\r", paddr_nz (val));
+	monitor_printf ("%s\r", phex_nz (val, reg_size));
     }
   if (current_monitor->setreg.term)
     {
       monitor_debug ("EXP setreg.term\n");
       monitor_expect (current_monitor->setreg.term, NULL, 0);
       if (current_monitor->flags & MO_SETREG_INTERACTIVE)
-	monitor_printf ("%s\r", paddr_nz (val));
+	monitor_printf ("%s\r", phex_nz (val, reg_size));
       monitor_expect_prompt (NULL, 0);
     }
   else
@@ -1409,7 +1413,7 @@ monitor_write_memory (CORE_ADDR memaddr,
   char *cmd;
   int i;
 
-  monitor_debug ("MON write %d %s\n", len, paddr (memaddr));
+  monitor_debug ("MON write %d %s\n", len, paddress (target_gdbarch, memaddr));
 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
     memaddr = gdbarch_addr_bits_remove (target_gdbarch, memaddr);
@@ -1808,7 +1812,7 @@ monitor_read_memory (CORE_ADDR memaddr, 
     }
 
   monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
-		 paddr_nz (memaddr), (long) myaddr, len);
+		 paddress (target_gdbarch, memaddr), (long) myaddr, len);
 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
     memaddr = gdbarch_addr_bits_remove (target_gdbarch, memaddr);
@@ -2034,7 +2038,7 @@ monitor_insert_breakpoint (struct gdbarc
   int i;
   int bplen;
 
-  monitor_debug ("MON inst bkpt %s\n", paddr (addr));
+  monitor_debug ("MON inst bkpt %s\n", paddress (gdbarch, addr));
   if (current_monitor->set_break == NULL)
     error (_("No set_break defined for this monitor"));
 
@@ -2069,7 +2073,7 @@ monitor_remove_breakpoint (struct gdbarc
   CORE_ADDR addr = bp_tgt->placed_address;
   int i;
 
-  monitor_debug ("MON rmbkpt %s\n", paddr (addr));
+  monitor_debug ("MON rmbkpt %s\n", paddress (gdbarch, addr));
   if (current_monitor->clr_break == NULL)
     error (_("No clr_break defined for this monitor"));
 
@@ -2090,8 +2094,8 @@ monitor_remove_breakpoint (struct gdbarc
 	}
     }
   fprintf_unfiltered (gdb_stderr,
-		      "Can't find breakpoint associated with 0x%s\n",
-		      paddr_nz (addr));
+		      "Can't find breakpoint associated with %s\n",
+		      paddress (gdbarch, addr));
   return 1;
 }
 
Index: gdb-head/gdb/printcmd.c
===================================================================
--- gdb-head.orig/gdb/printcmd.c
+++ gdb-head/gdb/printcmd.c
@@ -449,7 +449,7 @@ print_scalar_formatted (const void *vala
     case 'a':
       {
 	CORE_ADDR addr = unpack_pointer (type, valaddr);
-	print_address (addr, stream);
+	print_address (gdbarch, addr, stream);
       }
       break;
 
@@ -709,9 +709,10 @@ build_address_symbolic (CORE_ADDR addr, 
    <SYMBOL + OFFSET> after the number.  */
 
 void
-print_address (CORE_ADDR addr, struct ui_file *stream)
+print_address (struct gdbarch *gdbarch,
+	       CORE_ADDR addr, struct ui_file *stream)
 {
-  fputs_filtered (paddress (addr), stream);
+  fputs_filtered (paddress (gdbarch, addr), stream);
   print_address_symbolic (addr, stream, asm_demangle, " ");
 }
 
@@ -721,8 +722,8 @@ print_address (CORE_ADDR addr, struct ui
    or not.  */
 
 void
-print_address_demangle (CORE_ADDR addr, struct ui_file *stream,
-			int do_demangle)
+print_address_demangle (struct gdbarch *gdbarch, CORE_ADDR addr,
+			struct ui_file *stream, int do_demangle)
 {
   struct value_print_options opts;
   get_user_print_options (&opts);
@@ -732,7 +733,7 @@ print_address_demangle (CORE_ADDR addr, 
     }
   else if (opts.addressprint)
     {
-      fputs_filtered (paddress (addr), stream);
+      fputs_filtered (paddress (gdbarch, addr), stream);
       print_address_symbolic (addr, stream, do_demangle, " ");
     }
   else
@@ -807,7 +808,7 @@ do_examine (struct format_data fmt, stru
   while (count > 0)
     {
       QUIT;
-      print_address (next_address, gdb_stdout);
+      print_address (next_gdbarch, next_address, gdb_stdout);
       printf_filtered (":");
       for (i = maxelts;
 	   i > 0 && count > 0;
@@ -1140,20 +1141,21 @@ address_info (char *exp, int from_tty)
 
       if (msymbol != NULL)
 	{
+	  gdbarch = get_objfile_arch (msymbol_objfile (msymbol));
 	  load_addr = SYMBOL_VALUE_ADDRESS (msymbol);
 
 	  printf_filtered ("Symbol \"");
 	  fprintf_symbol_filtered (gdb_stdout, exp,
 				   current_language->la_language, DMGL_ANSI);
 	  printf_filtered ("\" is at ");
-	  fputs_filtered (paddress (load_addr), gdb_stdout);
+	  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
 	  printf_filtered (" in a file compiled without debugging");
 	  section = SYMBOL_OBJ_SECTION (msymbol);
 	  if (section_is_overlay (section))
 	    {
 	      load_addr = overlay_unmapped_address (load_addr, section);
 	      printf_filtered (",\n -- loaded at ");
-	      fputs_filtered (paddress (load_addr), gdb_stdout);
+	      fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
 	      printf_filtered (" in overlay section %s",
 			       section->the_bfd_section->name);
 	    }
@@ -1181,13 +1183,13 @@ address_info (char *exp, int from_tty)
 
     case LOC_LABEL:
       printf_filtered ("a label at address ");
-      fputs_filtered (paddress (load_addr = SYMBOL_VALUE_ADDRESS (sym)),
-		      gdb_stdout);
+      load_addr = SYMBOL_VALUE_ADDRESS (sym);
+      fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
       if (section_is_overlay (section))
 	{
 	  load_addr = overlay_unmapped_address (load_addr, section);
 	  printf_filtered (",\n -- loaded at ");
-	  fputs_filtered (paddress (load_addr), gdb_stdout);
+	  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
 	  printf_filtered (" in overlay section %s",
 			   section->the_bfd_section->name);
 	}
@@ -1221,13 +1223,13 @@ address_info (char *exp, int from_tty)
 
     case LOC_STATIC:
       printf_filtered (_("static storage at address "));
-     fputs_filtered (paddress (load_addr = SYMBOL_VALUE_ADDRESS (sym)),
-		     gdb_stdout);
+      load_addr = SYMBOL_VALUE_ADDRESS (sym);
+      fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
       if (section_is_overlay (section))
 	{
 	  load_addr = overlay_unmapped_address (load_addr, section);
 	  printf_filtered (_(",\n -- loaded at "));
-	  fputs_filtered (paddress (load_addr), gdb_stdout);
+	  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
 	  printf_filtered (_(" in overlay section %s"),
 			   section->the_bfd_section->name);
 	}
@@ -1259,12 +1261,12 @@ address_info (char *exp, int from_tty)
     case LOC_BLOCK:
       printf_filtered (_("a function at address "));
       load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
-      fputs_filtered (paddress (load_addr), gdb_stdout);
+      fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
       if (section_is_overlay (section))
 	{
 	  load_addr = overlay_unmapped_address (load_addr, section);
 	  printf_filtered (_(",\n -- loaded at "));
-	  fputs_filtered (paddress (load_addr), gdb_stdout);
+	  fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
 	  printf_filtered (_(" in overlay section %s"),
 			   section->the_bfd_section->name);
 	}
@@ -1286,16 +1288,17 @@ address_info (char *exp, int from_tty)
 		&& (section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
 	      printf_filtered (_("a thread-local variable at offset %s "
 				 "in the thread-local storage for `%s'"),
-			       paddr_nz (load_addr), section->objfile->name);
+			       paddress (gdbarch, load_addr),
+			       section->objfile->name);
 	    else
 	      {
 		printf_filtered (_("static storage at address "));
-		fputs_filtered (paddress (load_addr), gdb_stdout);
+		fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
 		if (section_is_overlay (section))
 		  {
 		    load_addr = overlay_unmapped_address (load_addr, section);
 		    printf_filtered (_(",\n -- loaded at "));
-		    fputs_filtered (paddress (load_addr), gdb_stdout);
+		    fputs_filtered (paddress (gdbarch, load_addr), gdb_stdout);
 		    printf_filtered (_(" in overlay section %s"),
 				     section->the_bfd_section->name);
 		  }
Index: gdb-head/gdb/p-valprint.c
===================================================================
--- gdb-head.orig/gdb/p-valprint.c
+++ gdb-head/gdb/p-valprint.c
@@ -56,6 +56,7 @@ pascal_val_print (struct type *type, con
 		  struct ui_file *stream, int recurse,
 		  const struct value_print_options *options)
 {
+  struct gdbarch *gdbarch = get_type_arch (type);
   unsigned int i = 0;	/* Number of characters printed */
   unsigned len;
   struct type *elttype;
@@ -142,7 +143,8 @@ pascal_val_print (struct type *type, con
 	  /* Print vtable entry - we only get here if we ARE using
 	     -fvtable_thunks.  (Otherwise, look under TYPE_CODE_STRUCT.) */
 	  /* Extract the address, assume that it is unsigned.  */
-	  print_address_demangle (extract_unsigned_integer (valaddr + embedded_offset, TYPE_LENGTH (type)),
+	  print_address_demangle (gdbarch,
+				  extract_unsigned_integer (valaddr + embedded_offset, TYPE_LENGTH (type)),
 				  stream, demangle);
 	  break;
 	}
@@ -155,14 +157,14 @@ pascal_val_print (struct type *type, con
 	  if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
 	    {
 	      /* Try to print what function it points to.  */
-	      print_address_demangle (addr, stream, demangle);
+	      print_address_demangle (gdbarch, addr, stream, demangle);
 	      /* Return value is irrelevant except for string pointers.  */
 	      return (0);
 	    }
 
 	  if (options->addressprint && options->format != 's')
 	    {
-	      fputs_filtered (paddress (addr), stream);
+	      fputs_filtered (paddress (gdbarch, addr), stream);
 	    }
 
 	  /* For a pointer to char or unsigned char, also print the string
@@ -254,7 +256,7 @@ pascal_val_print (struct type *type, con
 	  CORE_ADDR addr
 	    = extract_typed_address (valaddr + embedded_offset, type);
 	  fprintf_filtered (stream, "@");
-	  fputs_filtered (paddress (addr), stream);
+          fputs_filtered (paddress (gdbarch, addr), stream);
 	  if (options->deref_ref)
 	    fputs_filtered (": ", stream);
 	}
@@ -290,7 +292,8 @@ pascal_val_print (struct type *type, con
 	     -fvtable_thunks.  (Otherwise, look under TYPE_CODE_PTR.) */
 	  /* Extract the address, assume that it is unsigned.  */
 	  print_address_demangle
-	    (extract_unsigned_integer (valaddr + embedded_offset + TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8,
+	    (gdbarch,
+	     extract_unsigned_integer (valaddr + embedded_offset + TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8,
 				       TYPE_LENGTH (TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET))),
 	     stream, demangle);
 	}
@@ -356,7 +359,7 @@ pascal_val_print (struct type *type, con
       type_print (type, "", stream, -1);
       fprintf_filtered (stream, "} ");
       /* Try to print what function it points to, and its address.  */
-      print_address_demangle (address, stream, demangle);
+      print_address_demangle (gdbarch, address, stream, demangle);
       break;
 
     case TYPE_CODE_BOOL:
Index: gdb-head/gdb/remote.c
===================================================================
--- gdb-head.orig/gdb/remote.c
+++ gdb-head/gdb/remote.c
@@ -2877,6 +2877,7 @@ remote_check_symbols (struct objfile *ob
 	xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
       else
 	{
+	  int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
 	  CORE_ADDR sym_addr = SYMBOL_VALUE_ADDRESS (sym);
 
 	  /* If this is a function address, return the start of code
@@ -2886,7 +2887,7 @@ remote_check_symbols (struct objfile *ob
 							 &current_target);
 
 	  xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
-		     paddr_nz (sym_addr), &reply[8]);
+		     phex_nz (sym_addr, addr_size), &reply[8]);
 	}
   
       putpkt (msg);
@@ -5818,6 +5819,7 @@ static void
 remote_flash_erase (struct target_ops *ops,
                     ULONGEST address, LONGEST length)
 {
+  int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
   int saved_remote_timeout = remote_timeout;
   enum packet_result ret;
 
@@ -5826,7 +5828,7 @@ remote_flash_erase (struct target_ops *o
   remote_timeout = remote_flash_timeout;
 
   ret = remote_send_printf ("vFlashErase:%s,%s",
-			    paddr (address),
+			    phex (address, addr_size),
 			    phex (length, 4));
   switch (ret)
     {
@@ -7169,16 +7171,18 @@ compare_sections_command (char *args, in
 
       getpkt (&rs->buf, &rs->buf_size, 0);
       if (rs->buf[0] == 'E')
-	error (_("target memory fault, section %s, range 0x%s -- 0x%s"),
-	       sectname, paddr (lma), paddr (lma + size));
+	error (_("target memory fault, section %s, range %s -- %s"), sectname,
+	       paddress (target_gdbarch, lma),
+	       paddress (target_gdbarch, lma + size));
       if (rs->buf[0] != 'C')
 	error (_("remote target does not support this operation"));
 
       for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
 	target_crc = target_crc * 16 + fromhex (*tmp);
 
-      printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
-		       sectname, paddr (lma), paddr (lma + size));
+      printf_filtered ("Section %s, range %s -- %s: ", sectname,
+		       paddress (target_gdbarch, lma),
+		       paddress (target_gdbarch, lma + size));
       if (host_crc == target_crc)
 	printf_filtered ("matched.\n");
       else
@@ -7498,6 +7502,7 @@ remote_search_memory (struct target_ops*
 		      const gdb_byte *pattern, ULONGEST pattern_len,
 		      CORE_ADDR *found_addrp)
 {
+  int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
   struct remote_state *rs = get_remote_state ();
   int max_size = get_memory_write_packet_size ();
   struct packet_config *packet =
@@ -7536,7 +7541,7 @@ remote_search_memory (struct target_ops*
   /* Insert header.  */
   i = snprintf (rs->buf, max_size, 
 		"qSearch:memory:%s;%s;",
-		paddr_nz (start_addr),
+		phex_nz (start_addr, addr_size),
 		phex_nz (search_space_len, sizeof (search_space_len)));
   max_size -= (i + 1);
 
Index: gdb-head/gdb/remote-m32r-sdi.c
===================================================================
--- gdb-head.orig/gdb/remote-m32r-sdi.c
+++ gdb-head/gdb/remote-m32r-sdi.c
@@ -1050,10 +1050,10 @@ m32r_xfer_memory (CORE_ADDR memaddr, gdb
     {
       if (write)
 	fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,write)\n",
-			    paddr (memaddr), len);
+			    paddress (target_gdbarch, memaddr), len);
       else
 	fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,read)\n",
-			    paddr (memaddr), len);
+			    paddress (target_gdbarch, memaddr), len);
     }
 
   if (write)
@@ -1150,7 +1150,7 @@ m32r_insert_breakpoint (struct gdbarch *
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_insert_breakpoint(%s,...)\n",
-			paddr (addr));
+			paddress (gdbarch, addr));
 
   if (use_ib_breakpoints)
     ib_breakpoints = max_ib_breakpoints;
@@ -1192,7 +1192,7 @@ m32r_remove_breakpoint (struct gdbarch *
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_remove_breakpoint(%s)\n",
-			paddr (addr));
+			paddress (gdbarch, addr));
 
   for (i = 0; i < MAX_BREAKPOINTS; i++)
     {
@@ -1419,7 +1419,7 @@ m32r_insert_watchpoint (CORE_ADDR addr, 
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_insert_watchpoint(%s,%d,%d)\n",
-			paddr (addr), len, type);
+			paddress (target_gdbarch, addr), len, type);
 
   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
     {
@@ -1443,7 +1443,7 @@ m32r_remove_watchpoint (CORE_ADDR addr, 
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_remove_watchpoint(%s,%d,%d)\n",
-			paddr (addr), len, type);
+			paddress (target_gdbarch, addr), len, type);
 
   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
     {
Index: gdb-head/gdb/remote-mips.c
===================================================================
--- gdb-head.orig/gdb/remote-mips.c
+++ gdb-head/gdb/remote-mips.c
@@ -1187,6 +1187,7 @@ mips_request (int cmd,
 	      int timeout,
 	      char *buff)
 {
+  int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
   char myBuff[DATA_MAXLEN + 1];
   int len;
   int rpid;
@@ -1202,7 +1203,8 @@ mips_request (int cmd,
       if (mips_need_reply)
 	internal_error (__FILE__, __LINE__,
 			_("mips_request: Trying to send command before reply"));
-      sprintf (buff, "0x0 %c 0x%s 0x%s", cmd, paddr_nz (addr), paddr_nz (data));
+      sprintf (buff, "0x0 %c 0x%s 0x%s", cmd,
+	       phex_nz (addr, addr_size), phex_nz (data, addr_size));
       mips_send_packet (buff, 1);
       mips_need_reply = 1;
     }
@@ -1993,8 +1995,8 @@ mips_fetch_word (CORE_ADDR addr)
       val = mips_request ('i', addr, 0, &err,
 			  mips_receive_wait, NULL);
       if (err)
-	mips_error ("Can't read address 0x%s: %s",
-		    paddr_nz (addr), safe_strerror (errno));
+	mips_error ("Can't read address %s: %s",
+		    paddress (target_gdbarch, addr), safe_strerror (errno));
     }
   return val;
 }
@@ -2341,7 +2343,7 @@ static int
 mips_check_lsi_error (CORE_ADDR addr, int rerrflg)
 {
   struct lsi_error *err;
-  char *saddr = paddr_nz (addr);	/* printable address string */
+  char *saddr = paddress (target_gdbarch, addr);
 
   if (rerrflg == 0)		/* no error */
     return 0;
@@ -2358,14 +2360,14 @@ mips_check_lsi_error (CORE_ADDR addr, in
 		{
 		  found = 1;
 		  fprintf_unfiltered (gdb_stderr, "\
-mips_common_breakpoint (0x%s): Warning: %s\n",
+mips_common_breakpoint (%s): Warning: %s\n",
 				      saddr,
 				      err->string);
 		}
 	    }
 	  if (!found)
 	    fprintf_unfiltered (gdb_stderr, "\
-mips_common_breakpoint (0x%s): Unknown warning: 0x%x\n",
+mips_common_breakpoint (%s): Unknown warning: 0x%x\n",
 				saddr,
 				rerrflg);
 	}
@@ -2378,14 +2380,14 @@ mips_common_breakpoint (0x%s): Unknown w
       if ((err->code & rerrflg) == err->code)
 	{
 	  fprintf_unfiltered (gdb_stderr, "\
-mips_common_breakpoint (0x%s): Error: %s\n",
+mips_common_breakpoint (%s): Error: %s\n",
 			      saddr,
 			      err->string);
 	  return 1;
 	}
     }
   fprintf_unfiltered (gdb_stderr, "\
-mips_common_breakpoint (0x%s): Unknown error: 0x%x\n",
+mips_common_breakpoint (%s): Unknown error: 0x%x\n",
 		      saddr,
 		      rerrflg);
   return 1;
@@ -2408,6 +2410,7 @@ mips_common_breakpoint (0x%s): Unknown e
 static int
 mips_common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
 {
+  int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
   char buf[DATA_MAXLEN + 1];
   char cmd, rcmd;
   int rpid, rerrflg, rresponse, rlen;
@@ -2441,7 +2444,7 @@ mips_common_breakpoint (int set, CORE_AD
 	    {
 	      warning ("\
 mips_common_breakpoint: Attempt to clear bogus breakpoint at %s\n",
-		       paddr_nz (addr));
+		       paddress (target_gdbarch, addr));
 	      return 1;
 	    }
 
@@ -2490,15 +2493,16 @@ mips_common_breakpoint: Bad response fro
 	  if (type == BREAK_FETCH)	/* instruction breakpoint */
 	    {
 	      cmd = 'B';
-	      sprintf (buf, "0x0 B 0x%s 0x0", paddr_nz (addr));
+	      sprintf (buf, "0x0 B 0x%s 0x0", phex_nz (addr, addr_size));
 	    }
 	  else
 	    /* watchpoint */
 	    {
 	      cmd = 'A';
-	      sprintf (buf, "0x0 A 0x%s 0x%x 0x%s", paddr_nz (addr),
-		     type == BREAK_READ ? 1 : (type == BREAK_WRITE ? 2 : 3),
-		       paddr_nz (addr + len - 1));
+	      sprintf (buf, "0x0 A 0x%s 0x%x 0x%s",
+		       phex_nz (addr, addr_size),
+		       type == BREAK_READ ? 1 : (type == BREAK_WRITE ? 2 : 3),
+		       phex_nz (addr + len - 1, addr_size));
 	    }
 	  mips_send_packet (buf, 1);
 
@@ -2559,13 +2563,13 @@ mips_common_breakpoint: Bad response fro
 	    }
 
 	  cmd = 'B';
-	  sprintf (buf, "0x0 B 0x%s 0x%s %s", paddr_nz (addr),
-		   paddr_nz (mask), flags);
+	  sprintf (buf, "0x0 B 0x%s 0x%s %s", phex_nz (addr, addr_size),
+		   phex_nz (mask, addr_size), flags);
 	}
       else
 	{
 	  cmd = 'b';
-	  sprintf (buf, "0x0 b 0x%s", paddr_nz (addr));
+	  sprintf (buf, "0x0 b 0x%s", phex_nz (addr, addr_size));
 	}
 
       mips_send_packet (buf, 1);
@@ -2589,8 +2593,8 @@ mips_common_breakpoint: Bad response fro
 	    rresponse = rerrflg;
 	  if (rresponse != 22)	/* invalid argument */
 	    fprintf_unfiltered (gdb_stderr, "\
-mips_common_breakpoint (0x%s):  Got error: 0x%x\n",
-				paddr_nz (addr), rresponse);
+mips_common_breakpoint (%s):  Got error: 0x%x\n",
+				paddress (target_gdbarch, addr), rresponse);
 	  return 1;
 	}
     }
@@ -2616,7 +2620,8 @@ send_srec (char *srec, int len, CORE_ADD
 	case 0x6:		/* ACK */
 	  return;
 	case 0x15:		/* NACK */
-	  fprintf_unfiltered (gdb_stderr, "Download got a NACK at byte 0x%s!  Retrying.\n", paddr_nz (addr));
+	  fprintf_unfiltered (gdb_stderr, "Download got a NACK at byte %s!  Retrying.\n",
+			      paddress (target_gdbarch, addr));
 	  continue;
 	default:
 	  error ("Download got unexpected ack char: 0x%x, retrying.\n", ch);
Index: gdb-head/gdb/remote-sim.c
===================================================================
--- gdb-head.orig/gdb/remote-sim.c
+++ gdb-head/gdb/remote-sim.c
@@ -771,8 +771,8 @@ gdbsim_xfer_inferior_memory (CORE_ADDR m
       /* FIXME: Send to something other than STDOUT? */
       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
       gdb_print_host_address (myaddr, gdb_stdout);
-      printf_filtered (", memaddr 0x%s, len %d, write %d\n",
-		       paddr_nz (memaddr), len, write);
+      printf_filtered (", memaddr %s, len %d, write %d\n",
+		       paddress (target_gdbarch, memaddr), len, write);
       if (remote_debug && write)
 	dump_mem (myaddr, len);
     }
Index: gdb-head/gdb/rs6000-tdep.c
===================================================================
--- gdb-head.orig/gdb/rs6000-tdep.c
+++ gdb-head/gdb/rs6000-tdep.c
@@ -983,8 +983,8 @@ ppc_displaced_step_fixup (struct gdbarch
 
   if (debug_displaced)
     fprintf_unfiltered (gdb_stdlog,
-			"displaced: (ppc) fixup (0x%s, 0x%s)\n",
-			paddr_nz (from), paddr_nz (to));
+			"displaced: (ppc) fixup (%s, %s)\n",
+			paddress (gdbarch, from), paddress (gdbarch, to));
 
 
   /* Handle PC-relative branch instructions.  */
@@ -1009,10 +1009,10 @@ ppc_displaced_step_fixup (struct gdbarch
 	      if (debug_displaced)
 		fprintf_unfiltered
 		  (gdb_stdlog,
-		   "displaced: (ppc) branch instruction: 0x%s\n"
-		   "displaced: (ppc) adjusted PC from 0x%s to 0x%s\n",
-		   paddr_nz (insn), paddr_nz (current_pc),
-		   paddr_nz (from + offset));
+		   "displaced: (ppc) branch instruction: %s\n"
+		   "displaced: (ppc) adjusted PC from %s to %s\n",
+		   paddress (gdbarch, insn), paddress (gdbarch, current_pc),
+		   paddress (gdbarch, from + offset));
 
 	      regcache_cooked_write_unsigned (regs, gdbarch_pc_regnum (gdbarch),
 					      from + offset);
@@ -1040,8 +1040,8 @@ ppc_displaced_step_fixup (struct gdbarch
 					  from + PPC_INSN_SIZE);
 	  if (debug_displaced)
 		fprintf_unfiltered (gdb_stdlog,
-				    "displaced: (ppc) adjusted LR to 0x%s\n",
-				    paddr_nz (from + PPC_INSN_SIZE));
+				    "displaced: (ppc) adjusted LR to %s\n",
+				    paddress (gdbarch, from + PPC_INSN_SIZE));
 
 	}
     }
Index: gdb-head/gdb/scm-valprint.c
===================================================================
--- gdb-head.orig/gdb/scm-valprint.c
+++ gdb-head/gdb/scm-valprint.c
@@ -170,7 +170,7 @@ scm_ipruk (char *hdr, struct type *type,
   if (SCM_CELLP (ptr))
     fprintf_filtered (stream, " (0x%lx . 0x%lx) @",
 		      (long) SCM_CAR (ptr), (long) SCM_CDR (ptr));
-  fprintf_filtered (stream, " 0x%s>", paddr_nz (ptr));
+  fprintf_filtered (stream, " 0x%s>", phex_nz (ptr, SCM_SIZE));
 #undef SCM_SIZE
 }
 
@@ -245,7 +245,7 @@ taloop:
 			     (sizet) LENGTH (name),
 			   port);
 #endif
-	      fprintf_filtered (stream, " #X%s>", paddr_nz (svalue));
+	      fprintf_filtered (stream, " #X%s>", phex_nz (svalue, SCM_SIZE));
 	      break;
 	    }
 	case scm_tcs_cons_imcar:
Index: gdb-head/gdb/sh64-tdep.c
===================================================================
--- gdb-head.orig/gdb/sh64-tdep.c
+++ gdb-head/gdb/sh64-tdep.c
@@ -1316,8 +1316,8 @@ sh64_show_media_regs (struct frame_info 
 
   printf_filtered
     ("PC=%s SR=%016llx \n",
-     paddr (get_frame_register_unsigned (frame,
-					 gdbarch_pc_regnum (gdbarch))),
+     phex (get_frame_register_unsigned (frame,
+					gdbarch_pc_regnum (gdbarch)), 8),
      (long long) get_frame_register_unsigned (frame, SR_REGNUM));
 
   printf_filtered
@@ -1369,7 +1369,7 @@ sh64_show_compact_regs (struct frame_inf
 
   printf_filtered
     ("PC=%s \n",
-     paddr (get_frame_register_unsigned (frame, PC_C_REGNUM)));
+     phex (get_frame_register_unsigned (frame, PC_C_REGNUM), 8));
 
   printf_filtered
     ("GBR=%08lx MACH=%08lx MACL=%08lx PR=%08lx T=%08lx\n",
Index: gdb-head/gdb/sh-tdep.c
===================================================================
--- gdb-head.orig/gdb/sh-tdep.c
+++ gdb-head/gdb/sh-tdep.c
@@ -1418,9 +1418,9 @@ sh_generic_show_regs (struct frame_info 
 {
   printf_filtered
     ("      PC %s       SR %08lx       PR %08lx     MACH %08lx\n",
-     paddr (get_frame_register_unsigned (frame,
-					 gdbarch_pc_regnum
-					   (get_frame_arch (frame)))),
+     phex (get_frame_register_unsigned (frame,
+					gdbarch_pc_regnum
+					   (get_frame_arch (frame))), 4),
      (long) get_frame_register_unsigned (frame, SR_REGNUM),
      (long) get_frame_register_unsigned (frame, PR_REGNUM),
      (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@@ -1458,9 +1458,9 @@ sh3_show_regs (struct frame_info *frame)
 {
   printf_filtered
     ("      PC %s       SR %08lx       PR %08lx     MACH %08lx\n",
-     paddr (get_frame_register_unsigned (frame,
-					 gdbarch_pc_regnum
-					   (get_frame_arch (frame)))),
+     phex (get_frame_register_unsigned (frame,
+					gdbarch_pc_regnum
+					  (get_frame_arch (frame))), 4),
      (long) get_frame_register_unsigned (frame, SR_REGNUM),
      (long) get_frame_register_unsigned (frame, PR_REGNUM),
      (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@@ -1503,8 +1503,8 @@ sh2e_show_regs (struct frame_info *frame
   struct gdbarch *gdbarch = get_frame_arch (frame);
   printf_filtered
     ("      PC %s       SR %08lx       PR %08lx     MACH %08lx\n",
-     paddr (get_frame_register_unsigned (frame,
-					 gdbarch_pc_regnum (gdbarch))),
+     phex (get_frame_register_unsigned (frame,
+					gdbarch_pc_regnum (gdbarch)), 4),
      (long) get_frame_register_unsigned (frame, SR_REGNUM),
      (long) get_frame_register_unsigned (frame, PR_REGNUM),
      (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@@ -1588,8 +1588,8 @@ sh2a_show_regs (struct frame_info *frame
 
   printf_filtered
     ("      PC %s       SR %08lx       PR %08lx     MACH %08lx\n",
-     paddr (get_frame_register_unsigned (frame,
-					 gdbarch_pc_regnum (gdbarch))),
+     phex (get_frame_register_unsigned (frame,
+					gdbarch_pc_regnum (gdbarch)), 4),
      (long) get_frame_register_unsigned (frame, SR_REGNUM),
      (long) get_frame_register_unsigned (frame, PR_REGNUM),
      (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@@ -1703,9 +1703,9 @@ sh2a_nofpu_show_regs (struct frame_info 
 
   printf_filtered
     ("      PC %s       SR %08lx       PR %08lx     MACH %08lx\n",
-     paddr (get_frame_register_unsigned (frame,
-					 gdbarch_pc_regnum
-					   (get_frame_arch (frame)))),
+     phex (get_frame_register_unsigned (frame,
+					gdbarch_pc_regnum
+					  (get_frame_arch (frame))), 4),
      (long) get_frame_register_unsigned (frame, SR_REGNUM),
      (long) get_frame_register_unsigned (frame, PR_REGNUM),
      (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@@ -1780,8 +1780,8 @@ sh3e_show_regs (struct frame_info *frame
   struct gdbarch *gdbarch = get_frame_arch (frame);
   printf_filtered
     ("      PC %s       SR %08lx       PR %08lx     MACH %08lx\n",
-     paddr (get_frame_register_unsigned (frame,
-					 gdbarch_pc_regnum (gdbarch))),
+     phex (get_frame_register_unsigned (frame,
+					gdbarch_pc_regnum (gdbarch)), 4),
      (long) get_frame_register_unsigned (frame, SR_REGNUM),
      (long) get_frame_register_unsigned (frame, PR_REGNUM),
      (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@@ -1862,9 +1862,9 @@ sh3_dsp_show_regs (struct frame_info *fr
 {
   printf_filtered
     ("      PC %s       SR %08lx       PR %08lx     MACH %08lx\n",
-     paddr (get_frame_register_unsigned (frame,
-					 gdbarch_pc_regnum
-					   (get_frame_arch (frame)))),
+     phex (get_frame_register_unsigned (frame,
+					gdbarch_pc_regnum
+					  (get_frame_arch (frame))), 4),
      (long) get_frame_register_unsigned (frame, SR_REGNUM),
      (long) get_frame_register_unsigned (frame, PR_REGNUM),
      (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@@ -1929,8 +1929,8 @@ sh4_show_regs (struct frame_info *frame)
 
   printf_filtered
     ("      PC %s       SR %08lx       PR %08lx     MACH %08lx\n",
-     paddr (get_frame_register_unsigned (frame,
-					 gdbarch_pc_regnum (gdbarch))),
+     phex (get_frame_register_unsigned (frame,
+					gdbarch_pc_regnum (gdbarch)), 4),
      (long) get_frame_register_unsigned (frame, SR_REGNUM),
      (long) get_frame_register_unsigned (frame, PR_REGNUM),
      (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@@ -2013,9 +2013,9 @@ sh4_nofpu_show_regs (struct frame_info *
 {
   printf_filtered
     ("      PC %s       SR %08lx       PR %08lx     MACH %08lx\n",
-     paddr (get_frame_register_unsigned (frame,
-					 gdbarch_pc_regnum
-					   (get_frame_arch (frame)))),
+     phex (get_frame_register_unsigned (frame,
+					gdbarch_pc_regnum
+					  (get_frame_arch (frame))), 4),
      (long) get_frame_register_unsigned (frame, SR_REGNUM),
      (long) get_frame_register_unsigned (frame, PR_REGNUM),
      (long) get_frame_register_unsigned (frame, MACH_REGNUM));
@@ -2059,9 +2059,9 @@ sh_dsp_show_regs (struct frame_info *fra
 {
   printf_filtered
     ("      PC %s       SR %08lx       PR %08lx     MACH %08lx\n",
-     paddr (get_frame_register_unsigned (frame,
-					 gdbarch_pc_regnum
-					   (get_frame_arch (frame)))),
+     phex (get_frame_register_unsigned (frame,
+					gdbarch_pc_regnum
+					  (get_frame_arch (frame))), 4),
      (long) get_frame_register_unsigned (frame, SR_REGNUM),
      (long) get_frame_register_unsigned (frame, PR_REGNUM),
      (long) get_frame_register_unsigned (frame, MACH_REGNUM));
Index: gdb-head/gdb/solib-som.c
===================================================================
--- gdb-head.orig/gdb/solib-som.c
+++ gdb-head/gdb/solib-som.c
@@ -639,28 +639,28 @@ som_current_sos (void)
 	    lmi->tsd_start_addr = extract_unsigned_integer (tsdbuf, 4);
 
 #ifdef SOLIB_SOM_DBG
-	    printf ("\n+ library \"%s\" is described at 0x%s\n", new->so_name, 
-	    	    paddr_nz (lm));
+	    printf ("\n+ library \"%s\" is described at %s\n", new->so_name,
+	    	    paddress (target_gdbarch, lm));
 	    printf ("  'version' is %d\n", new->lm_info->struct_version);
 	    printf ("  'bind_mode' is %d\n", new->lm_info->bind_mode);
 	    printf ("  'library_version' is %d\n", 
 	    	    new->lm_info->library_version);
-	    printf ("  'text_addr' is 0x%s\n", 
-	    	    paddr_nz (new->lm_info->text_addr));
-	    printf ("  'text_link_addr' is 0x%s\n", 
-	    	    paddr_nz (new->lm_info->text_link_addr));
-	    printf ("  'text_end' is 0x%s\n", 
-	    	    paddr_nz (new->lm_info->text_end));
-	    printf ("  'data_start' is 0x%s\n", 
-	    	    paddr_nz (new->lm_info->data_start));
-	    printf ("  'bss_start' is 0x%s\n", 
-	    	    paddr_nz (new->lm_info->bss_start));
-	    printf ("  'data_end' is 0x%s\n", 
-	    	    paddr_nz (new->lm_info->data_end));
-	    printf ("  'got_value' is %s\n", 
-	    	    paddr_nz (new->lm_info->got_value));
-	    printf ("  'tsd_start_addr' is 0x%s\n", 
-	    	    paddr_nz (new->lm_info->tsd_start_addr));
+	    printf ("  'text_addr' is %s\n",
+	    	    paddress (target_gdbarch, new->lm_info->text_addr));
+	    printf ("  'text_link_addr' is %s\n",
+	    	    paddress (target_gdbarch, new->lm_info->text_link_addr));
+	    printf ("  'text_end' is %s\n",
+	    	    paddress (target_gdbarch, new->lm_info->text_end));
+	    printf ("  'data_start' is %s\n",
+	    	    paddress (target_gdbarch, new->lm_info->data_start));
+	    printf ("  'bss_start' is %s\n",
+	    	    paddress (target_gdbarch, new->lm_info->bss_start));
+	    printf ("  'data_end' is %s\n",
+	    	    paddress (target_gdbarch, new->lm_info->data_end));
+	    printf ("  'got_value' is %s\n",
+	    	    paddress (target_gdbarch, new->lm_info->got_value));
+	    printf ("  'tsd_start_addr' is %s\n",
+	    	    paddress (target_gdbarch, new->lm_info->tsd_start_addr));
 #endif
 
 	    new->addr_low = lmi->text_addr;
Index: gdb-head/gdb/sol-thread.c
===================================================================
--- gdb-head.orig/gdb/sol-thread.c
+++ gdb-head/gdb/sol-thread.c
@@ -1250,7 +1250,8 @@ info_cb (const td_thrhandle_t *th, void 
 	    printf_filtered ("   startfunc: %s\n",
 			     SYMBOL_PRINT_NAME (msym));
 	  else
-	    printf_filtered ("   startfunc: 0x%s\n", paddr (ti.ti_startfunc));
+	    printf_filtered ("   startfunc: %s\n",
+			     paddress (target_gdbarch, ti.ti_startfunc));
 	}
 
       /* If thread is asleep, print function that went to sleep.  */
@@ -1262,7 +1263,8 @@ info_cb (const td_thrhandle_t *th, void 
 	    printf_filtered (" - Sleep func: %s\n",
 			     SYMBOL_PRINT_NAME (msym));
 	  else
-	    printf_filtered (" - Sleep func: 0x%s\n", paddr (ti.ti_startfunc));
+	    printf_filtered (" - Sleep func: %s\n",
+			     paddress (target_gdbarch, ti.ti_startfunc));
 	}
 
       /* Wrap up line, if necessary.  */
Index: gdb-head/gdb/source.c
===================================================================
--- gdb-head.orig/gdb/source.c
+++ gdb-head/gdb/source.c
@@ -19,6 +19,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
+#include "arch-utils.h"
 #include "symtab.h"
 #include "expression.h"
 #include "language.h"
@@ -1295,7 +1296,7 @@ identify_source_line (struct symtab *s, 
     /* Don't index off the end of the line_charpos array.  */
     return 0;
   annotate_source (s->fullname, line, s->line_charpos[line - 1],
-		   mid_statement, pc);
+		   mid_statement, get_objfile_arch (s->objfile), pc);
 
   current_source_line = line;
   first_line_listed = line;
@@ -1474,6 +1475,8 @@ line_info (char *arg, int from_tty)
 
       if (sal.symtab == 0)
 	{
+	  struct gdbarch *gdbarch = get_current_arch ();
+
 	  printf_filtered (_("No line number information available"));
 	  if (sal.pc != 0)
 	    {
@@ -1482,7 +1485,7 @@ line_info (char *arg, int from_tty)
 	         address.  */
 	      printf_filtered (" for address ");
 	      wrap_here ("  ");
-	      print_address (sal.pc, gdb_stdout);
+	      print_address (gdbarch, sal.pc, gdb_stdout);
 	    }
 	  else
 	    printf_filtered (".");
@@ -1491,13 +1494,15 @@ line_info (char *arg, int from_tty)
       else if (sal.line > 0
 	       && find_line_pc_range (sal, &start_pc, &end_pc))
 	{
+	  struct gdbarch *gdbarch = get_objfile_arch (sal.symtab->objfile);
+
 	  if (start_pc == end_pc)
 	    {
 	      printf_filtered ("Line %d of \"%s\"",
 			       sal.line, sal.symtab->filename);
 	      wrap_here ("  ");
 	      printf_filtered (" is at address ");
-	      print_address (start_pc, gdb_stdout);
+	      print_address (gdbarch, start_pc, gdb_stdout);
 	      wrap_here ("  ");
 	      printf_filtered (" but contains no code.\n");
 	    }
@@ -1507,15 +1512,15 @@ line_info (char *arg, int from_tty)
 			       sal.line, sal.symtab->filename);
 	      wrap_here ("  ");
 	      printf_filtered (" starts at address ");
-	      print_address (start_pc, gdb_stdout);
+	      print_address (gdbarch, start_pc, gdb_stdout);
 	      wrap_here ("  ");
 	      printf_filtered (" and ends at ");
-	      print_address (end_pc, gdb_stdout);
+	      print_address (gdbarch, end_pc, gdb_stdout);
 	      printf_filtered (".\n");
 	    }
 
 	  /* x/i should display this line's code.  */
-	  set_next_address (get_objfile_arch (sal.symtab->objfile), start_pc);
+	  set_next_address (gdbarch, start_pc);
 
 	  /* Repeating "info line" should do the following line.  */
 	  last_line_listed = sal.line + 1;
Index: gdb-head/gdb/stack.c
===================================================================
--- gdb-head.orig/gdb/stack.c
+++ gdb-head/gdb/stack.c
@@ -520,6 +520,7 @@ void
 print_frame_info (struct frame_info *frame, int print_level,
 		  enum print_what print_what, int print_args)
 {
+  struct gdbarch *gdbarch = get_frame_arch (frame);
   struct symtab_and_line sal;
   int source_print;
   int location_print;
@@ -532,7 +533,7 @@ print_frame_info (struct frame_info *fra
 	= make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
 
       annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
-			    get_frame_pc (frame));
+			    gdbarch, get_frame_pc (frame));
 
       /* Do this regardless of SOURCE because we don't have any source
          to list for this frame.  */
@@ -545,7 +546,8 @@ print_frame_info (struct frame_info *fra
       if (ui_out_is_mi_like_p (uiout))
         {
           annotate_frame_address ();
-          ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
+          ui_out_field_core_addr (uiout, "addr",
+				  gdbarch, get_frame_pc (frame));
           annotate_frame_address_end ();
         }
 
@@ -624,7 +626,8 @@ print_frame_info (struct frame_info *fra
 		 ability to decide for themselves if it is desired.  */
 	      if (opts.addressprint && mid_statement)
 		{
-		  ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
+		  ui_out_field_core_addr (uiout, "addr",
+					  gdbarch, get_frame_pc (frame));
 		  ui_out_text (uiout, "\t");
 		}
 
@@ -735,6 +738,7 @@ print_frame (struct frame_info *frame, i
 	     enum print_what print_what, int print_args,
 	     struct symtab_and_line sal)
 {
+  struct gdbarch *gdbarch = get_frame_arch (frame);
   char *funname = NULL;
   enum language funlang = language_unknown;
   struct ui_stream *stb;
@@ -747,7 +751,7 @@ print_frame (struct frame_info *frame, i
   find_frame_funname (frame, &funname, &funlang);
 
   annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
-			get_frame_pc (frame));
+			gdbarch, get_frame_pc (frame));
 
   list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
 
@@ -763,7 +767,7 @@ print_frame (struct frame_info *frame, i
 	|| print_what == LOC_AND_ADDRESS)
       {
 	annotate_frame_address ();
-	ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
+	ui_out_field_core_addr (uiout, "addr", gdbarch, get_frame_pc (frame));
 	annotate_frame_address_end ();
 	ui_out_text (uiout, " in ");
       }
@@ -1052,10 +1056,10 @@ frame_info (char *addr_exp, int from_tty
     {
       printf_filtered (_("Stack frame at "));
     }
-  fputs_filtered (paddress (get_frame_base (fi)), gdb_stdout);
+  fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
   printf_filtered (":\n");
   printf_filtered (" %s = ", pc_regname);
-  fputs_filtered (paddress (get_frame_pc (fi)), gdb_stdout);
+  fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
 
   wrap_here ("   ");
   if (funname)
@@ -1070,7 +1074,7 @@ frame_info (char *addr_exp, int from_tty
   puts_filtered ("; ");
   wrap_here ("    ");
   printf_filtered ("saved %s ", pc_regname);
-  fputs_filtered (paddress (frame_unwind_caller_pc (fi)), gdb_stdout);
+  fputs_filtered (paddress (gdbarch, frame_unwind_caller_pc (fi)), gdb_stdout);
   printf_filtered ("\n");
 
   if (calling_frame_info == NULL)
@@ -1088,7 +1092,7 @@ frame_info (char *addr_exp, int from_tty
   else
     {
       printf_filtered (" called by frame at ");
-      fputs_filtered (paddress (get_frame_base (calling_frame_info)),
+      fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
 		      gdb_stdout);
     }
   if (get_next_frame (fi) && calling_frame_info)
@@ -1097,7 +1101,7 @@ frame_info (char *addr_exp, int from_tty
   if (get_next_frame (fi))
     {
       printf_filtered (" caller of frame at ");
-      fputs_filtered (paddress (get_frame_base (get_next_frame (fi))),
+      fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
 		      gdb_stdout);
     }
   if (get_next_frame (fi) || calling_frame_info)
@@ -1118,7 +1122,7 @@ frame_info (char *addr_exp, int from_tty
     else
       {
 	printf_filtered (" Arglist at ");
-	fputs_filtered (paddress (arg_list), gdb_stdout);
+	fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
 	printf_filtered (",");
 
 	if (!gdbarch_frame_num_args_p (gdbarch))
@@ -1150,7 +1154,7 @@ frame_info (char *addr_exp, int from_tty
     else
       {
 	printf_filtered (" Locals at ");
-	fputs_filtered (paddress (arg_list), gdb_stdout);
+	fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
 	printf_filtered (",");
       }
   }
@@ -1192,14 +1196,14 @@ frame_info (char *addr_exp, int from_tty
 					   register_size (gdbarch,
 					   gdbarch_sp_regnum (gdbarch)));
 	    printf_filtered (" Previous frame's sp is ");
-	    fputs_filtered (paddress (sp), gdb_stdout);
+	    fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
 	    printf_filtered ("\n");
 	    need_nl = 0;
 	  }
 	else if (!optimized && lval == lval_memory)
 	  {
 	    printf_filtered (" Previous frame's sp at ");
-	    fputs_filtered (paddress (addr), gdb_stdout);
+	    fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
 	    printf_filtered ("\n");
 	    need_nl = 0;
 	  }
@@ -1234,7 +1238,7 @@ frame_info (char *addr_exp, int from_tty
 	      wrap_here (" ");
 	      printf_filtered (" %s at ",
 			       gdbarch_register_name (gdbarch, i));
-	      fputs_filtered (paddress (addr), gdb_stdout);
+	      fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
 	      count++;
 	    }
 	}
@@ -1485,8 +1489,8 @@ print_block_frame_locals (struct block *
 /* Same, but print labels.  */
 
 static int
-print_block_frame_labels (struct block *b, int *have_default,
-			  struct ui_file *stream)
+print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
+			  int *have_default, struct ui_file *stream)
 {
   struct dict_iterator iter;
   struct symbol *sym;
@@ -1511,7 +1515,8 @@ print_block_frame_labels (struct block *
 	  if (opts.addressprint)
 	    {
 	      fprintf_filtered (stream, " ");
-	      fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (sym)), stream);
+	      fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
+			      stream);
 	    }
 	  fprintf_filtered (stream, " in file %s, line %d\n",
 			    sal.symtab->filename, sal.line);
@@ -1568,6 +1573,7 @@ print_frame_label_vars (struct frame_inf
 #else
   struct blockvector *bl;
   struct block *block = get_frame_block (frame, 0);
+  struct gdbarch *gdbarch = get_frame_arch (frame);
   int values_printed = 0;
   int index, have_default = 0;
   char *blocks_printed;
@@ -1605,7 +1611,8 @@ print_frame_label_vars (struct frame_inf
 	{
 	  if (blocks_printed[index] == 0)
 	    {
-	      if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl, index),
+	      if (print_block_frame_labels (gdbarch,
+					    BLOCKVECTOR_BLOCK (bl, index),
 					    &have_default, stream))
 		values_printed = 1;
 	      blocks_printed[index] = 1;
Index: gdb-head/gdb/symfile.c
===================================================================
--- gdb-head.orig/gdb/symfile.c
+++ gdb-head/gdb/symfile.c
@@ -1800,9 +1800,9 @@ load_progress (ULONGEST bytes, void *unt
     {
       /* The write is just starting.  Let the user know we've started
 	 this section.  */
-      ui_out_message (uiout, 0, "Loading section %s, size 0x%s lma 0x%s\n",
-		      args->section_name, paddr_nz (args->section_size),
-		      paddr_nz (args->lma));
+      ui_out_message (uiout, 0, "Loading section %s, size %s lma %s\n",
+		      args->section_name, hex_string (args->section_size),
+		      paddress (target_gdbarch, args->lma));
       return;
     }
 
@@ -1819,11 +1819,11 @@ load_progress (ULONGEST bytes, void *unt
       struct cleanup *verify_cleanups = make_cleanup (xfree, check);
 
       if (target_read_memory (args->lma, check, bytes) != 0)
-	error (_("Download verify read failed at 0x%s"),
-	       paddr (args->lma));
+	error (_("Download verify read failed at %s"),
+	       paddress (target_gdbarch, args->lma));
       if (memcmp (args->buffer, check, bytes) != 0)
-	error (_("Download verify compare failed at 0x%s"),
-	       paddr (args->lma));
+	error (_("Download verify compare failed at %s"),
+	       paddress (target_gdbarch, args->lma));
       do_cleanups (verify_cleanups);
     }
   totals->data_count += bytes;
@@ -1979,7 +1979,7 @@ generic_load (char *args, int from_tty)
 
   entry = bfd_get_start_address (loadfile_bfd);
   ui_out_text (uiout, "Start address ");
-  ui_out_field_fmt (uiout, "address", "0x%s", paddr_nz (entry));
+  ui_out_field_fmt (uiout, "address", "%s", paddress (target_gdbarch, entry));
   ui_out_text (uiout, ", load size ");
   ui_out_field_fmt (uiout, "load-size", "%lu", total_progress.data_count);
   ui_out_text (uiout, "\n");
@@ -2081,6 +2081,7 @@ print_transfer_performance (struct ui_fi
 static void
 add_symbol_file_command (char *args, int from_tty)
 {
+  struct gdbarch *gdbarch = get_current_arch ();
   char *filename = NULL;
   int flags = OBJF_USERLOADED;
   char *arg;
@@ -2211,7 +2212,8 @@ add_symbol_file_command (char *args, int
          entered on the command line. */
       section_addrs->other[sec_num].name = sec;
       section_addrs->other[sec_num].addr = addr;
-      printf_unfiltered ("\t%s_addr = %s\n", sec, paddress (addr));
+      printf_unfiltered ("\t%s_addr = %s\n", sec,
+			 paddress (gdbarch, addr));
       sec_num++;
 
       /* The object's sections are initialized when a
@@ -3503,6 +3505,7 @@ list_overlays_command (char *args, int f
     ALL_OBJSECTIONS (objfile, osect)
       if (section_is_mapped (osect))
       {
+	struct gdbarch *gdbarch = get_objfile_arch (objfile);
 	const char *name;
 	bfd_vma lma, vma;
 	int size;
@@ -3513,13 +3516,13 @@ list_overlays_command (char *args, int f
 	name = bfd_section_name (objfile->obfd, osect->the_bfd_section);
 
 	printf_filtered ("Section %s, loaded at ", name);
-	fputs_filtered (paddress (lma), gdb_stdout);
+	fputs_filtered (paddress (gdbarch, lma), gdb_stdout);
 	puts_filtered (" - ");
-	fputs_filtered (paddress (lma + size), gdb_stdout);
+	fputs_filtered (paddress (gdbarch, lma + size), gdb_stdout);
 	printf_filtered (", mapped at ");
-	fputs_filtered (paddress (vma), gdb_stdout);
+	fputs_filtered (paddress (gdbarch, vma), gdb_stdout);
 	puts_filtered (" - ");
-	fputs_filtered (paddress (vma + size), gdb_stdout);
+	fputs_filtered (paddress (gdbarch, vma + size), gdb_stdout);
 	puts_filtered ("\n");
 
 	nmapped++;
Index: gdb-head/gdb/symfile-mem.c
===================================================================
--- gdb-head.orig/gdb/symfile-mem.c
+++ gdb-head/gdb/symfile-mem.c
@@ -196,8 +196,8 @@ try using the \"file\" command first."))
 	}
       args.bfd = bfd;
       args.sysinfo_ehdr = sysinfo_ehdr;
-      args.name = xstrprintf ("system-supplied DSO at 0x%s",
-		 paddr_nz (sysinfo_ehdr));
+      args.name = xstrprintf ("system-supplied DSO at %s",
+			      paddress (target_gdbarch, sysinfo_ehdr));
       /* Pass zero for FROM_TTY, because the action of loading the
 	 vsyscall DSO was not triggered by the user, even if the user
 	 typed "run" at the TTY.  */
Index: gdb-head/gdb/symmisc.c
===================================================================
--- gdb-head.orig/gdb/symmisc.c
+++ gdb-head/gdb/symmisc.c
@@ -67,13 +67,15 @@ static void dump_objfile (struct objfile
 
 static int block_depth (struct block *);
 
-static void print_partial_symbols (struct partial_symbol **, int,
+static void print_partial_symbols (struct gdbarch *,
+				   struct partial_symbol **, int,
 				   char *, struct ui_file *);
 
 void _initialize_symmisc (void);
 
 struct print_symbol_args
   {
+    struct gdbarch *gdbarch;
     struct symbol *symbol;
     int depth;
     struct ui_file *outfile;
@@ -261,6 +263,7 @@ dump_objfile (struct objfile *objfile)
 static void
 dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
 {
+  struct gdbarch *gdbarch = get_objfile_arch (objfile);
   struct minimal_symbol *msymbol;
   int index;
   char ms_type;
@@ -310,7 +313,8 @@ dump_msymbols (struct objfile *objfile, 
 	  break;
 	}
       fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
-      fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (msymbol)), outfile);
+      fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msymbol)),
+		      outfile);
       fprintf_filtered (outfile, " %s", SYMBOL_LINKAGE_NAME (msymbol));
       if (section)
 	fprintf_filtered (outfile, " section %s",
@@ -337,6 +341,7 @@ static void
 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
 	      struct ui_file *outfile)
 {
+  struct gdbarch *gdbarch = get_objfile_arch (objfile);
   int i;
 
   fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
@@ -365,15 +370,16 @@ dump_psymtab (struct objfile *objfile, s
       if (i != 0)
 	fprintf_filtered (outfile, ", ");
       wrap_here ("    ");
-      fputs_filtered (paddress (ANOFFSET (psymtab->section_offsets, i)),
+      fputs_filtered (paddress (gdbarch,
+				ANOFFSET (psymtab->section_offsets, i)),
 		      outfile);
     }
   fprintf_filtered (outfile, "\n");
 
   fprintf_filtered (outfile, "  Symbols cover text addresses ");
-  fputs_filtered (paddress (psymtab->textlow), outfile);
+  fputs_filtered (paddress (gdbarch, psymtab->textlow), outfile);
   fprintf_filtered (outfile, "-");
-  fputs_filtered (paddress (psymtab->texthigh), outfile);
+  fputs_filtered (paddress (gdbarch, psymtab->texthigh), outfile);
   fprintf_filtered (outfile, "\n");
   fprintf_filtered (outfile, "  Depends on %d other partial symtabs.\n",
 		    psymtab->number_of_dependencies);
@@ -386,13 +392,15 @@ dump_psymtab (struct objfile *objfile, s
     }
   if (psymtab->n_global_syms > 0)
     {
-      print_partial_symbols (objfile->global_psymbols.list
+      print_partial_symbols (gdbarch,
+			     objfile->global_psymbols.list
 			     + psymtab->globals_offset,
 			     psymtab->n_global_syms, "Global", outfile);
     }
   if (psymtab->n_static_syms > 0)
     {
-      print_partial_symbols (objfile->static_psymbols.list
+      print_partial_symbols (gdbarch,
+			     objfile->static_psymbols.list
 			     + psymtab->statics_offset,
 			     psymtab->n_static_syms, "Static", outfile);
     }
@@ -403,6 +411,7 @@ static void
 dump_symtab_1 (struct objfile *objfile, struct symtab *symtab,
 	       struct ui_file *outfile)
 {
+  struct gdbarch *gdbarch = get_objfile_arch (objfile);
   int i;
   struct dict_iterator iter;
   int len, blen;
@@ -430,7 +439,7 @@ dump_symtab_1 (struct objfile *objfile, 
       for (i = 0; i < len; i++)
 	{
 	  fprintf_filtered (outfile, " line %d at ", l->item[i].line);
-	  fputs_filtered (paddress (l->item[i].pc), outfile);
+	  fputs_filtered (paddress (gdbarch, l->item[i].pc), outfile);
 	  fprintf_filtered (outfile, "\n");
 	}
     }
@@ -458,9 +467,9 @@ dump_symtab_1 (struct objfile *objfile, 
 	     wants it.  */
 	  fprintf_filtered (outfile, ", %d syms/buckets in ",
 			    dict_size (BLOCK_DICT (b)));
-	  fputs_filtered (paddress (BLOCK_START (b)), outfile);
+	  fputs_filtered (paddress (gdbarch, BLOCK_START (b)), outfile);
 	  fprintf_filtered (outfile, "..");
-	  fputs_filtered (paddress (BLOCK_END (b)), outfile);
+	  fputs_filtered (paddress (gdbarch, BLOCK_END (b)), outfile);
 	  if (BLOCK_FUNCTION (b))
 	    {
 	      fprintf_filtered (outfile, ", function %s",
@@ -477,6 +486,7 @@ dump_symtab_1 (struct objfile *objfile, 
 	  ALL_BLOCK_SYMBOLS (b, iter, sym)
 	    {
 	      struct print_symbol_args s;
+	      s.gdbarch = gdbarch;
 	      s.symbol = sym;
 	      s.depth = depth + 1;
 	      s.outfile = outfile;
@@ -570,6 +580,7 @@ Arguments missing: an output file name a
 static int
 print_symbol (void *args)
 {
+  struct gdbarch *gdbarch = ((struct print_symbol_args *) args)->gdbarch;
   struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
   int depth = ((struct print_symbol_args *) args)->depth;
   struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
@@ -579,7 +590,8 @@ print_symbol (void *args)
   if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
     {
       fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
-      fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol)), outfile);
+      fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
+		      outfile);
       if (section)
 	fprintf_filtered (outfile, " section %s\n",
 			  bfd_section_name (section->the_bfd_section->owner,
@@ -644,7 +656,8 @@ print_symbol (void *args)
 
 	case LOC_STATIC:
 	  fprintf_filtered (outfile, "static at ");
-	  fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol)), outfile);
+	  fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
+			  outfile);
 	  if (section)
 	    fprintf_filtered (outfile, " section %s",
 			      bfd_section_name (section->the_bfd_section->owner,
@@ -682,7 +695,8 @@ print_symbol (void *args)
 
 	case LOC_LABEL:
 	  fprintf_filtered (outfile, "label at ");
-	  fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol)), outfile);
+	  fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
+			  outfile);
 	  if (section)
 	    fprintf_filtered (outfile, " section %s",
 			      bfd_section_name (section->the_bfd_section->owner,
@@ -693,10 +707,12 @@ print_symbol (void *args)
 	  fprintf_filtered (outfile, "block object ");
 	  gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
 	  fprintf_filtered (outfile, ", ");
-	  fputs_filtered (paddress (BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
+	  fputs_filtered (paddress (gdbarch,
+				    BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
 			  outfile);
 	  fprintf_filtered (outfile, "..");
-	  fputs_filtered (paddress (BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
+	  fputs_filtered (paddress (gdbarch,
+				    BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
 			  outfile);
 	  if (section)
 	    fprintf_filtered (outfile, " section %s",
@@ -773,7 +789,8 @@ maintenance_print_psymbols (char *args, 
 }
 
 static void
-print_partial_symbols (struct partial_symbol **p, int count, char *what,
+print_partial_symbols (struct gdbarch *gdbarch,
+		       struct partial_symbol **p, int count, char *what,
 		       struct ui_file *outfile)
 {
   fprintf_filtered (outfile, "  %s partial symbols:\n", what);
@@ -855,7 +872,7 @@ print_partial_symbols (struct partial_sy
 	  break;
 	}
       fputs_filtered (", ", outfile);
-      fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (*p)), outfile);
+      fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (*p)), outfile);
       fprintf_filtered (outfile, "\n");
       p++;
     }
@@ -995,6 +1012,7 @@ maintenance_info_psymtabs (char *regexp,
 
   ALL_OBJFILES (objfile)
     {
+      struct gdbarch *gdbarch = get_objfile_arch (objfile);
       struct partial_symtab *psymtab;
 
       /* We don't want to print anything for this objfile until we
@@ -1027,9 +1045,11 @@ maintenance_info_psymtabs (char *regexp,
 	      printf_filtered ("    fullname %s\n",
 			       psymtab->fullname ? psymtab->fullname : "(null)");
 	      printf_filtered ("    text addresses ");
-	      fputs_filtered (paddress (psymtab->textlow), gdb_stdout);
+	      fputs_filtered (paddress (gdbarch, psymtab->textlow),
+			      gdb_stdout);
 	      printf_filtered (" -- ");
-	      fputs_filtered (paddress (psymtab->texthigh), gdb_stdout);
+	      fputs_filtered (paddress (gdbarch, psymtab->texthigh),
+			      gdb_stdout);
 	      printf_filtered ("\n");
 	      printf_filtered ("    globals ");
 	      if (psymtab->n_global_syms)
@@ -1097,6 +1117,7 @@ maintenance_check_symtabs (char *ignore,
 
   ALL_PSYMTABS (objfile, ps)
   {
+    struct gdbarch *gdbarch = get_objfile_arch (objfile);
     s = PSYMTAB_TO_SYMTAB (ps);
     if (s == NULL)
       continue;
@@ -1140,9 +1161,9 @@ maintenance_check_symtabs (char *ignore,
 	printf_filtered ("Psymtab ");
 	puts_filtered (ps->filename);
 	printf_filtered (" covers bad range ");
-	fputs_filtered (paddress (ps->textlow), gdb_stdout);
+	fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
 	printf_filtered (" - ");
-	fputs_filtered (paddress (ps->texthigh), gdb_stdout);
+	fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
 	printf_filtered ("\n");
 	continue;
       }
@@ -1153,13 +1174,13 @@ maintenance_check_symtabs (char *ignore,
 	printf_filtered ("Psymtab ");
 	puts_filtered (ps->filename);
 	printf_filtered (" covers ");
-	fputs_filtered (paddress (ps->textlow), gdb_stdout);
+	fputs_filtered (paddress (gdbarch, ps->textlow), gdb_stdout);
 	printf_filtered (" - ");
-	fputs_filtered (paddress (ps->texthigh), gdb_stdout);
+	fputs_filtered (paddress (gdbarch, ps->texthigh), gdb_stdout);
 	printf_filtered (" but symtab covers only ");
-	fputs_filtered (paddress (BLOCK_START (b)), gdb_stdout);
+	fputs_filtered (paddress (gdbarch, BLOCK_START (b)), gdb_stdout);
 	printf_filtered (" - ");
-	fputs_filtered (paddress (BLOCK_END (b)), gdb_stdout);
+	fputs_filtered (paddress (gdbarch, BLOCK_END (b)), gdb_stdout);
 	printf_filtered ("\n");
       }
   }
Index: gdb-head/gdb/symtab.c
===================================================================
--- gdb-head.orig/gdb/symtab.c
+++ gdb-head/gdb/symtab.c
@@ -2079,8 +2079,8 @@ find_pc_sect_symtab (CORE_ADDR pc, struc
 	   will cause a core dump), but maybe we can successfully
 	   continue, so let's not.  */
 	warning (_("\
-(Internal error: pc 0x%s in read in psymtab, but not in symtab.)\n"),
-		 paddr_nz (pc));
+(Internal error: pc %s in read in psymtab, but not in symtab.)\n"),
+		 paddress (get_objfile_arch (ps->objfile), pc));
       s = PSYMTAB_TO_SYMTAB (ps);
     }
   return (s);
Index: gdb-head/gdb/target.c
===================================================================
--- gdb-head.orig/gdb/target.c
+++ gdb-head/gdb/target.c
@@ -1464,7 +1464,7 @@ target_flash_erase (ULONGEST address, LO
 	{
 	  if (targetdebug)
 	    fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
-                                paddr (address), phex (length, 0));
+                                hex_string (address), phex (length, 0));
 	  t->to_flash_erase (t, address, length);
 	  return;
 	}
@@ -2871,8 +2871,8 @@ deprecated_debug_xfer_memory (CORE_ADDR 
 
   fprintf_unfiltered (gdb_stdlog,
 		      "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
-		      paddress (memaddr), len, write ? "write" : "read",
-                      retval);
+		      paddress (target_gdbarch, memaddr), len,
+		      write ? "write" : "read", retval);
 
   if (retval > 0)
     {
Index: gdb-head/gdb/tracepoint.c
===================================================================
--- gdb-head.orig/gdb/tracepoint.c
+++ gdb-head/gdb/tracepoint.c
@@ -19,6 +19,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
+#include "arch-utils.h"
 #include "symtab.h"
 #include "frame.h"
 #include "gdbtypes.h"
@@ -1668,6 +1669,8 @@ trace_find_line_command (char *args, int
       old_chain = make_cleanup (xfree, sals.sals);
       if (sal.symtab == 0)
 	{
+	  struct gdbarch *gdbarch = get_current_arch ();
+
 	  printf_filtered ("TFIND: No line number information available");
 	  if (sal.pc != 0)
 	    {
@@ -1676,7 +1679,7 @@ trace_find_line_command (char *args, int
 	         have the symbolic address.  */
 	      printf_filtered (" for address ");
 	      wrap_here ("  ");
-	      print_address (sal.pc, gdb_stdout);
+	      print_address (gdbarch, sal.pc, gdb_stdout);
 	      printf_filtered (";\n -- will attempt to find by PC. \n");
 	    }
 	  else
@@ -1688,13 +1691,15 @@ trace_find_line_command (char *args, int
       else if (sal.line > 0
 	       && find_line_pc_range (sal, &start_pc, &end_pc))
 	{
+	  struct gdbarch *gdbarch = get_objfile_arch (sal.symtab->objfile);
+
 	  if (start_pc == end_pc)
 	    {
 	      printf_filtered ("Line %d of \"%s\"",
 			       sal.line, sal.symtab->filename);
 	      wrap_here ("  ");
 	      printf_filtered (" is at address ");
-	      print_address (start_pc, gdb_stdout);
+	      print_address (gdbarch, start_pc, gdb_stdout);
 	      wrap_here ("  ");
 	      printf_filtered (" but contains no code.\n");
 	      sal = find_pc_line (start_pc, 0);
@@ -1873,7 +1878,8 @@ scope_info (char *args, int from_tty)
 	      break;
 	    case LOC_STATIC:
 	      printf_filtered ("in static storage at address ");
-	      printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (sym)));
+	      printf_filtered ("%s", paddress (gdbarch,
+					       SYMBOL_VALUE_ADDRESS (sym)));
 	      break;
 	    case LOC_REGISTER:
 	      /* GDBARCH is the architecture associated with the objfile
@@ -1915,11 +1921,13 @@ scope_info (char *args, int from_tty)
 	      continue;
 	    case LOC_LABEL:
 	      printf_filtered ("a label at address ");
-	      printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (sym)));
+	      printf_filtered ("%s", paddress (gdbarch,
+					       SYMBOL_VALUE_ADDRESS (sym)));
 	      break;
 	    case LOC_BLOCK:
 	      printf_filtered ("a function at address ");
-	      printf_filtered ("%s", paddress (BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
+	      printf_filtered ("%s",
+		paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
 	      break;
 	    case LOC_UNRESOLVED:
 	      msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
@@ -1929,7 +1937,8 @@ scope_info (char *args, int from_tty)
 	      else
 		{
 		  printf_filtered ("static storage at address ");
-		  printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (msym)));
+		  printf_filtered ("%s",
+		    paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
 		}
 	      break;
 	    case LOC_OPTIMIZED_OUT:
Index: gdb-head/gdb/tui/tui-disasm.c
===================================================================
--- gdb-head.orig/gdb/tui/tui-disasm.c
+++ gdb-head/gdb/tui/tui-disasm.c
@@ -66,7 +66,7 @@ tui_disassemble (struct gdbarch *gdbarch
       if (asm_lines->insn)
         xfree (asm_lines->insn);
       
-      print_address (pc, gdb_dis_out);
+      print_address (gdbarch, pc, gdb_dis_out);
       asm_lines->addr = pc;
       asm_lines->addr_string = xstrdup (tui_file_get_strbuf (gdb_dis_out));
 
Index: gdb-head/gdb/tui/tui-stack.c
===================================================================
--- gdb-head.orig/gdb/tui/tui-stack.c
+++ gdb-head/gdb/tui/tui-stack.c
@@ -103,7 +103,7 @@ tui_make_status_line (struct tui_locator
 
   /* Translate PC address.  */
   pc_out = tui_sfileopen (128);
-  fputs_filtered (paddress (loc->addr), pc_out);
+  fputs_filtered (paddress (loc->gdbarch, loc->addr), pc_out);
   pc_buf = tui_file_get_strbuf (pc_out);
   pc_width = strlen (pc_buf);
   
Index: gdb-head/gdb/utils.c
===================================================================
--- gdb-head.orig/gdb/utils.c
+++ gdb-head/gdb/utils.c
@@ -2847,26 +2847,8 @@ get_cell (void)
   return buf[cell];
 }
 
-int
-strlen_paddr (void)
-{
-  return (gdbarch_addr_bit (current_gdbarch) / 8 * 2);
-}
-
-char *
-paddr (CORE_ADDR addr)
-{
-  return phex (addr, gdbarch_addr_bit (current_gdbarch) / 8);
-}
-
-char *
-paddr_nz (CORE_ADDR addr)
-{
-  return phex_nz (addr, gdbarch_addr_bit (current_gdbarch) / 8);
-}
-
 const char *
-paddress (CORE_ADDR addr)
+paddress (struct gdbarch *gdbarch, CORE_ADDR addr)
 {
   /* Truncate address to the size of a target address, avoiding shifts
      larger or equal than the width of a CORE_ADDR.  The local
@@ -2877,7 +2859,7 @@ paddress (CORE_ADDR addr)
      either zero or sign extended.  Should gdbarch_address_to_pointer or
      some ADDRESS_TO_PRINTABLE() be used to do the conversion?  */
 
-  int addr_bit = gdbarch_addr_bit (current_gdbarch);
+  int addr_bit = gdbarch_addr_bit (gdbarch);
 
   if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
     addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
Index: gdb-head/gdb/valops.c
===================================================================
--- gdb-head.orig/gdb/valops.c
+++ gdb-head/gdb/valops.c
@@ -702,8 +702,9 @@ value_fetch_lazy (struct value *val)
 		fprintf_unfiltered (gdb_stdlog, " register=%d",
 				    VALUE_REGNUM (new_val));
 	      else if (VALUE_LVAL (new_val) == lval_memory)
-		fprintf_unfiltered (gdb_stdlog, " address=0x%s",
-				    paddr_nz (value_address (new_val)));
+		fprintf_unfiltered (gdb_stdlog, " address=%s",
+				    paddress (gdbarch,
+					      value_address (new_val)));
 	      else
 		fprintf_unfiltered (gdb_stdlog, " computed");
 
Index: gdb-head/gdb/valprint.c
===================================================================
--- gdb-head.orig/gdb/valprint.c
+++ gdb-head/gdb/valprint.c
@@ -1393,6 +1393,7 @@ val_print_string (struct type *elttype, 
   int bytes_read;
   gdb_byte *buffer = NULL;	/* Dynamically growable fetch buffer.  */
   struct cleanup *old_chain = NULL;	/* Top of the old cleanup chain.  */
+  struct gdbarch *gdbarch = get_type_arch (elttype);
   int width = TYPE_LENGTH (elttype);
 
   /* First we need to figure out the limit on the number of characters we are
@@ -1455,13 +1456,13 @@ val_print_string (struct type *elttype, 
       if (errcode == EIO)
 	{
 	  fprintf_filtered (stream, " <Address ");
-	  fputs_filtered (paddress (addr), stream);
+	  fputs_filtered (paddress (gdbarch, addr), stream);
 	  fprintf_filtered (stream, " out of bounds>");
 	}
       else
 	{
 	  fprintf_filtered (stream, " <Error reading address ");
-	  fputs_filtered (paddress (addr), stream);
+	  fputs_filtered (paddress (gdbarch, addr), stream);
 	  fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
 	}
     }
Index: gdb-head/gdb/value.h
===================================================================
--- gdb-head.orig/gdb/value.h
+++ gdb-head/gdb/value.h
@@ -318,7 +318,8 @@ extern struct value *coerce_array (struc
 struct frame_info;
 struct fn_field;
 
-extern void print_address_demangle (CORE_ADDR, struct ui_file *, int);
+extern void print_address_demangle (struct gdbarch *, CORE_ADDR,
+				    struct ui_file *, int);
 
 extern LONGEST value_as_long (struct value *val);
 extern DOUBLEST value_as_double (struct value *val);
Index: gdb-head/gdb/xcoffsolib.c
===================================================================
--- gdb-head.orig/gdb/xcoffsolib.c
+++ gdb-head/gdb/xcoffsolib.c
@@ -62,6 +62,7 @@ static void sharedlibrary_command (char 
 static void
 solib_info (char *args, int from_tty)
 {
+  int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
   struct vmap *vp = vmap;
 
   /* Check for new shared libraries loaded with load ().  */
@@ -83,8 +84,10 @@ Text Range		Data Range		Syms	Shared Obje
   for (; vp != NULL; vp = vp->nxt)
     {
       printf_unfiltered ("0x%s-0x%s	0x%s-0x%s	%s	%s%s%s%s\n",
-			 paddr (vp->tstart),paddr (vp->tend),
-			 paddr (vp->dstart), paddr (vp->dend),
+			 phex (vp->tstart, addr_size),
+			 phex (vp->tend, addr_size),
+			 phex (vp->dstart, addr_size),
+			 phex (vp->dend, addr_size),
 			 vp->loaded ? "Yes" : "No ",
 			 vp->name,
 			 *vp->member ? "(" : "",
Index: gdb-head/gdb/ada-lang.c
===================================================================
--- gdb-head.orig/gdb/ada-lang.c
+++ gdb-head/gdb/ada-lang.c
@@ -10301,7 +10301,7 @@ print_one_exception (enum exception_catc
   if (opts.addressprint)
     {
       annotate_field (4);
-      ui_out_field_core_addr (uiout, "addr", b->loc->address);
+      ui_out_field_core_addr (uiout, "addr", b->loc->gdbarch, b->loc->address);
     }
 
   annotate_field (5);
Index: gdb-head/gdb/mi/mi-main.c
===================================================================
--- gdb-head.orig/gdb/mi/mi-main.c
+++ gdb-head/gdb/mi/mi-main.c
@@ -935,13 +935,15 @@ mi_cmd_data_read_memory (char *command, 
     error ("Unable to read memory.");
 
   /* Output the header information.  */
-  ui_out_field_core_addr (uiout, "addr", addr);
+  ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
   ui_out_field_int (uiout, "nr-bytes", nr_bytes);
   ui_out_field_int (uiout, "total-bytes", total_bytes);
-  ui_out_field_core_addr (uiout, "next-row", addr + word_size * nr_cols);
-  ui_out_field_core_addr (uiout, "prev-row", addr - word_size * nr_cols);
-  ui_out_field_core_addr (uiout, "next-page", addr + total_bytes);
-  ui_out_field_core_addr (uiout, "prev-page", addr - total_bytes);
+  ui_out_field_core_addr (uiout, "next-row",
+			  gdbarch, addr + word_size * nr_cols);
+  ui_out_field_core_addr (uiout, "prev-row",
+			  gdbarch, addr - word_size * nr_cols);
+  ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
+  ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
 
   /* Build the result as a two dimentional table.  */
   {
@@ -961,7 +963,7 @@ mi_cmd_data_read_memory (char *command, 
 	struct value_print_options opts;
 
 	cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
-	ui_out_field_core_addr (uiout, "addr", addr + row_byte);
+	ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
 	/* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
 	cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
 	get_formatted_print_options (&opts, word_format);
Index: gdb-head/gdb/mi/mi-symbol-cmds.c
===================================================================
--- gdb-head.orig/gdb/mi/mi-symbol-cmds.c
+++ gdb-head/gdb/mi/mi-symbol-cmds.c
@@ -19,6 +19,7 @@
 #include "defs.h"
 #include "mi-cmds.h"
 #include "symtab.h"
+#include "objfiles.h"
 #include "ui-out.h"
 
 /* SYMBOL-LIST-LINES:
@@ -30,6 +31,7 @@
 void
 mi_cmd_symbol_list_lines (char *command, char **argv, int argc)
 {
+  struct gdbarch *gdbarch;
   char *filename;
   struct symtab *s;
   int i;
@@ -48,13 +50,14 @@ mi_cmd_symbol_list_lines (char *command,
      sorted by increasing values in the symbol table, so no need to
      perform any other sorting. */
 
+  gdbarch = get_objfile_arch (s->objfile);
   cleanup_stack = make_cleanup_ui_out_list_begin_end (uiout, "lines");
 
   if (LINETABLE (s) != NULL && LINETABLE (s)->nitems > 0)
     for (i = 0; i < LINETABLE (s)->nitems; i++)
     {
       cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
-      ui_out_field_core_addr (uiout, "pc", LINETABLE (s)->item[i].pc);
+      ui_out_field_core_addr (uiout, "pc", gdbarch, LINETABLE (s)->item[i].pc);
       ui_out_field_int (uiout, "line", LINETABLE (s)->item[i].line);
       do_cleanups (cleanup_tuple);
     }
Index: gdb-head/gdb/ui-out.c
===================================================================
--- gdb-head.orig/gdb/ui-out.c
+++ gdb-head/gdb/ui-out.c
@@ -488,10 +488,11 @@ ui_out_field_fmt_int (struct ui_out *uio
 void
 ui_out_field_core_addr (struct ui_out *uiout,
 			const char *fldname,
+			struct gdbarch *gdbarch,
 			CORE_ADDR address)
 {
   char addstr[20];
-  int addr_bit = gdbarch_addr_bit (current_gdbarch);
+  int addr_bit = gdbarch_addr_bit (gdbarch);
 
   if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
     address &= ((CORE_ADDR) 1 << addr_bit) - 1;
Index: gdb-head/gdb/ui-out.h
===================================================================
--- gdb-head.orig/gdb/ui-out.h
+++ gdb-head/gdb/ui-out.h
@@ -115,7 +115,7 @@ extern void ui_out_field_fmt_int (struct
 		 		  int value);
 
 extern void ui_out_field_core_addr (struct ui_out *uiout, const char *fldname,
-				    CORE_ADDR address);
+				    struct gdbarch *gdbarch, CORE_ADDR address);
 
 extern void ui_out_field_string (struct ui_out * uiout, const char *fldname,
 				 const char *string);
Index: gdb-head/gdb/testsuite/gdb.threads/tls-shared.exp
===================================================================
--- gdb-head.orig/gdb/testsuite/gdb.threads/tls-shared.exp
+++ gdb-head/gdb/testsuite/gdb.threads/tls-shared.exp
@@ -93,7 +93,7 @@ gdb_test "print i_tls" "2" "print thread
 gdb_test "ptype i_tls" "int" "ptype of thread local storage variable"
 
 gdb_test "info address i_tls" \
-	"Symbol \\\"i_tls\\\" is a thread-local variable at offset 0 in the thread-local storage for .*tls-main.." \
+	"Symbol \\\"i_tls\\\" is a thread-local variable at offset 0x0 in the thread-local storage for .*tls-main.." \
 	"print storage info for thread local storage variable"
 
 set line_number [gdb_get_line_number "break here to check result"]
Index: gdb-head/gdb/windows-tdep.c
===================================================================
--- gdb-head.orig/gdb/windows-tdep.c
+++ gdb-head/gdb/windows-tdep.c
@@ -22,18 +22,17 @@
 
 void
 windows_xfer_shared_library (const char* so_name, CORE_ADDR load_addr,
-			     struct obstack *obstack)
+			     struct gdbarch *gdbarch, struct obstack *obstack)
 {
   char *p;
   obstack_grow_str (obstack, "<library name=\"");
   p = xml_escape_text (so_name);
   obstack_grow_str (obstack, p);
   xfree (p);
-  obstack_grow_str (obstack, "\"><segment address=\"0x");
+  obstack_grow_str (obstack, "\"><segment address=\"");
   /* The symbols in a dll are offset by 0x1000, which is the the
      offset from 0 of the first byte in an image - because of the file
      header and the section alignment. */
-  p = paddr_nz (load_addr + 0x1000);
-  obstack_grow_str (obstack, p);
+  obstack_grow_str (obstack, paddress (gdbarch, load_addr + 0x1000));
   obstack_grow_str (obstack, "\"/></library>");
 }
Index: gdb-head/gdb/windows-tdep.h
===================================================================
--- gdb-head.orig/gdb/windows-tdep.h
+++ gdb-head/gdb/windows-tdep.h
@@ -19,8 +19,10 @@
 #define WINDOWS_TDEP_H
 
 struct obstack;
+struct gdbarch;
 
 extern void windows_xfer_shared_library (const char* so_name,
 					 CORE_ADDR load_addr,
+					 struct gdbarch *gdbarch,
 					 struct obstack *obstack);
 #endif
Index: gdb-head/gdb/windows-nat.c
===================================================================
--- gdb-head.orig/gdb/windows-nat.c
+++ gdb-head/gdb/windows-nat.c
@@ -2082,7 +2082,7 @@ windows_xfer_shared_libraries (struct ta
   obstack_grow_str (&obstack, "<library-list>\n");
   for (so = solib_start.next; so; so = so->next)
     windows_xfer_shared_library (so->so_name, (CORE_ADDR) (uintptr_t) so->lm_info->load_addr,
-				 &obstack);
+				 target_gdbarch, &obstack);
   obstack_grow_str0 (&obstack, "</library-list>\n");
 
   buf = obstack_finish (&obstack);
Index: gdb-head/gdb/amd64-tdep.c
===================================================================
--- gdb-head.orig/gdb/amd64-tdep.c
+++ gdb-head/gdb/amd64-tdep.c
@@ -1075,9 +1075,9 @@ fixup_riprel (struct gdbarch *gdbarch, s
 
   if (debug_displaced)
     fprintf_unfiltered (gdb_stdlog, "displaced: %%rip-relative addressing used.\n"
-			"displaced: using temp reg %d, old value 0x%s, new value 0x%s\n",
-			dsc->tmp_regno, paddr_nz (dsc->tmp_save),
-			paddr_nz (rip_base));
+			"displaced: using temp reg %d, old value %s, new value %s\n",
+			dsc->tmp_regno, paddress (gdbarch, dsc->tmp_save),
+			paddress (gdbarch, rip_base));
 }
 
 static void
@@ -1144,8 +1144,8 @@ amd64_displaced_step_copy_insn (struct g
 
   if (debug_displaced)
     {
-      fprintf_unfiltered (gdb_stdlog, "displaced: copy 0x%s->0x%s: ",
-			  paddr_nz (from), paddr_nz (to));
+      fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
+			  paddress (gdbarch, from), paddress (gdbarch, to));
       displaced_step_dump_bytes (gdb_stdlog, buf, len);
     }
 
@@ -1258,17 +1258,18 @@ amd64_displaced_step_fixup (struct gdbar
 
   if (debug_displaced)
     fprintf_unfiltered (gdb_stdlog,
-			"displaced: fixup (0x%s, 0x%s), "
+			"displaced: fixup (%s, %s), "
 			"insn = 0x%02x 0x%02x ...\n",
-			paddr_nz (from), paddr_nz (to), insn[0], insn[1]);
+			paddress (gdbarch, from), paddress (gdbarch, to),
+			insn[0], insn[1]);
 
   /* If we used a tmp reg, restore it.	*/
 
   if (dsc->tmp_used)
     {
       if (debug_displaced)
-	fprintf_unfiltered (gdb_stdlog, "displaced: restoring reg %d to 0x%s\n",
-			    dsc->tmp_regno, paddr_nz (dsc->tmp_save));
+	fprintf_unfiltered (gdb_stdlog, "displaced: restoring reg %d to %s\n",
+			    dsc->tmp_regno, paddress (gdbarch, dsc->tmp_save));
       regcache_cooked_write_unsigned (regs, dsc->tmp_regno, dsc->tmp_save);
     }
 
@@ -1332,8 +1333,9 @@ amd64_displaced_step_fixup (struct gdbar
 	  if (debug_displaced)
 	    fprintf_unfiltered (gdb_stdlog,
 				"displaced: "
-				"relocated %%rip from 0x%s to 0x%s\n",
-				paddr_nz (orig_rip), paddr_nz (rip));
+				"relocated %%rip from %s to %s\n",
+				paddress (gdbarch, orig_rip),
+				paddress (gdbarch, rip));
 	}
     }
 
@@ -1358,10 +1360,10 @@ amd64_displaced_step_fixup (struct gdbar
 
       if (debug_displaced)
 	fprintf_unfiltered (gdb_stdlog,
-			    "displaced: relocated return addr at 0x%s "
-			    "to 0x%s\n",
-			    paddr_nz (rsp),
-			    paddr_nz (retaddr));
+			    "displaced: relocated return addr at %s "
+			    "to %s\n",
+			    paddress (gdbarch, rsp),
+			    paddress (gdbarch, retaddr));
     }
 }
 
Index: gdb-head/gdb/record.c
===================================================================
--- gdb-head.orig/gdb/record.c
+++ gdb-head/gdb/record.c
@@ -261,9 +261,9 @@ record_arch_list_add_mem (CORE_ADDR addr
 
   if (record_debug > 1)
     fprintf_unfiltered (gdb_stdlog,
-			"Process record: add mem addr = 0x%s len = %d to "
+			"Process record: add mem addr = %s len = %d to "
 			"record list.\n",
-			paddr_nz (addr), len);
+			paddress (target_gdbarch, addr), len);
 
   if (!addr)
     return 0;
@@ -281,8 +281,8 @@ record_arch_list_add_mem (CORE_ADDR addr
       if (record_debug)
 	fprintf_unfiltered (gdb_stdlog,
 			    "Process record: error reading memory at "
-			    "addr = 0x%s len = %d.\n",
-			    paddr_nz (addr), len);
+			    "addr = %s len = %d.\n",
+			    paddress (target_gdbarch, addr), len);
       xfree (rec->u.mem.val);
       xfree (rec);
       return -1;
@@ -649,6 +649,7 @@ record_wait (struct target_ops *ops,
   else
     {
       struct regcache *regcache = get_current_regcache ();
+      struct gdbarch *gdbarch = get_regcache_arch (regcache);
       int continue_flag = 1;
       int first_record_end = 1;
       struct cleanup *old_cleanups = make_cleanup (record_wait_cleanups, 0);
@@ -664,14 +665,13 @@ record_wait (struct target_ops *ops,
 	    {
 	      if (record_debug)
 		fprintf_unfiltered (gdb_stdlog,
-				    "Process record: break at 0x%s.\n",
-				    paddr_nz (tmp_pc));
-	      if (gdbarch_decr_pc_after_break (get_regcache_arch (regcache))
+				    "Process record: break at %s.\n",
+				    paddress (gdbarch, tmp_pc));
+	      if (gdbarch_decr_pc_after_break (gdbarch)
 		  && !record_resume_step)
 		regcache_write_pc (regcache,
 				   tmp_pc +
-				   gdbarch_decr_pc_after_break
-				   (get_regcache_arch (regcache)));
+				   gdbarch_decr_pc_after_break (gdbarch));
 	      goto replay_out;
 	    }
 	}
@@ -731,16 +731,16 @@ record_wait (struct target_ops *ops,
 	      if (record_debug > 1)
 		fprintf_unfiltered (gdb_stdlog,
 				    "Process record: record_mem %s to "
-				    "inferior addr = 0x%s len = %d.\n",
+				    "inferior addr = %s len = %d.\n",
 				    host_address_to_string (record_list),
-				    paddr_nz (record_list->u.mem.addr),
+				    paddress (gdbarch, record_list->u.mem.addr),
 				    record_list->u.mem.len);
 
 	      if (target_read_memory
 		  (record_list->u.mem.addr, mem, record_list->u.mem.len))
 		error (_("Process record: error reading memory at "
-			 "addr = 0x%s len = %d."),
-		       paddr_nz (record_list->u.mem.addr),
+			 "addr = %s len = %d."),
+		       paddress (gdbarch, record_list->u.mem.addr),
 		       record_list->u.mem.len);
 
 	      if (target_write_memory
@@ -748,8 +748,8 @@ record_wait (struct target_ops *ops,
 		   record_list->u.mem.len))
 		error (_
 		       ("Process record: error writing memory at "
-			"addr = 0x%s len = %d."),
-		       paddr_nz (record_list->u.mem.addr),
+			"addr = %s len = %d."),
+		       paddress (gdbarch, record_list->u.mem.addr),
 		       record_list->u.mem.len);
 
 	      memcpy (record_list->u.mem.val, mem, record_list->u.mem.len);
@@ -790,15 +790,14 @@ record_wait (struct target_ops *ops,
 		      if (record_debug)
 			fprintf_unfiltered (gdb_stdlog,
 					    "Process record: break "
-					    "at 0x%s.\n",
-					    paddr_nz (tmp_pc));
-		      if (gdbarch_decr_pc_after_break (get_regcache_arch (regcache))
+					    "at %s.\n",
+					    paddress (gdbarch, tmp_pc));
+		      if (gdbarch_decr_pc_after_break (gdbarch)
 			  && execution_direction == EXEC_FORWARD
 			  && !record_resume_step)
 			regcache_write_pc (regcache,
 					   tmp_pc +
-					   gdbarch_decr_pc_after_break
-					   (get_regcache_arch (regcache)));
+					   gdbarch_decr_pc_after_break (gdbarch));
 		      continue_flag = 0;
 		    }
 		}
@@ -996,8 +995,8 @@ record_xfer_partial (struct target_ops *
 	  /* Let user choose if he wants to write memory or not.  */
 	  if (!nquery (_("Because GDB is in replay mode, writing to memory "
 		         "will make the execution log unusable from this "
-		         "point onward.  Write memory at address 0x%s?"),
-		       paddr_nz (offset)))
+		         "point onward.  Write memory at address %s?"),
+		       paddress (target_gdbarch, offset)))
 	    return -1;
 
 	  /* Destroy the record from here forward.  */
Index: gdb-head/gdb/linux-record.c
===================================================================
--- gdb-head.orig/gdb/linux-record.c
+++ gdb-head/gdb/linux-record.c
@@ -96,6 +96,7 @@ int
 record_linux_system_call (int num, struct regcache *regcache,
 			  struct linux_record_tdep *tdep)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   uint32_t tmpu32;
 
   switch (num)
@@ -547,8 +548,8 @@ record_linux_system_call (int num, struc
 		if (record_debug)
 		  fprintf_unfiltered (gdb_stdlog,
 				      "Process record: error reading memory "
-				      "at addr = 0x%s len = %lu.\n",
-				      paddr_nz (tmpu32),
+				      "at addr = %s len = %lu.\n",
+				      paddress (gdbarch, tmpu32),
 				      (unsigned long)sizeof (sel));
 		return -1;
 	      }
@@ -624,10 +625,10 @@ record_linux_system_call (int num, struc
 	target_terminal_ours ();
 	q =
 	  yquery (_("The next instruction is syscall munmap.  "
-		    "It will free the memory addr = 0x%s len = %u.  "
+		    "It will free the memory addr = %s len = %u.  "
 		    "It will make record target get error.  "
 		    "Do you want to stop the program?"),
-		  paddr_nz (tmpu32), (int)len);
+		  paddress (gdbarch, tmpu32), (int)len);
 	target_terminal_inferior ();
 	if (q)
 	  return 1;
@@ -687,8 +688,8 @@ record_linux_system_call (int num, struc
 		    if (record_debug)
 		      fprintf_unfiltered (gdb_stdlog,
 					  "Process record: error reading "
-					  "memory at addr = 0x%s len = %lu.\n",
-					  paddr_nz (tmpu32),
+					  "memory at addr = %s len = %lu.\n",
+					  paddress (gdbarch, tmpu32),
 					  (unsigned long)sizeof (a));
 		    return -1;
 		  }
@@ -712,8 +713,8 @@ record_linux_system_call (int num, struc
 		    if (record_debug)
 		      fprintf_unfiltered (gdb_stdlog,
 					  "Process record: error reading "
-					  "memory at addr = 0x%s len = %lu.\n",
-					  paddr_nz (tmpu32),
+					  "memory at addr = %s len = %lu.\n",
+					  paddress (gdbarch, tmpu32),
 				          (unsigned long)sizeof (a));
 		    return -1;
 		  }
@@ -737,8 +738,8 @@ record_linux_system_call (int num, struc
 		    if (record_debug)
 		      fprintf_unfiltered (gdb_stdlog,
 					  "Process record: error reading "
-					  "memory at addr = 0x%s len = %lu.\n",
-					  paddr_nz (tmpu32),
+					  "memory at addr = %s len = %lu.\n",
+					  paddress (gdbarch, tmpu32),
 					  (unsigned long)sizeof (a));
 		    return -1;
 		  }
@@ -750,9 +751,9 @@ record_linux_system_call (int num, struc
 			if (record_debug)
 			  fprintf_unfiltered (gdb_stdlog,
 					      "Process record: error reading "
-					      "memory at addr = 0x%s "
+					      "memory at addr = %s "
 					      "len = %lu.\n",
-					      paddr_nz (a[2]),
+					      paddress (gdbarch, a[2]),
 					      (unsigned long)sizeof (a[2]));
 			return -1;
 		      }
@@ -774,8 +775,8 @@ record_linux_system_call (int num, struc
 		    if (record_debug)
 		      fprintf_unfiltered (gdb_stdlog,
 					  "Process record: error reading "
-					  "memory at addr = 0x%s len = %lu.\n",
-					  paddr_nz (tmpu32),
+					  "memory at addr = %s len = %lu.\n",
+					  paddress (gdbarch, tmpu32),
 					  (unsigned long)sizeof (a));
 		    return -1;
 		  }
@@ -787,9 +788,9 @@ record_linux_system_call (int num, struc
 			if (record_debug)
 			  fprintf_unfiltered (gdb_stdlog,
 					      "Process record: error reading "
-					      "memory at addr = 0x%s "
+					      "memory at addr = %s "
 					      "len = %lu.\n",
-					      paddr_nz (a[2]),
+					      paddress (gdbarch, a[2]),
 					      (unsigned long)sizeof (a[2]));
 			return -1;
 		      }
@@ -820,8 +821,8 @@ record_linux_system_call (int num, struc
 		    if (record_debug)
 		      fprintf_unfiltered (gdb_stdlog,
 					  "Process record: error reading "
-					  "memory at addr = 0x%s len = %lu.\n",
-					  paddr_nz (tmpu32),
+					  "memory at addr = %s len = %lu.\n",
+					  paddress (gdbarch, tmpu32),
 					  (unsigned long)sizeof (a));
 		    return -1;
 		  }
@@ -833,9 +834,9 @@ record_linux_system_call (int num, struc
 			if (record_debug)
 			  fprintf_unfiltered (gdb_stdlog,
 					      "Process record: error reading "
-					      "memory at addr = 0x%s "
+					      "memory at addr = %s "
 					      "len = %lu.\n",
-					      paddr_nz (a[4]),
+					      paddress (gdbarch, a[4]),
 					      (unsigned long)sizeof (av));
 			return -1;
 		      }
@@ -877,8 +878,8 @@ record_linux_system_call (int num, struc
 		    if (record_debug)
 		      fprintf_unfiltered (gdb_stdlog,
 					  "Process record: error reading "
-					  "memory at addr = 0x%s len = %lu.\n",
-					  paddr_nz (tmpu32),
+					  "memory at addr = %s len = %lu.\n",
+					  paddress (gdbarch, tmpu32),
 					  (unsigned long)sizeof (a));
 		    return -1;
 		  }
@@ -892,9 +893,9 @@ record_linux_system_call (int num, struc
 			if (record_debug)
 			  fprintf_unfiltered (gdb_stdlog,
 					      "Process record: error reading "
-					      "memory at addr = 0x%s "
+					      "memory at addr = %s "
 					      "len = %lu.\n",
-					      paddr_nz (a[1]),
+					      paddress (gdbarch, a[1]),
 					      (unsigned long)sizeof (rec));
 			return -1;
 		      }
@@ -916,10 +917,10 @@ record_linux_system_call (int num, struc
 				  fprintf_unfiltered (gdb_stdlog,
 						      "Process record: error "
 						      "reading memory at "
-						      "addr = 0x%s "
+						      "addr = %s "
 						      "len = %lu.\n",
-						      paddr_nz (rec.
-								msg_iov),
+						      paddress (gdbarch,
+								rec.msg_iov),
 						      (unsigned long)sizeof (iov));
 				return -1;
 			      }
@@ -1234,8 +1235,8 @@ record_linux_system_call (int num, struc
 		    if (record_debug)
 		      fprintf_unfiltered (gdb_stdlog,
 					  "Process record: error reading "
-					  "memory at addr = 0x%s len = %lu.\n",
-					  paddr_nz (vec),
+					  "memory at addr = %s len = %lu.\n",
+					  paddress (gdbarch, vec),
 					  (unsigned long)sizeof (struct record_iovec));
 		    return -1;
 		  }
@@ -1783,8 +1784,8 @@ record_linux_system_call (int num, struc
 	      if (record_debug)
 		fprintf_unfiltered (gdb_stdlog,
 				    "Process record: error reading memory "
-				    "at addr = 0x%s len = %u.\n",
-				    paddr_nz (tmpu32),
+				    "at addr = %s len = %u.\n",
+				    paddress (gdbarch, tmpu32),
 				    (int)(nr * tdep->size_int));
 	      return -1;
 	    }
Index: gdb-head/gdb/darwin-nat-info.c
===================================================================
--- gdb-head.orig/gdb/darwin-nat-info.c
+++ gdb-head/gdb/darwin-nat-info.c
@@ -576,8 +576,8 @@ darwin_debug_regions (task_t task, mach_
       if (print)
         {
           printf_filtered (_("%s-%s %s/%s  %s %s %s"),
-                           paddr(prev_address),
-                           paddr(prev_address + prev_size),
+                           paddress (target_gdbarch, prev_address),
+                           paddress (target_gdbarch, prev_address + prev_size),
                            unparse_protection (prev_info.protection),
                            unparse_protection (prev_info.max_protection),
                            unparse_inheritance (prev_info.inheritance),
@@ -661,8 +661,8 @@ darwin_debug_regions_recurse (task_t tas
 	break;
       row_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "regions-row");
 
-      ui_out_field_core_addr (uiout, "start", r_start);
-      ui_out_field_core_addr (uiout, "end", r_start + r_size);
+      ui_out_field_core_addr (uiout, "start", target_gdbarch, r_start);
+      ui_out_field_core_addr (uiout, "end", target_gdbarch, r_start + r_size);
       ui_out_field_string (uiout, "min-prot", 
 			   unparse_protection (r_info.protection));
       ui_out_field_string (uiout, "max-prot", 
Index: gdb-head/gdb/gnu-nat.c
===================================================================
--- gdb-head.orig/gdb/gnu-nat.c
+++ gdb-head/gdb/gnu-nat.c
@@ -2492,7 +2492,8 @@ gnu_xfer_memory (CORE_ADDR memaddr, gdb_
   else
     {
       inf_debug (gnu_current_inf, "%s %s[%d] %s %s",
-		 write ? "writing" : "reading", paddr (memaddr), len,
+		 write ? "writing" : "reading",
+		 paddress (target_gdbarch, memaddr), len,
 		 write ? "<--" : "-->", host_address_to_string (myaddr));
       if (write)
 	return gnu_write_inferior (task, memaddr, myaddr, len);
Index: gdb-head/gdb/mips-linux-nat.c
===================================================================
--- gdb-head.orig/gdb/mips-linux-nat.c
+++ gdb-head/gdb/mips-linux-nat.c
@@ -595,7 +595,8 @@ mips_show_dr (const char *func, CORE_ADD
 
   puts_unfiltered (func);
   if (addr || len)
-    printf_unfiltered (" (addr=0x%s, len=%d, type=%s)", paddr (addr), len,
+    printf_unfiltered (" (addr=%s, len=%d, type=%s)",
+		       paddress (target_gdbarch, addr), len,
 		       type == hw_write ? "data-write"
 		       : (type == hw_read ? "data-read"
 			  : (type == hw_access ? "data-read/write"
@@ -604,9 +605,11 @@ mips_show_dr (const char *func, CORE_ADD
   puts_unfiltered (":\n");
 
   for (i = 0; i < MAX_DEBUG_REGISTER; i++)
-    printf_unfiltered ("\tDR%d: lo=0x%s, hi=0x%s\n",
-		       i, paddr (get_watchlo (&watch_mirror, i)),
-		       paddr (get_watchhi (&watch_mirror, i)));
+    printf_unfiltered ("\tDR%d: lo=%s, hi=%s\n", i,
+		       paddress (target_gdbarch,
+				 get_watchlo (&watch_mirror, i)),
+		       paddress (target_gdbarch,
+				 get_watchhi (&watch_mirror, i)));
 }
 
 /* Return 1 if watch registers are usable.  Cached information is used
Index: gdb-head/gdb/doc/gdbint.texinfo
===================================================================
--- gdb-head.orig/gdb/doc/gdbint.texinfo
+++ gdb-head/gdb/doc/gdbint.texinfo
@@ -1400,8 +1400,8 @@ This function outputs a value of an @cod
 the name of the field.
 @end deftypefun
 
-@deftypefun void ui_out_field_core_addr (struct ui_out *@var{uiout}, const char *@var{fldname}, CORE_ADDR @var{address})
-This function outputs an address.
+@deftypefun void ui_out_field_core_addr (struct ui_out *@var{uiout}, const char *@var{fldname}, struct gdbarch *@var{gdbarch}, CORE_ADDR @var{address})
+This function outputs an address as appropriate for @var{gdbarch}.
 @end deftypefun
 
 @deftypefun void ui_out_field_string (struct ui_out *@var{uiout}, const char *@var{fldname}, const char *@var{string})

-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com


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