* gdbarch.sh (target_gdbarch): Remove macro.
authorTom Tromey <tromey@redhat.com>
Fri, 9 Nov 2012 19:58:03 +0000 (19:58 +0000)
committerTom Tromey <tromey@redhat.com>
Fri, 9 Nov 2012 19:58:03 +0000 (19:58 +0000)
(get_target_gdbarch): Rename to target_gdbarch.
* gdbarch.c, gdbarch.h: Rebuild.
* ada-tasks.c, aix-thread.c, amd64-linux-nat.c, arch-utils.c,
arm-tdep.c, auxv.c, breakpoint.c, bsd-uthread.c, corefile.c,
darwin-nat-info.c, dcache.c, dsrec.c, exec.c, fbsd-nat.c,
filesystem.c, gcore.c, gnu-nat.c, i386-darwin-nat.c, i386-nat.c,
ia64-vms-tdep.c, inf-ptrace.c, infcmd.c, jit.c, linux-nat.c,
linux-tdep.c, linux-thread-db.c, m32r-rom.c, memattr.c,
mep-tdep.c, microblaze-tdep.c, mips-linux-nat.c,
mips-linux-tdep.c, mips-tdep.c, monitor.c, moxie-tdep.c,
nto-procfs.c, nto-tdep.c, ppc-linux-nat.c, proc-service.c,
procfs.c, progspace.c, ravenscar-thread.c, record.c,
remote-m32r-sdi.c, remote-mips.c, remote-sim.c, remote.c,
rl78-tdep.c, rs6000-nat.c, rx-tdep.c, s390-nat.c, sol-thread.c,
solib-darwin.c, solib-dsbt.c, solib-frv.c, solib-ia64-hpux.c,
solib-irix.c, solib-pa64.c, solib-som.c, solib-spu.c,
solib-sunos.c, solib-svr4.c, solib.c, spu-linux-nat.c,
spu-multiarch.c, spu-tdep.c, symfile-mem.c, symfile.c, symtab.c,
target-descriptions.c, target.c, target.h, tracepoint.c,
windows-nat.c, windows-tdep.c, xcoffsolib.c, cli/cli-dump.c,
common/agent.c, mi/mi-interp.c, python/py-finishbreakpoint.c,
python/py-inferior.c, python/python.c: Update.

86 files changed:
gdb/ChangeLog
gdb/ada-tasks.c
gdb/aix-thread.c
gdb/amd64-linux-nat.c
gdb/arch-utils.c
gdb/arm-tdep.c
gdb/auxv.c
gdb/breakpoint.c
gdb/bsd-uthread.c
gdb/cli/cli-dump.c
gdb/common/agent.c
gdb/corefile.c
gdb/darwin-nat-info.c
gdb/dcache.c
gdb/dsrec.c
gdb/exec.c
gdb/fbsd-nat.c
gdb/filesystem.c
gdb/gcore.c
gdb/gdbarch.c
gdb/gdbarch.h
gdb/gdbarch.sh
gdb/gnu-nat.c
gdb/i386-darwin-nat.c
gdb/i386-nat.c
gdb/ia64-vms-tdep.c
gdb/inf-ptrace.c
gdb/infcmd.c
gdb/jit.c
gdb/linux-nat.c
gdb/linux-tdep.c
gdb/linux-thread-db.c
gdb/m32r-rom.c
gdb/memattr.c
gdb/mep-tdep.c
gdb/mi/mi-interp.c
gdb/microblaze-tdep.c
gdb/mips-linux-nat.c
gdb/mips-linux-tdep.c
gdb/mips-tdep.c
gdb/monitor.c
gdb/moxie-tdep.c
gdb/nto-procfs.c
gdb/nto-tdep.c
gdb/ppc-linux-nat.c
gdb/proc-service.c
gdb/procfs.c
gdb/progspace.c
gdb/python/py-finishbreakpoint.c
gdb/python/py-inferior.c
gdb/python/python.c
gdb/ravenscar-thread.c
gdb/record.c
gdb/remote-m32r-sdi.c
gdb/remote-mips.c
gdb/remote-sim.c
gdb/remote.c
gdb/rl78-tdep.c
gdb/rs6000-nat.c
gdb/rx-tdep.c
gdb/s390-nat.c
gdb/sol-thread.c
gdb/solib-darwin.c
gdb/solib-dsbt.c
gdb/solib-frv.c
gdb/solib-ia64-hpux.c
gdb/solib-irix.c
gdb/solib-pa64.c
gdb/solib-som.c
gdb/solib-spu.c
gdb/solib-sunos.c
gdb/solib-svr4.c
gdb/solib.c
gdb/spu-linux-nat.c
gdb/spu-multiarch.c
gdb/spu-tdep.c
gdb/symfile-mem.c
gdb/symfile.c
gdb/symtab.c
gdb/target-descriptions.c
gdb/target.c
gdb/target.h
gdb/tracepoint.c
gdb/windows-nat.c
gdb/windows-tdep.c
gdb/xcoffsolib.c

index 3a87a2c93e19c692553fa349efbd3a2c64a0832e..661985c4ee67fb9577f11e7bf0a552a81521785c 100644 (file)
@@ -1,3 +1,29 @@
+2012-11-09  Tom Tromey  <tromey@redhat.com>
+
+       * gdbarch.sh (target_gdbarch): Remove macro.
+       (get_target_gdbarch): Rename to target_gdbarch.
+       * gdbarch.c, gdbarch.h: Rebuild.
+       * ada-tasks.c, aix-thread.c, amd64-linux-nat.c, arch-utils.c,
+       arm-tdep.c, auxv.c, breakpoint.c, bsd-uthread.c, corefile.c,
+       darwin-nat-info.c, dcache.c, dsrec.c, exec.c, fbsd-nat.c,
+       filesystem.c, gcore.c, gnu-nat.c, i386-darwin-nat.c, i386-nat.c,
+       ia64-vms-tdep.c, inf-ptrace.c, infcmd.c, jit.c, linux-nat.c,
+       linux-tdep.c, linux-thread-db.c, m32r-rom.c, memattr.c,
+       mep-tdep.c, microblaze-tdep.c, mips-linux-nat.c,
+       mips-linux-tdep.c, mips-tdep.c, monitor.c, moxie-tdep.c,
+       nto-procfs.c, nto-tdep.c, ppc-linux-nat.c, proc-service.c,
+       procfs.c, progspace.c, ravenscar-thread.c, record.c,
+       remote-m32r-sdi.c, remote-mips.c, remote-sim.c, remote.c,
+       rl78-tdep.c, rs6000-nat.c, rx-tdep.c, s390-nat.c, sol-thread.c,
+       solib-darwin.c, solib-dsbt.c, solib-frv.c, solib-ia64-hpux.c,
+       solib-irix.c, solib-pa64.c, solib-som.c, solib-spu.c,
+       solib-sunos.c, solib-svr4.c, solib.c, spu-linux-nat.c,
+       spu-multiarch.c, spu-tdep.c, symfile-mem.c, symfile.c, symtab.c,
+       target-descriptions.c, target.c, target.h, tracepoint.c,
+       windows-nat.c, windows-tdep.c, xcoffsolib.c, cli/cli-dump.c,
+       common/agent.c, mi/mi-interp.c, python/py-finishbreakpoint.c,
+       python/py-inferior.c, python/python.c: Update.
+
 2012-11-09  Andrew Burgess  <aburgess@broadcom.com>
 
        * source.c (print_source_lines_base): Add fullname field giving
index 0e441fbff6343cd569b337a6ed48b72469cca444..02ac6d0d07ba715da38cba5897efd72926309341 100644 (file)
@@ -893,7 +893,7 @@ ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
         contains debug information on the task type (due to implicit with of
         Ada.Tasking).  */
       data->known_tasks_element =
-       builtin_type (target_gdbarch)->builtin_data_ptr;
+       builtin_type (target_gdbarch ())->builtin_data_ptr;
       data->known_tasks_length = MAX_NUMBER_OF_KNOWN_TASKS;
       return;
     }
@@ -924,7 +924,7 @@ ada_tasks_inferior_data_sniffer (struct ada_tasks_inferior_data *data)
 
       /* Fallback to default values.  */
       data->known_tasks_element =
-       builtin_type (target_gdbarch)->builtin_data_ptr;
+       builtin_type (target_gdbarch ())->builtin_data_ptr;
       data->known_tasks_length = 1;
       return;
     }
@@ -1173,7 +1173,7 @@ info_task (struct ui_out *uiout, char *taskno_str, struct inferior *inf)
 
   /* Print the Ada task ID.  */
   printf_filtered (_("Ada Task: %s\n"),
-                  paddress (target_gdbarch, task_info->task_id));
+                  paddress (target_gdbarch (), task_info->task_id));
 
   /* Print the name of the task.  */
   if (task_info->name[0] != '\0')
index c7d73eb45a272dcbfa1d66575ffc3f7926118d84..5da6c4eadbc8c7ddcb0c596c9c060d5fd045e590 100644 (file)
@@ -887,7 +887,7 @@ pd_enable (void)
     return;
 
   /* Check application word size.  */
-  arch64 = register_size (target_gdbarch, 0) == 8;
+  arch64 = register_size (target_gdbarch (), 0) == 8;
 
   /* Check whether the application is pthreaded.  */
   stub_name = NULL;
@@ -901,7 +901,7 @@ pd_enable (void)
   if (!(ms = lookup_minimal_symbol (stub_name, NULL, NULL)))
     return;
   pd_brk_addr = SYMBOL_VALUE_ADDRESS (ms);
-  if (!create_thread_event_breakpoint (target_gdbarch, pd_brk_addr))
+  if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr))
     return;
 
   /* Prepare for thread debugging.  */
index 01982acf17c26fd840eeafcc281db0ec9a429c5c..f4a12db176d4148d81f55ce586cd9b3dbc485495 100644 (file)
@@ -443,7 +443,7 @@ ps_err_e
 ps_get_thread_area (const struct ps_prochandle *ph,
                     lwpid_t lwpid, int idx, void **base)
 {
-  if (gdbarch_bfd_arch_info (target_gdbarch)->bits_per_word == 32)
+  if (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word == 32)
     {
       /* The full structure is found in <asm-i386/ldt.h>.  The second
         integer is the LDT's base_address and that is used to locate
index f4414b91ddaa9fc5db891ffb84258dda435f5d59..71d17cf591d892810238f3cd4dedf848378fabad 100644 (file)
@@ -506,7 +506,7 @@ gdbarch_update_p (struct gdbarch_info info)
 
   /* If it is the same old architecture, accept the request (but don't
      swap anything).  */
-  if (new_gdbarch == target_gdbarch)
+  if (new_gdbarch == target_gdbarch ())
     {
       if (gdbarch_debug)
        fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: "
@@ -757,7 +757,7 @@ get_current_arch (void)
   if (has_stack_frames ())
     return get_frame_arch (get_selected_frame (NULL));
   else
-    return target_gdbarch;
+    return target_gdbarch ();
 }
 
 int
index fbc2479bc6754dad7941150339e777c4ff6f8572..1a6736642eb8f84359322caee998ca0379170259 100644 (file)
@@ -9195,7 +9195,7 @@ arm_update_current_architecture (void)
   struct gdbarch_info info;
 
   /* If the current architecture is not ARM, we have nothing to do.  */
-  if (gdbarch_bfd_arch_info (target_gdbarch)->arch != bfd_arch_arm)
+  if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_arm)
     return;
 
   /* Update the architecture.  */
@@ -9229,10 +9229,10 @@ static void
 show_fp_model (struct ui_file *file, int from_tty,
               struct cmd_list_element *c, const char *value)
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch ());
 
   if (arm_fp_model == ARM_FLOAT_AUTO
-      && gdbarch_bfd_arch_info (target_gdbarch)->arch == bfd_arch_arm)
+      && gdbarch_bfd_arch_info (target_gdbarch ())->arch == bfd_arch_arm)
     fprintf_filtered (file, _("\
 The current ARM floating point model is \"auto\" (currently \"%s\").\n"),
                      fp_model_strings[tdep->fp_model]);
@@ -9266,10 +9266,10 @@ static void
 arm_show_abi (struct ui_file *file, int from_tty,
             struct cmd_list_element *c, const char *value)
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch ());
 
   if (arm_abi_global == ARM_ABI_AUTO
-      && gdbarch_bfd_arch_info (target_gdbarch)->arch == bfd_arch_arm)
+      && gdbarch_bfd_arch_info (target_gdbarch ())->arch == bfd_arch_arm)
     fprintf_filtered (file, _("\
 The current ARM ABI is \"auto\" (currently \"%s\").\n"),
                      arm_abi_strings[tdep->arm_abi]);
@@ -9292,7 +9292,7 @@ static void
 arm_show_force_mode (struct ui_file *file, int from_tty,
                     struct cmd_list_element *c, const char *value)
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch ());
 
   fprintf_filtered (file,
                    _("The current execution mode assumed "
index 62628c60f83ade3eeb2d0667a9b256c349d17169..e2aeb214388a636f9a434e873fab158201d77618 100644 (file)
@@ -76,7 +76,7 @@ ld_so_xfer_auxv (gdb_byte *readbuf,
 {
   struct minimal_symbol *msym;
   CORE_ADDR data_address, pointer_address;
-  struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
   size_t ptr_size = TYPE_LENGTH (ptr_type);
   size_t auxv_pair_size = 2 * ptr_size;
   gdb_byte *ptr_buf = alloca (ptr_size);
@@ -240,9 +240,9 @@ static int
 default_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
                   gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 {
-  const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch)
+  const int sizeof_auxv_field = gdbarch_ptr_bit (target_gdbarch ())
                                / TARGET_CHAR_BIT;
-  const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  const enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   gdb_byte *ptr = *readptr;
 
   if (endptr == ptr)
@@ -479,7 +479,7 @@ fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
          fprintf_filtered (file, "%s\n", plongest (val));
          break;
        case hex:
-         fprintf_filtered (file, "%s\n", paddress (target_gdbarch, val));
+         fprintf_filtered (file, "%s\n", paddress (target_gdbarch (), val));
          break;
        case str:
          {
@@ -487,8 +487,8 @@ fprint_target_auxv (struct ui_file *file, struct target_ops *ops)
 
            get_user_print_options (&opts);
            if (opts.addressprint)
-             fprintf_filtered (file, "%s ", paddress (target_gdbarch, val));
-           val_print_string (builtin_type (target_gdbarch)->builtin_char,
+             fprintf_filtered (file, "%s ", paddress (target_gdbarch (), val));
+           val_print_string (builtin_type (target_gdbarch ())->builtin_char,
                              NULL, val, -1, file, &opts);
            fprintf_filtered (file, "\n");
          }
index 3763a04247518d110cb98ce25a38f9d4f4ac2640..d47544bcf1d3cd7d2467550cfe080987be56804a 100644 (file)
@@ -2792,7 +2792,7 @@ update_inserted_breakpoint_locations (void)
         to select an inferior to insert breakpoint to.  In fact, even
         if we aren't attached to any process yet, we should still
         insert breakpoints.  */
-      if (!gdbarch_has_global_breakpoints (target_gdbarch)
+      if (!gdbarch_has_global_breakpoints (target_gdbarch ())
          && ptid_equal (inferior_ptid, null_ptid))
        continue;
 
@@ -2851,7 +2851,7 @@ insert_breakpoint_locations (void)
         to select an inferior to insert breakpoint to.  In fact, even
         if we aren't attached to any process yet, we should still
         insert breakpoints.  */
-      if (!gdbarch_has_global_breakpoints (target_gdbarch)
+      if (!gdbarch_has_global_breakpoints (target_gdbarch ())
          && ptid_equal (inferior_ptid, null_ptid))
        continue;
 
@@ -3732,7 +3732,7 @@ breakpoint_init_inferior (enum inf_context context)
 
   /* If breakpoint locations are shared across processes, then there's
      nothing to do.  */
-  if (gdbarch_has_global_breakpoints (target_gdbarch))
+  if (gdbarch_has_global_breakpoints (target_gdbarch ()))
     return;
 
   ALL_BP_LOCATIONS (bl, blp_tmp)
@@ -5936,7 +5936,7 @@ print_one_breakpoint_location (struct breakpoint *b,
   if (loc != NULL
       && !header_of_multiple
       && (allflag
-         || (!gdbarch_has_global_breakpoints (target_gdbarch)
+         || (!gdbarch_has_global_breakpoints (target_gdbarch ())
              && (number_of_program_spaces () > 1
                  || number_of_inferiors () > 1)
              /* LOC is for existing B, it cannot be in
@@ -6596,7 +6596,7 @@ static int
 breakpoint_address_match (struct address_space *aspace1, CORE_ADDR addr1,
                          struct address_space *aspace2, CORE_ADDR addr2)
 {
-  return ((gdbarch_has_global_breakpoints (target_gdbarch)
+  return ((gdbarch_has_global_breakpoints (target_gdbarch ())
           || aspace1 == aspace2)
          && addr1 == addr2);
 }
@@ -6611,7 +6611,7 @@ breakpoint_address_match_range (struct address_space *aspace1, CORE_ADDR addr1,
                                int len1, struct address_space *aspace2,
                                CORE_ADDR addr2)
 {
-  return ((gdbarch_has_global_breakpoints (target_gdbarch)
+  return ((gdbarch_has_global_breakpoints (target_gdbarch ())
           || aspace1 == aspace2)
          && addr2 >= addr1 && addr2 < addr1 + len1);
 }
@@ -12529,7 +12529,7 @@ update_global_location_list (int should_insert)
 
   if (breakpoints_always_inserted_mode ()
       && (have_live_inferiors ()
-         || (gdbarch_has_global_breakpoints (target_gdbarch))))
+         || (gdbarch_has_global_breakpoints (target_gdbarch ()))))
     {
       if (should_insert)
        insert_breakpoint_locations ();
index 948af8fb52b2e87ab5d763706bba0a00b5908725..fed14d54b842b75b6d9591fe07da6a973cb41e69 100644 (file)
@@ -93,7 +93,7 @@ bsd_uthread_set_collect_uthread (struct gdbarch *gdbarch,
 static void
 bsd_uthread_check_magic (CORE_ADDR addr)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   ULONGEST magic = read_memory_unsigned_integer (addr, 4, byte_order);
 
   if (magic != BSD_UTHREAD_PTHREAD_MAGIC)
@@ -137,7 +137,7 @@ bsd_uthread_lookup_address (const char *name, struct objfile *objfile)
 static int
 bsd_uthread_lookup_offset (const char *name, struct objfile *objfile)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   CORE_ADDR addr;
 
   addr = bsd_uthread_lookup_address (name, objfile);
@@ -150,7 +150,7 @@ bsd_uthread_lookup_offset (const char *name, struct objfile *objfile)
 static CORE_ADDR
 bsd_uthread_read_memory_address (CORE_ADDR addr)
 {
-  struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
   return read_memory_typed_address (addr, ptr_type);
 }
 
@@ -161,7 +161,7 @@ bsd_uthread_read_memory_address (CORE_ADDR addr)
 static int
 bsd_uthread_activate (struct objfile *objfile)
 {
-  struct gdbarch *gdbarch = target_gdbarch;
+  struct gdbarch *gdbarch = target_gdbarch ();
   struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
 
   /* Skip if the thread stratum has already been activated.  */
@@ -349,7 +349,7 @@ static ptid_t
 bsd_uthread_wait (struct target_ops *ops,
                  ptid_t ptid, struct target_waitstatus *status, int options)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   CORE_ADDR addr;
   struct target_ops *beneath = find_target_beneath (ops);
 
@@ -407,7 +407,7 @@ bsd_uthread_resume (struct target_ops *ops,
 static int
 bsd_uthread_thread_alive (struct target_ops *ops, ptid_t ptid)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   struct target_ops *beneath = find_target_beneath (ops);
   CORE_ADDR addr = ptid_get_tid (inferior_ptid);
 
@@ -484,7 +484,7 @@ static char *bsd_uthread_state[] =
 static char *
 bsd_uthread_extra_thread_info (struct thread_info *info)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   CORE_ADDR addr = ptid_get_tid (info->ptid);
 
   if (addr != 0)
index dd9c3b86009fb4bb06e0e49ecb12d01b46f27107..c2d1397ba72bf8723c4b46229fc44ece7f69a969 100644 (file)
@@ -486,10 +486,10 @@ restore_section_callback (bfd *ibfd, asection *isec, void *args)
 
   if (data->load_offset != 0 || data->load_start != 0 || data->load_end != 0)
     printf_filtered (" into memory (%s to %s)\n",
-                    paddress (target_gdbarch,
+                    paddress (target_gdbarch (),
                               (unsigned long) sec_start
                               + sec_offset + data->load_offset), 
-                    paddress (target_gdbarch,
+                    paddress (target_gdbarch (),
                               (unsigned long) sec_start + sec_offset
                                + data->load_offset + sec_load_count));
   else
index 43f1b65e78145ac4a6c42257d5eab24c8d5d0152..156b15485b1fe12f47ef806851ee4bc3529307ed 100644 (file)
@@ -125,7 +125,7 @@ agent_get_helper_thread_id (void)
                                (unsigned char *) &helper_thread_id,
                                sizeof helper_thread_id))
 #else
-      enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+      enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
       gdb_byte buf[4];
 
       if (target_read_memory (ipa_sym_addrs.addr_helper_thread_id,
@@ -332,7 +332,7 @@ agent_capability_check (enum agent_capa agent_capa)
                                (unsigned char *) &agent_capability,
                                sizeof agent_capability))
 #else
-      enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+      enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
       gdb_byte buf[4];
 
       if (target_read_memory (ipa_sym_addrs.addr_capability,
index a2ed24f008598edf328b77625a148ad739140f77..78dbbc2b86da3e0b332800b1ef5ec822ccd550bd 100644 (file)
@@ -203,11 +203,11 @@ memory_error (int status, CORE_ADDR memaddr)
        bounds.  */
     throw_error (MEMORY_ERROR,
                 _("Cannot access memory at address %s"),
-                paddress (target_gdbarch, memaddr));
+                paddress (target_gdbarch (), memaddr));
   else
     throw_error (MEMORY_ERROR,
                 _("Error accessing memory address %s: %s."),
-                paddress (target_gdbarch, memaddr),
+                paddress (target_gdbarch (), memaddr),
                 safe_strerror (status));
 }
 
index 9741538f91873122fe17f0467e420725286a0f49..67e73e6fac5417a61c1ffd6f5e82bf5582dde984 100644 (file)
@@ -573,8 +573,8 @@ darwin_debug_regions (task_t task, mach_vm_address_t address, int max)
       if (print)
         {
           printf_filtered (_("%s-%s %s/%s  %s %s %s"),
-                           paddress (target_gdbarch, prev_address),
-                           paddress (target_gdbarch, 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),
@@ -623,7 +623,7 @@ darwin_debug_regions_recurse (task_t task)
 
   table_chain = make_cleanup_ui_out_table_begin_end (uiout, 9, -1, "regions");
 
-  if (gdbarch_addr_bit (target_gdbarch) <= 32)
+  if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
     {
       ui_out_table_header (uiout, 10, ui_left, "start", "Start");
       ui_out_table_header (uiout, 10, ui_left, "end", "End");
@@ -659,8 +659,8 @@ darwin_debug_regions_recurse (task_t task)
        break;
       row_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "regions-row");
 
-      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_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 652cfab9e091e86723e2beef7f797bd4d908641e..ce9fe31906a484535e92f404a3b8a32e3186e73c 100644 (file)
@@ -589,7 +589,7 @@ dcache_print_line (int index)
   db = (struct dcache_block *) n->value;
 
   printf_filtered (_("Line %d: address %s [%d hits]\n"),
-                  index, paddress (target_gdbarch, db->addr), db->refs);
+                  index, paddress (target_gdbarch (), db->addr), db->refs);
 
   for (j = 0; j < last_cache->line_size; j++)
     {
@@ -647,7 +647,7 @@ dcache_info (char *exp, int tty)
       struct dcache_block *db = (struct dcache_block *) n->value;
 
       printf_filtered (_("Line %d: address %s [%d hits]\n"),
-                      i, paddress (target_gdbarch, db->addr), db->refs);
+                      i, paddress (target_gdbarch (), db->addr), db->refs);
       i++;
       refcount += db->refs;
 
index 20ff33938587e941f443812839424a8d58c05e2f..9ea23c0aec23cbf1b7b9347a87bb3a79fd625d8f 100644 (file)
@@ -104,8 +104,8 @@ load_srec (struct serial *desc, const char *file, bfd_vma load_offset,
            have also been used.  cagney 1999-09-01 */
        printf_filtered ("%s\t: %s .. %s  ",
                         section_name,
-                        paddress (target_gdbarch, addr),
-                        paddress (target_gdbarch, addr + size));
+                        paddress (target_gdbarch (), addr),
+                        paddress (target_gdbarch (), addr + size));
        gdb_flush (gdb_stdout);
 
        data_count += size;
@@ -259,7 +259,7 @@ make_srec (char *srec, CORE_ADDR targ_addr, bfd *abfd, asection *sect,
   else
     internal_error (__FILE__, __LINE__,
                    _("make_srec:  Bad address (%s), or bad flags (0x%x)."),
-                   paddress (target_gdbarch, targ_addr), flags);
+                   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 2bd31816f9a0229ec06871e326f31dc5d5af0096..615d5c097ed20e4116a9628077e0dae2299d09c6 100644 (file)
@@ -767,7 +767,7 @@ exec_files_info (struct target_ops *t)
 
   if (vmap)
     {
-      int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
+      int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
       struct vmap *vp;
 
       printf_unfiltered (_("\tMapping info for file `%s'.\n"), vmap->name);
index 4a8a50915c35ffe86277b39340fcf5c964f0f67f..254a01a25ba44b43f987fc4393709051c8a36247 100644 (file)
@@ -125,7 +125,7 @@ fbsd_find_memory_regions (find_memory_region_ftype func, void *obfd)
        {
          fprintf_filtered (gdb_stdout, 
                            "Save segment, %ld bytes at %s (%c%c%c)\n",
-                           size, paddress (target_gdbarch, start),
+                           size, paddress (target_gdbarch (), start),
                            read ? 'r' : '-',
                            write ? 'w' : '-',
                            exec ? 'x' : '-');
index d855b7511c9bb9f2876a958183410a9baa325ff0..5b4b0cf3c9804100db3f1cebfd97f92b622c4b09 100644 (file)
@@ -39,7 +39,7 @@ effective_target_file_system_kind (void)
 {
   if (target_file_system_kind == file_system_kind_auto)
     {
-      if (gdbarch_has_dos_based_file_system (target_gdbarch))
+      if (gdbarch_has_dos_based_file_system (target_gdbarch ()))
        return file_system_kind_dos_based;
       else
        return file_system_kind_unix;
index 3c8e2f43fbd9e99400bc12829a14469e514f65e7..566798277e04dc736999e4ebce610567db1015cf 100644 (file)
@@ -75,10 +75,10 @@ write_gcore_file (bfd *obfd)
   /* FIXME: uweigand/2011-10-06: All architectures that support core file
      generation should be converted to gdbarch_make_corefile_notes; at that
      point, the target vector method can be removed.  */
-  if (!gdbarch_make_corefile_notes_p (target_gdbarch))
+  if (!gdbarch_make_corefile_notes_p (target_gdbarch ()))
     note_data = target_make_corefile_notes (obfd, &note_size);
   else
-    note_data = gdbarch_make_corefile_notes (target_gdbarch, obfd, &note_size);
+    note_data = gdbarch_make_corefile_notes (target_gdbarch (), obfd, &note_size);
 
   if (note_data == NULL || note_size == 0)
     error (_("Target does not support core file generation."));
@@ -165,7 +165,7 @@ default_gcore_mach (void)
   return 0;
 #else
 
-  const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (target_gdbarch);
+  const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (target_gdbarch ());
 
   if (bfdarch != NULL)
     return bfdarch->mach;
@@ -179,7 +179,7 @@ default_gcore_mach (void)
 static enum bfd_architecture
 default_gcore_arch (void)
 {
-  const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (target_gdbarch);
+  const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (target_gdbarch ());
 
   if (bfdarch != NULL)
     return bfdarch->arch;
@@ -193,8 +193,8 @@ static const char *
 default_gcore_target (void)
 {
   /* The gdbarch may define a target to use for core files.  */
-  if (gdbarch_gcore_bfd_target_p (target_gdbarch))
-    return gdbarch_gcore_bfd_target (target_gdbarch);
+  if (gdbarch_gcore_bfd_target_p (target_gdbarch ()))
+    return gdbarch_gcore_bfd_target (target_gdbarch ());
 
   /* Otherwise, try to fall back to the exec_bfd target.  This will probably
      not work for non-ELF targets.  */
@@ -398,7 +398,7 @@ gcore_create_callback (CORE_ADDR vaddr, unsigned long size, int read,
       if (info_verbose)
         {
           fprintf_filtered (gdb_stdout, "Ignore segment, %s bytes at %s\n",
-                            plongest (size), paddress (target_gdbarch, vaddr));
+                            plongest (size), paddress (target_gdbarch (), vaddr));
         }
 
       return 0;
@@ -458,7 +458,7 @@ gcore_create_callback (CORE_ADDR vaddr, unsigned long size, int read,
   if (info_verbose)
     {
       fprintf_filtered (gdb_stdout, "Save segment, %s bytes at %s\n",
-                       plongest (size), paddress (target_gdbarch, vaddr));
+                       plongest (size), paddress (target_gdbarch (), vaddr));
     }
 
   bfd_set_section_size (obfd, osec, size);
@@ -554,7 +554,7 @@ gcore_copy_callback (bfd *obfd, asection *osec, void *ignored)
          warning (_("Memory read failed for corefile "
                     "section, %s bytes at %s."),
                   plongest (size),
-                  paddress (target_gdbarch, bfd_section_vma (obfd, osec)));
+                  paddress (target_gdbarch (), bfd_section_vma (obfd, osec)));
          break;
        }
       if (!bfd_set_section_contents (obfd, osec, memhunk, offset, size))
@@ -575,8 +575,8 @@ static int
 gcore_memory_sections (bfd *obfd)
 {
   /* Try gdbarch method first, then fall back to target method.  */
-  if (!gdbarch_find_memory_regions_p (target_gdbarch)
-      || gdbarch_find_memory_regions (target_gdbarch,
+  if (!gdbarch_find_memory_regions_p (target_gdbarch ())
+      || gdbarch_find_memory_regions (target_gdbarch (),
                                      gcore_create_callback, obfd) != 0)
     {
       if (target_find_memory_regions (gcore_create_callback, obfd) != 0)
index 25e47506809c38cbe8cc184c4140d85730112f77..26dd4043a609532b967915d9f01747f3d3a81244 100644 (file)
@@ -4675,10 +4675,10 @@ deprecated_target_gdbarch_select_hack (struct gdbarch *new_gdbarch)
   registers_changed ();
 }
 
-/* Helper for 'target_gdbarch'.  */
+/* Return the current inferior's arch.  */
 
 struct gdbarch *
-get_target_gdbarch (void)
+target_gdbarch (void)
 {
   return current_inferior ()->gdbarch;
 }
index 5afb3db57cb0447466edf29842601dd6513a4fbc..9d2bac398148815c180f4d7bb87251d381a9d789 100644 (file)
@@ -71,8 +71,7 @@ struct stap_parse_info;
    gdbarch.  */
 
 /* This is a convenience wrapper for 'current_inferior ()->gdbarch'.  */
-#define target_gdbarch get_target_gdbarch ()
-extern struct gdbarch *get_target_gdbarch (void);
+extern struct gdbarch *target_gdbarch (void);
 
 /* The initial, default architecture.  It uses host values (for want of a better
    choice).  */
index 13d5cc6539cb9485864bc51ebfa28d8fb85e2bff..53a52b1fcebcba172f99eaa8a289b31dfa25f386 100755 (executable)
@@ -1089,8 +1089,7 @@ struct stap_parse_info;
    gdbarch.  */
 
 /* This is a convenience wrapper for 'current_inferior ()->gdbarch'.  */
-#define target_gdbarch get_target_gdbarch ()
-extern struct gdbarch *get_target_gdbarch (void);
+extern struct gdbarch *target_gdbarch (void);
 
 /* The initial, default architecture.  It uses host values (for want of a better
    choice).  */
@@ -2291,10 +2290,10 @@ deprecated_target_gdbarch_select_hack (struct gdbarch *new_gdbarch)
   registers_changed ();
 }
 
-/* Helper for 'target_gdbarch'.  */
+/* Return the current inferior's arch.  */
 
 struct gdbarch *
-get_target_gdbarch (void)
+target_gdbarch (void)
 {
   return current_inferior ()->gdbarch;
 }
index b34935e8e1e2b96bbfd8a75bfde58de544585220..e6836d73f2e9efe35b0beb9dc5d50d3049d80888 100644 (file)
@@ -2491,7 +2491,7 @@ gnu_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
     {
       inf_debug (gnu_current_inf, "%s %s[%d] %s %s",
                 write ? "writing" : "reading",
-                paddress (target_gdbarch, memaddr), len,
+                paddress (target_gdbarch (), memaddr), len,
                 write ? "<--" : "-->", host_address_to_string (myaddr));
       if (write)
        return gnu_write_inferior (task, memaddr, myaddr, len);
index 6afbbd0beceb89ba358b4c36bf12be5cafbb135f..4680d9457d9dfaf1fcb985ad6398686b801e7f3e 100644 (file)
@@ -415,7 +415,7 @@ i386_darwin_dr_get_control (void)
 void
 darwin_check_osabi (darwin_inferior *inf, thread_t thread)
 {
-  if (gdbarch_osabi (target_gdbarch) == GDB_OSABI_UNKNOWN)
+  if (gdbarch_osabi (target_gdbarch ()) == GDB_OSABI_UNKNOWN)
     {
       /* Attaching to a process.  Let's figure out what kind it is.  */
       x86_thread_state_t gp_regs;
@@ -433,7 +433,7 @@ darwin_check_osabi (darwin_inferior *inf, thread_t thread)
 
       gdbarch_info_init (&info);
       gdbarch_info_fill (&info);
-      info.byte_order = gdbarch_byte_order (target_gdbarch);
+      info.byte_order = gdbarch_byte_order (target_gdbarch ());
       info.osabi = GDB_OSABI_DARWIN;
       if (gp_regs.tsh.flavor == x86_THREAD_STATE64)
        info.bfd_arch_info = bfd_lookup_arch (bfd_arch_i386,
@@ -457,7 +457,7 @@ darwin_check_osabi (darwin_inferior *inf, thread_t thread)
 static int
 i386_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   static const gdb_byte darwin_syscall[] = { 0xcd, 0x80 }; /* int 0x80 */
   gdb_byte buf[sizeof (darwin_syscall)];
 
@@ -490,7 +490,7 @@ i386_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
 static int
 amd64_darwin_sstep_at_sigreturn (x86_thread_state_t *regs)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   static const gdb_byte darwin_syscall[] = { 0x0f, 0x05 }; /* syscall */
   gdb_byte buf[sizeof (darwin_syscall)];
 
index 559bc29b44d5c7b69885fe98fef9709bfd2d17b8..1d4d620c178cfe179cc982b6ef554782c3f330a4 100644 (file)
@@ -318,7 +318,7 @@ i386_show_dr (struct i386_debug_reg_state *state,
              const char *func, CORE_ADDR addr,
              int len, enum target_hw_bp_type type)
 {
-  int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
+  int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
   int i;
 
   puts_unfiltered (func);
index 09238fcb3d1fe801af5afe4c06bcb9440a1e47a4..9f477df3a707b1abc9424852a16377512097dc01 100644 (file)
@@ -33,7 +33,7 @@ ia64_vms_find_proc_info_x (unw_addr_space_t as, unw_word_t ip,
                            unw_proc_info_t *pi,
                            int need_unwind_info, void *arg)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   unw_dyn_info_t di;
   int ret;
   gdb_byte buf[32];
index e6729ac5679c05ca1b5484b28528c6c86367347a..740798fbd0a1fe7387d798b8babab3d524a619be 100644 (file)
@@ -649,11 +649,11 @@ static int
 inf_ptrace_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
                       gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 {
-  struct type *int_type = builtin_type (target_gdbarch)->builtin_int;
-  struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+  struct type *int_type = builtin_type (target_gdbarch ())->builtin_int;
+  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
   const int sizeof_auxv_type = TYPE_LENGTH (int_type);
   const int sizeof_auxv_val = TYPE_LENGTH (ptr_type);
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   gdb_byte *ptr = *readptr;
 
   if (endptr == ptr)
index fd035df9055faedbffe18119836b01ec0c2f2670..c3e602b4fadc2fc12e496b6783d43f901627e959 100644 (file)
@@ -469,7 +469,7 @@ post_create_inferior (struct target_ops *target, int from_tty)
 
          /* If the solist is global across processes, there's no need to
             refetch it here.  */
-         if (!gdbarch_has_global_solist (target_gdbarch))
+         if (!gdbarch_has_global_solist (target_gdbarch ()))
            {
 #ifdef SOLIB_ADD
              SOLIB_ADD (NULL, 0, target, auto_solib_add);
@@ -1839,7 +1839,7 @@ program_info (char *args, int from_tty)
 
   target_files_info ();
   printf_filtered (_("Program stopped at %s.\n"),
-                  paddress (target_gdbarch, stop_pc));
+                  paddress (target_gdbarch (), stop_pc));
   if (tp->control.stop_step)
     printf_filtered (_("It stopped after being stepped.\n"));
   else if (stat != 0)
@@ -2542,7 +2542,7 @@ attach_command (char *args, int from_tty)
 
   dont_repeat ();              /* Not for the faint of heart */
 
-  if (gdbarch_has_global_solist (target_gdbarch))
+  if (gdbarch_has_global_solist (target_gdbarch ()))
     /* Don't complain if all processes share the same symbol
        space.  */
     ;
@@ -2732,7 +2732,7 @@ detach_command (char *args, int from_tty)
 
   /* If the solist is global across inferiors, don't clear it when we
      detach from a single inferior.  */
-  if (!gdbarch_has_global_solist (target_gdbarch))
+  if (!gdbarch_has_global_solist (target_gdbarch ()))
     no_shared_libraries (NULL, from_tty);
 
   /* If we still have inferiors to debug, then don't mess with their
index 9e8f295c8137738b408969e7356f5b5b0276d5a7..2dcafbcd142c3c5c2e88e7dc2d0431d2274816aa 100644 (file)
--- a/gdb/jit.c
+++ b/gdb/jit.c
@@ -757,7 +757,7 @@ jit_object_close_impl (struct gdb_symbol_callbacks *cb,
   priv_data = cb->priv_data;
 
   objfile = allocate_objfile (NULL, 0);
-  objfile->gdbarch = target_gdbarch;
+  objfile->gdbarch = target_gdbarch ();
 
   terminate_minimal_symbol_table (objfile);
 
@@ -1290,7 +1290,7 @@ jit_inferior_init (struct gdbarch *gdbarch)
 void
 jit_inferior_created_hook (void)
 {
-  jit_inferior_init (target_gdbarch);
+  jit_inferior_init (target_gdbarch ());
 }
 
 /* Exported routine to call to re-set the jit breakpoints,
@@ -1299,7 +1299,7 @@ jit_inferior_created_hook (void)
 void
 jit_breakpoint_re_set (void)
 {
-  jit_breakpoint_re_set_internal (target_gdbarch,
+  jit_breakpoint_re_set_internal (target_gdbarch (),
                                  get_jit_inferior_data ());
 }
 
index c282e5d2abf3f1a74f411473ef4edae375dd63e7..45f7e240600284c2c4b15436cbcce44f1d5320a4 100644 (file)
@@ -4376,7 +4376,7 @@ linux_nat_make_corefile_notes (bfd *obfd, int *note_size)
 {
   /* FIXME: uweigand/2011-10-06: Once all GNU/Linux architectures have been
      converted to gdbarch_core_regset_sections, this function can go away.  */
-  return linux_make_corefile_notes (target_gdbarch, obfd, note_size,
+  return linux_make_corefile_notes (target_gdbarch (), obfd, note_size,
                                    linux_nat_collect_thread_registers);
 }
 
@@ -4431,7 +4431,7 @@ linux_proc_xfer_partial (struct target_ops *ops, enum target_object object,
 static LONGEST
 spu_enumerate_spu_ids (int pid, gdb_byte *buf, ULONGEST offset, LONGEST len)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   LONGEST pos = 0;
   LONGEST written = 0;
   char path[128];
@@ -4640,7 +4640,7 @@ linux_xfer_partial (struct target_ops *ops, enum target_object object,
 
   if (object == TARGET_OBJECT_MEMORY)
     {
-      int addr_bit = gdbarch_addr_bit (target_gdbarch);
+      int addr_bit = gdbarch_addr_bit (target_gdbarch ());
 
       if (addr_bit < (sizeof (ULONGEST) * HOST_CHAR_BIT))
        offset &= ((ULONGEST) 1 << addr_bit) - 1;
index f02d51031e9cfd0719e8ca8b618a0211f5f68c1e..dbeed360f5490cf3805249dde8f7d06bb414d788 100644 (file)
@@ -667,7 +667,7 @@ linux_spu_make_corefile_notes (bfd *obfd, char *note_data, int *note_size)
       "proxydma_info",
    };
 
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   gdb_byte *spu_ids;
   LONGEST i, j, size;
 
index bd905274301e929be756fb6eedf06470b8e74348..c52ab15bd8aac63c3faec613576d1e64e566bbc3 100644 (file)
@@ -544,13 +544,13 @@ enable_thread_event (int event, CORE_ADDR *bp)
   /* Set up the breakpoint.  */
   gdb_assert (exec_bfd);
   (*bp) = (gdbarch_convert_from_func_ptr_addr
-          (target_gdbarch,
+          (target_gdbarch (),
            /* Do proper sign extension for the target.  */
            (bfd_get_sign_extend_vma (exec_bfd) > 0
             ? (CORE_ADDR) (intptr_t) notify.u.bptaddr
             : (CORE_ADDR) (uintptr_t) notify.u.bptaddr),
            &current_target));
-  create_thread_event_breakpoint (target_gdbarch, *bp);
+  create_thread_event_breakpoint (target_gdbarch (), *bp);
 
   return TD_OK;
 }
index 4bb4cebde1489a9b55f96a6d3b139a3840525e49..f74cfe397ad79f9d48f5dd38f2d5c6af2bc2b7a9 100644 (file)
@@ -79,7 +79,7 @@ m32r_load_section (bfd *abfd, asection *s, void *obj)
   unsigned int *data_count = obj;
   if (s->flags & SEC_LOAD)
     {
-      int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
+      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;
@@ -89,7 +89,7 @@ m32r_load_section (bfd *abfd, asection *s, void *obj)
       printf_filtered ("Loading section %s, size 0x%lx lma ",
                       bfd_section_name (abfd, s),
                       (unsigned long) section_size);
-      fputs_filtered (paddress (target_gdbarch, 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", phex_nz (section_base, addr_size));
@@ -149,7 +149,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 (target_gdbarch, 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);
@@ -548,7 +548,7 @@ m32r_upload_command (char *args, int from_tty)
            printf_filtered ("Loading section %s, size 0x%lx lma ",
                             bfd_section_name (abfd, s),
                             (unsigned long) section_size);
-           fputs_filtered (paddress (target_gdbarch, section_base),
+           fputs_filtered (paddress (target_gdbarch (), section_base),
                            gdb_stdout);
            printf_filtered ("\n");
            gdb_flush (gdb_stdout);
index bd92f1d00882412473dc98fa56c87fceb5cd9f04..39c9b2229833c143ea6741908f54e16b39cd6e57 100644 (file)
@@ -431,10 +431,10 @@ mem_info_command (char *args, int from_tty)
   printf_filtered ("Num ");
   printf_filtered ("Enb ");
   printf_filtered ("Low Addr   ");
-  if (gdbarch_addr_bit (target_gdbarch) > 32)
+  if (gdbarch_addr_bit (target_gdbarch ()) > 32)
     printf_filtered ("        ");
   printf_filtered ("High Addr  ");
-  if (gdbarch_addr_bit (target_gdbarch) > 32)
+  if (gdbarch_addr_bit (target_gdbarch ()) > 32)
     printf_filtered ("        ");
   printf_filtered ("Attrs ");
   printf_filtered ("\n");
@@ -446,14 +446,14 @@ mem_info_command (char *args, int from_tty)
       printf_filtered ("%-3d %-3c\t",
                       m->number,
                       m->enabled_p ? 'y' : 'n');
-      if (gdbarch_addr_bit (target_gdbarch) <= 32)
+      if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
        tmp = hex_string_custom ((unsigned long) m->lo, 8);
       else
        tmp = hex_string_custom ((unsigned long) m->lo, 16);
       
       printf_filtered ("%s ", tmp);
 
-      if (gdbarch_addr_bit (target_gdbarch) <= 32)
+      if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
        {
          if (m->hi == 0)
            tmp = "0x100000000";
index c73d38f9fea6f6dec8f1bae77fa73cb232a32ae4..7d00445859ad447a9932b605bda0af19b7e1b2f2 100644 (file)
@@ -263,7 +263,7 @@ me_module_register_set (CONFIG_ATTR me_module,
        mask contains any of the me_module's coprocessor ISAs,
        specifically excluding the generic coprocessor register sets.  */
 
-  CGEN_CPU_DESC desc = gdbarch_tdep (target_gdbarch)->cpu_desc;
+  CGEN_CPU_DESC desc = gdbarch_tdep (target_gdbarch ())->cpu_desc;
   const CGEN_HW_ENTRY *hw;
 
   if (me_module == CONFIG_NONE)
@@ -854,7 +854,7 @@ current_me_module (void)
       return regval;
     }
   else
-    return gdbarch_tdep (target_gdbarch)->me_module;
+    return gdbarch_tdep (target_gdbarch ())->me_module;
 }
 
 
index d3c3d8133ed21551b42127336c73f15654632b00..993f8b00264a821516e801f474138a17621bba5b 100644 (file)
@@ -778,7 +778,7 @@ mi_solib_loaded (struct so_list *solib)
   struct mi_interp *mi = top_level_interpreter_data ();
 
   target_terminal_ours ();
-  if (gdbarch_has_global_solist (target_gdbarch))
+  if (gdbarch_has_global_solist (target_gdbarch ()))
     fprintf_unfiltered (mi->event_channel,
                        "library-loaded,id=\"%s\",target-name=\"%s\","
                        "host-name=\"%s\",symbols-loaded=\"%d\"",
@@ -802,7 +802,7 @@ mi_solib_unloaded (struct so_list *solib)
   struct mi_interp *mi = top_level_interpreter_data ();
 
   target_terminal_ours ();
-  if (gdbarch_has_global_solist (target_gdbarch))
+  if (gdbarch_has_global_solist (target_gdbarch ()))
     fprintf_unfiltered (mi->event_channel,
                        "library-unloaded,id=\"%s\",target-name=\"%s\","
                        "host-name=\"%s\"",
@@ -865,7 +865,7 @@ mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
   ui_out_redirect (mi_uiout, mi->event_channel);
 
   ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
-  ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch, memaddr);
+  ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
   ui_out_field_fmt (mi_uiout, "len", "0x%zx", len);
 
   /* Append 'type=code' into notification if MEMADDR falls in the range of
index 965840040194dd085782d87eb68400b88f7fd192..7427912d8998533fc11944a1c6273b3fcaf50783 100644 (file)
@@ -123,7 +123,7 @@ microblaze_register_type (struct gdbarch *gdbarch, int regnum)
 static unsigned long
 microblaze_fetch_instruction (CORE_ADDR pc)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   gdb_byte buf[4];
 
   /* If we can't read the instruction at PC, return zero.  */
index b9f7f1dc638fb8c57329d21e7927053312cf660c..bfcd0611af9a63d5c15f025b44a8af8d4d3c7439 100644 (file)
@@ -688,7 +688,7 @@ mips_show_dr (const char *func, CORE_ADDR addr,
   puts_unfiltered (func);
   if (addr || len)
     printf_unfiltered (" (addr=%s, len=%d, type=%s)",
-                      paddress (target_gdbarch, addr), len,
+                      paddress (target_gdbarch (), addr), len,
                       type == hw_write ? "data-write"
                       : (type == hw_read ? "data-read"
                          : (type == hw_access ? "data-read/write"
@@ -698,9 +698,9 @@ mips_show_dr (const char *func, CORE_ADDR addr,
 
   for (i = 0; i < MAX_DEBUG_REGISTER; i++)
     printf_unfiltered ("\tDR%d: lo=%s, hi=%s\n", i,
-                      paddress (target_gdbarch,
+                      paddress (target_gdbarch (),
                                 get_watchlo (&watch_mirror, i)),
-                      paddress (target_gdbarch,
+                      paddress (target_gdbarch (),
                                 get_watchhi (&watch_mirror, i)));
 }
 
index 272e8d99acad5a27b5eab298cf6625ab10e112e2..023290fcffb0d37cd460e892b85400f83695e84d 100644 (file)
@@ -682,8 +682,8 @@ mips_linux_in_dynsym_stub (CORE_ADDR pc, char *name)
 {
   unsigned char buf[28], *p;
   ULONGEST insn, insn1;
-  int n64 = (mips_abi (target_gdbarch) == MIPS_ABI_N64);
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  int n64 = (mips_abi (target_gdbarch ()) == MIPS_ABI_N64);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 
   read_memory (pc - 12, buf, 28);
 
index 2af4c898f0de765daa0a1c315c4330bab428159b..61f2cd209c7766367a0ff2c6fb77660680a106c2 100644 (file)
@@ -1087,7 +1087,7 @@ static void
 show_mask_address (struct ui_file *file, int from_tty,
                   struct cmd_list_element *c, const char *value)
 {
-  struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch);
+  struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch ());
 
   deprecated_show_value_hack (file, from_tty, c, value);
   switch (mask_address_var)
@@ -6652,7 +6652,7 @@ show_mipsfpu_command (char *args, int from_tty)
 {
   char *fpu;
 
-  if (gdbarch_bfd_arch_info (target_gdbarch)->arch != bfd_arch_mips)
+  if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_mips)
     {
       printf_unfiltered
        ("The MIPS floating-point coprocessor is unknown "
@@ -6660,7 +6660,7 @@ show_mipsfpu_command (char *args, int from_tty)
       return;
     }
 
-  switch (MIPS_FPU_TYPE (target_gdbarch))
+  switch (MIPS_FPU_TYPE (target_gdbarch ()))
     {
     case MIPS_FPU_SINGLE:
       fpu = "single-precision";
@@ -8681,7 +8681,7 @@ show_mips_abi (struct ui_file *file,
               struct cmd_list_element *ignored_cmd,
               const char *ignored_value)
 {
-  if (gdbarch_bfd_arch_info (target_gdbarch)->arch != bfd_arch_mips)
+  if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_mips)
     fprintf_filtered
       (file, 
        "The MIPS ABI is unknown because the current architecture "
@@ -8689,7 +8689,7 @@ show_mips_abi (struct ui_file *file,
   else
     {
       enum mips_abi global_abi = global_mips_abi ();
-      enum mips_abi actual_abi = mips_abi (target_gdbarch);
+      enum mips_abi actual_abi = mips_abi (target_gdbarch ());
       const char *actual_abi_str = mips_abi_strings[actual_abi];
 
       if (global_abi == MIPS_ABI_UNKNOWN)
index 48127364d664e53621443c6d31e86bf1b41b6acd..850c2739064d3e7f58e544052fd281e9772851d0 100644 (file)
@@ -217,11 +217,11 @@ monitor_error (char *function, char *message,
 
   if (final_char)
     error (_("%s (%s): %s: %s%c"),
-          function, paddress (target_gdbarch, memaddr),
+          function, paddress (target_gdbarch (), memaddr),
           message, safe_string, final_char);
   else
     error (_("%s (%s): %s: %s"),
-          function, paddress (target_gdbarch, memaddr),
+          function, paddress (target_gdbarch (), memaddr),
           message, safe_string);
 }
 
@@ -256,7 +256,7 @@ fromhex (int a)
 static void
 monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
 {
-  int addr_bit = gdbarch_addr_bit (target_gdbarch);
+  int addr_bit = gdbarch_addr_bit (target_gdbarch ());
   char format[10];
   char fmt;
   char *p;
@@ -1440,15 +1440,15 @@ monitor_files_info (struct target_ops *ops)
 static int
 monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   unsigned int val, hostval;
   char *cmd;
   int i;
 
-  monitor_debug ("MON write %d %s\n", len, paddress (target_gdbarch, 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);
+    memaddr = gdbarch_addr_bits_remove (target_gdbarch (), memaddr);
 
   /* Use memory fill command for leading 0 bytes.  */
 
@@ -1707,7 +1707,7 @@ monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len)
 static int
 monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   unsigned int val;
   char membuf[sizeof (int) * 2 + 1];
   char *p;
@@ -1852,11 +1852,11 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
     }
 
   monitor_debug ("MON read block ta(%s) ha(%s) %d\n",
-                paddress (target_gdbarch, memaddr),
+                paddress (target_gdbarch (), memaddr),
                 host_address_to_string (myaddr), len);
 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
-    memaddr = gdbarch_addr_bits_remove (target_gdbarch, memaddr);
+    memaddr = gdbarch_addr_bits_remove (target_gdbarch (), memaddr);
 
   if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
     return monitor_read_memory_single (memaddr, myaddr, len);
index 5a04ecc7909e2b35d745a90b4050f40c24bebb03..f8a4528b9261be2975f6986893e530e0d54004ff 100644 (file)
@@ -505,7 +505,7 @@ moxie_process_readu (CORE_ADDR addr, char *buf,
       if (record_debug)
        printf_unfiltered (_("Process record: error reading memory at "
                             "addr 0x%s len = %d.\n"),
-                          paddress (target_gdbarch, addr), length);
+                          paddress (target_gdbarch (), addr), length);
       return -1;
     }
 
@@ -528,7 +528,7 @@ moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
   if (record_debug > 1)
     fprintf_unfiltered (gdb_stdlog, "Process record: moxie_process_record "
                                    "addr = 0x%s\n",
-                       paddress (target_gdbarch, addr));
+                       paddress (target_gdbarch (), addr));
 
   inst = (uint16_t) moxie_process_readu (addr, buf, 2, byte_order);
 
index b58f3188b2a550ac180d72b0b93578decefe26e1..cf33a025a5d9bfc19fe310f9363d5b2d5af8fcc5 100644 (file)
@@ -197,7 +197,7 @@ procfs_open (char *arg, int from_tty)
            {
              if (sysinfo->type !=
                  nto_map_arch_to_cputype (gdbarch_bfd_arch_info
-                                          (target_gdbarch)->arch_name))
+                                          (target_gdbarch ())->arch_name))
                error (_("Invalid target CPU."));
            }
        }
index fddd5482c4ff6853c8d6bb2218a661ed94101d0c..7c4894638c749041b82fea47ff3294cc5cbb283d 100644 (file)
@@ -94,14 +94,14 @@ nto_find_and_open_solib (char *solib, unsigned o_flags, char **temp_pathname)
   "%s/lib:%s/usr/lib:%s/usr/photon/lib:%s/usr/photon/dll:%s/lib/dll"
 
   nto_root = nto_target ();
-  if (strcmp (gdbarch_bfd_arch_info (target_gdbarch)->arch_name, "i386") == 0)
+  if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0)
     {
       arch = "x86";
       endian = "";
     }
-  else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch)->arch_name,
+  else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
                   "rs6000") == 0
-          || strcmp (gdbarch_bfd_arch_info (target_gdbarch)->arch_name,
+          || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
                   "powerpc") == 0)
     {
       arch = "ppc";
@@ -109,8 +109,8 @@ nto_find_and_open_solib (char *solib, unsigned o_flags, char **temp_pathname)
     }
   else
     {
-      arch = gdbarch_bfd_arch_info (target_gdbarch)->arch_name;
-      endian = gdbarch_byte_order (target_gdbarch)
+      arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name;
+      endian = gdbarch_byte_order (target_gdbarch ())
               == BFD_ENDIAN_BIG ? "be" : "le";
     }
 
@@ -150,14 +150,14 @@ nto_init_solib_absolute_prefix (void)
   const char *arch;
 
   nto_root = nto_target ();
-  if (strcmp (gdbarch_bfd_arch_info (target_gdbarch)->arch_name, "i386") == 0)
+  if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name, "i386") == 0)
     {
       arch = "x86";
       endian = "";
     }
-  else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch)->arch_name,
+  else if (strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
                   "rs6000") == 0
-          || strcmp (gdbarch_bfd_arch_info (target_gdbarch)->arch_name,
+          || strcmp (gdbarch_bfd_arch_info (target_gdbarch ())->arch_name,
                   "powerpc") == 0)
     {
       arch = "ppc";
@@ -165,8 +165,8 @@ nto_init_solib_absolute_prefix (void)
     }
   else
     {
-      arch = gdbarch_bfd_arch_info (target_gdbarch)->arch_name;
-      endian = gdbarch_byte_order (target_gdbarch)
+      arch = gdbarch_bfd_arch_info (target_gdbarch ())->arch_name;
+      endian = gdbarch_byte_order (target_gdbarch ())
               == BFD_ENDIAN_BIG ? "be" : "le";
     }
 
@@ -261,7 +261,7 @@ lm_addr (struct so_list *so)
   if (so->lm_info->l_addr == (CORE_ADDR)-1)
     {
       struct link_map_offsets *lmo = nto_fetch_link_map_offsets ();
-      struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+      struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 
       so->lm_info->l_addr =
        extract_typed_address (so->lm_info->lm + lmo->l_addr_offset, ptr_type);
@@ -272,12 +272,12 @@ lm_addr (struct so_list *so)
 static CORE_ADDR
 nto_truncate_ptr (CORE_ADDR addr)
 {
-  if (gdbarch_ptr_bit (target_gdbarch) == sizeof (CORE_ADDR) * 8)
+  if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR) * 8)
     /* We don't need to truncate anything, and the bit twiddling below
        will fail due to overflow problems.  */
     return addr;
   else
-    return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch)) - 1);
+    return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
 }
 
 static Elf_Internal_Phdr *
index 14f4ecbdb48eb1d82aa766a0326b183537133f97..ef94a48bd24f9218fe73a05fbe305f5af22dcec4 100644 (file)
@@ -2394,7 +2394,7 @@ ppc_linux_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
                       gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 {
   int sizeof_auxv_field = ppc_linux_target_wordsize ();
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   gdb_byte *ptr = *readptr;
 
   if (endptr == ptr)
index a1f90a88eb3f6c5daec3ae1654c5fa0e317570e6..68df6e9a0a1069e2316bb2b851508efeb14478c4 100644 (file)
@@ -269,7 +269,7 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
   struct regcache *regcache;
 
   inferior_ptid = BUILD_LWP (lwpid, ptid_get_pid (ph->ptid));
-  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
+  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
 
   target_fetch_registers (regcache, -1);
   fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
@@ -288,7 +288,7 @@ ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, const prgregset_t gregset)
   struct regcache *regcache;
 
   inferior_ptid = BUILD_LWP (lwpid, ptid_get_pid (ph->ptid));
-  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
+  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
 
   supply_gregset (regcache, (const gdb_gregset_t *) gregset);
   target_store_registers (regcache, -1);
@@ -308,7 +308,7 @@ ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
   struct regcache *regcache;
 
   inferior_ptid = BUILD_LWP (lwpid, ptid_get_pid (ph->ptid));
-  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
+  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
 
   target_fetch_registers (regcache, -1);
   fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
@@ -328,7 +328,7 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
   struct regcache *regcache;
 
   inferior_ptid = BUILD_LWP (lwpid, ptid_get_pid (ph->ptid));
-  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
+  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
 
   supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
   target_store_registers (regcache, -1);
index c03165abed93c1505ae6ce1803e52853050d2277..82c7cd0cf344862a0e538b3e5623a044f819c75d 100644 (file)
@@ -159,7 +159,7 @@ static int
 procfs_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
                   gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   gdb_byte *ptr = *readptr;
 
   if (endptr == ptr)
@@ -1206,12 +1206,12 @@ proc_watchpoint_address (procinfo *pi, CORE_ADDR *addr)
       return 0;
 
 #ifdef NEW_PROC_API
-  *addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch,
-           builtin_type (target_gdbarch)->builtin_data_ptr,
+  *addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch (),
+           builtin_type (target_gdbarch ())->builtin_data_ptr,
            (gdb_byte *) &pi->prstatus.pr_lwp.pr_info.si_addr);
 #else
-  *addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch,
-           builtin_type (target_gdbarch)->builtin_data_ptr,
+  *addr = (CORE_ADDR) gdbarch_pointer_to_address (target_gdbarch (),
+           builtin_type (target_gdbarch ())->builtin_data_ptr,
            (gdb_byte *) &pi->prstatus.pr_info.si_addr);
 #endif
   return 1;
@@ -2455,11 +2455,11 @@ proc_parent_pid (procinfo *pi)
 static void *
 procfs_address_to_host_pointer (CORE_ADDR addr)
 {
-  struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
   void *ptr;
 
   gdb_assert (sizeof (ptr) == TYPE_LENGTH (ptr_type));
-  gdbarch_address_to_pointer (target_gdbarch, ptr_type,
+  gdbarch_address_to_pointer (target_gdbarch (), ptr_type,
                              (gdb_byte *) &ptr, addr);
   return ptr;
 }
@@ -3430,7 +3430,7 @@ remove_dbx_link_breakpoint (void)
   if (dbx_link_bpt_addr == 0)
     return;
 
-  if (deprecated_remove_raw_breakpoint (target_gdbarch, dbx_link_bpt) != 0)
+  if (deprecated_remove_raw_breakpoint (target_gdbarch (), dbx_link_bpt) != 0)
     warning (_("Unable to remove __dbx_link breakpoint."));
 
   dbx_link_bpt_addr = 0;
@@ -3503,7 +3503,7 @@ insert_dbx_link_bpt_in_file (int fd, CORE_ADDR ignored)
     {
       /* Insert the breakpoint.  */
       dbx_link_bpt_addr = sym_addr;
-      dbx_link_bpt = deprecated_insert_raw_breakpoint (target_gdbarch, NULL,
+      dbx_link_bpt = deprecated_insert_raw_breakpoint (target_gdbarch (), NULL,
                                                       sym_addr);
       if (dbx_link_bpt == NULL)
        {
@@ -4118,7 +4118,7 @@ invalidate_cache (procinfo *parent, procinfo *pi, void *ptr)
       if (!proc_set_gregs (pi))        /* flush gregs cache */
        proc_warn (pi, "target_resume, set_gregs",
                   __LINE__);
-  if (gdbarch_fp0_regnum (target_gdbarch) >= 0)
+  if (gdbarch_fp0_regnum (target_gdbarch ()) >= 0)
     if (pi->fpregs_dirty)
       if (parent == NULL ||
          proc_get_current_thread (parent) != pi->tid)
@@ -4396,7 +4396,7 @@ procfs_mourn_inferior (struct target_ops *ops)
 
   if (dbx_link_bpt != NULL)
     {
-      deprecated_remove_raw_breakpoint (target_gdbarch, dbx_link_bpt);
+      deprecated_remove_raw_breakpoint (target_gdbarch (), dbx_link_bpt);
       dbx_link_bpt_addr = 0;
       dbx_link_bpt = NULL;
     }
@@ -4881,7 +4881,7 @@ procfs_can_use_hw_breakpoint (int type, int cnt, int othertype)
      procfs_address_to_host_pointer will reveal that an internal error
      will be generated when the host and target pointer sizes are
      different.  */
-  struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 
   if (sizeof (void *) != TYPE_LENGTH (ptr_type))
     return 0;
@@ -4938,7 +4938,7 @@ procfs_insert_watchpoint (CORE_ADDR addr, int len, int type,
                          struct expression *cond)
 {
   if (!target_have_steppable_watchpoint
-      && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch))
+      && !gdbarch_have_nonsteppable_watchpoint (target_gdbarch ()))
     {
       /* When a hardware watchpoint fires off the PC will be left at
         the instruction following the one which caused the
@@ -5138,7 +5138,7 @@ info_mappings_callback (struct prmap *map, find_memory_region_ftype ignore,
   pr_off = map->pr_off;
 #endif
 
-  if (gdbarch_addr_bit (target_gdbarch) == 32)
+  if (gdbarch_addr_bit (target_gdbarch ()) == 32)
     printf_filtered ("\t%#10lx %#10lx %#10lx %#10x %7s\n",
                     (unsigned long) map->pr_vaddr,
                     (unsigned long) map->pr_vaddr + map->pr_size - 1,
@@ -5165,7 +5165,7 @@ info_proc_mappings (procinfo *pi, int summary)
     return;    /* No output for summary mode.  */
 
   printf_filtered (_("Mapped address spaces:\n\n"));
-  if (gdbarch_ptr_bit (target_gdbarch) == 32)
+  if (gdbarch_ptr_bit (target_gdbarch ()) == 32)
     printf_filtered ("\t%10s %10s %10s %10s %7s\n",
                     "Start Addr",
                     "  End Addr",
index db8c5a3b09610a806c329a0b14345b4674ff13a6..ff5af0dbdf5148163300008aa4a4959c69cde9c0 100644 (file)
@@ -75,7 +75,7 @@ new_address_space (void)
 struct address_space *
 maybe_new_address_space (void)
 {
-  int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch);
+  int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ());
 
   if (shared_aspace)
     {
@@ -148,7 +148,7 @@ release_program_space (struct program_space *pspace)
   no_shared_libraries (NULL, 0);
   exec_close ();
   free_all_objfiles ();
-  if (!gdbarch_has_shared_address_space (target_gdbarch))
+  if (!gdbarch_has_shared_address_space (target_gdbarch ()))
     free_address_space (pspace->aspace);
   resize_section_table (&pspace->target_sections,
                        -resize_section_table (&pspace->target_sections, 0));
@@ -432,7 +432,7 @@ number_of_program_spaces (void)
 void
 update_address_spaces (void)
 {
-  int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch);
+  int shared_aspace = gdbarch_has_shared_address_space (target_gdbarch ());
   struct program_space *pspace;
   struct inferior *inf;
 
@@ -454,7 +454,7 @@ update_address_spaces (void)
       }
 
   for (inf = inferior_list; inf; inf = inf->next)
-    if (gdbarch_has_global_solist (target_gdbarch))
+    if (gdbarch_has_global_solist (target_gdbarch ()))
       inf->aspace = maybe_new_address_space ();
     else
       inf->aspace = inf->pspace->aspace;
index 56ab77525c0fdaaf503df569fd5071bada3734cd..7b2d319039e3815d3f9e2a0a1aeca60190409024 100644 (file)
@@ -392,7 +392,7 @@ bpfinishpy_handle_stop (struct bpstats *bs, int print_frame)
 static void
 bpfinishpy_handle_exit (struct inferior *inf)
 {
-  struct cleanup *cleanup = ensure_python_env (target_gdbarch,
+  struct cleanup *cleanup = ensure_python_env (target_gdbarch (),
                                                current_language);
 
   iterate_over_breakpoints (bpfinishpy_detect_out_scope_cb, NULL);
index 211a643ddaed1d4ecf3b3a31a4934941bcc7bc37..8acf87b187eca79648a4e5f3d825ecb5b938059a 100644 (file)
@@ -101,7 +101,7 @@ python_on_resume (ptid_t ptid)
 {
   struct cleanup *cleanup;
 
-  cleanup = ensure_python_env (target_gdbarch, current_language);
+  cleanup = ensure_python_env (target_gdbarch (), current_language);
 
   if (emit_continue_event (ptid) < 0)
     gdbpy_print_stack ();
@@ -115,7 +115,7 @@ python_inferior_exit (struct inferior *inf)
   struct cleanup *cleanup;
   const LONGEST *exit_code = NULL;
 
-  cleanup = ensure_python_env (target_gdbarch, current_language);
+  cleanup = ensure_python_env (target_gdbarch (), current_language);
 
   if (inf->has_exit_code)
     exit_code = &inf->exit_code;
index 97f85060544d5bb6980271da82926fffd9644708..cd50e509759dd7ccd4bf57b1fec855f0de67ab56 100644 (file)
@@ -1280,7 +1280,7 @@ finalize_python (void *ignore)
      clearer to make the needed calls explicitly here than to create a
      cleanup and then mysteriously discard it.  */
   PyGILState_Ensure ();
-  python_gdbarch = target_gdbarch;
+  python_gdbarch = target_gdbarch ();
   python_language = current_language;
 
   Py_Finalize ();
index 0c475cbd2d1a160fbfd00a3c5907465f484f327e..0f9380bcaf2a48b8552213b464d039646e4a96a4 100644 (file)
@@ -166,7 +166,7 @@ get_running_thread_id (void)
   char *buf;
   CORE_ADDR object_addr;
   struct type *builtin_type_void_data_ptr =
-    builtin_type (target_gdbarch)->builtin_data_ptr;
+    builtin_type (target_gdbarch ())->builtin_data_ptr;
 
   if (!object_msym)
     return 0;
index c98ed321b985c7bc32df253efdb2bfa8647b211d..08ffb687e2e0502900e3cba2c12036d198e60f6f 100644 (file)
@@ -512,14 +512,14 @@ record_arch_list_add_mem (CORE_ADDR addr, int len)
     fprintf_unfiltered (gdb_stdlog,
                        "Process record: add mem addr = %s len = %d to "
                        "record list.\n",
-                       paddress (target_gdbarch, addr), len);
+                       paddress (target_gdbarch (), addr), len);
 
   if (!addr)   /* FIXME: Why?  Some arch must permit it...  */
     return 0;
 
   rec = record_mem_alloc (addr, len);
 
-  if (record_read_memory (target_gdbarch, addr, record_get_loc (rec), len))
+  if (record_read_memory (target_gdbarch (), addr, record_get_loc (rec), len))
     {
       record_mem_release (rec);
       return -1;
@@ -874,7 +874,7 @@ record_open_1 (char *name, int from_tty)
     error (_("Process record target can't debug inferior in non-stop mode "
             "(non-stop)."));
 
-  if (!gdbarch_process_record_p (target_gdbarch))
+  if (!gdbarch_process_record_p (target_gdbarch ()))
     error (_("Process record: the current architecture doesn't support "
             "record function."));
 
@@ -1686,7 +1686,7 @@ record_xfer_partial (struct target_ops *ops, enum target_object object,
          if (!query (_("Because GDB is in replay mode, writing to memory "
                        "will make the execution log unusable from this "
                        "point onward.  Write memory at address %s?"),
-                      paddress (target_gdbarch, offset)))
+                      paddress (target_gdbarch (), offset)))
            error (_("Process record canceled the operation."));
 
          /* Destroy the record from here forward.  */
index 748aeba6953bada41528a33ec5eb2f72e8613092..f7addea2186dc8848168e9964a5e53de97a404ce 100644 (file)
@@ -487,7 +487,7 @@ m32r_resume (struct target_ops *ops,
       else
        {
          buf[0] = SDI_WRITE_MEMORY;
-         if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+         if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
            store_long_parameter (buf + 1, pc_addr);
          else
            store_long_parameter (buf + 1, pc_addr - 1);
@@ -527,7 +527,7 @@ m32r_resume (struct target_ops *ops,
        continue;
 
       /* Set PBP.  */
-      if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+      if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
        send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
                            0x00000006);
       else
@@ -554,7 +554,7 @@ m32r_resume (struct target_ops *ops,
       store_long_parameter (buf + 5, 4);
       if ((bp_addr & 2) == 0 && bp_addr != (pc_addr & 0xfffffffc))
        {
-         if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+         if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
            {
              buf[9] = dbt_bp_entry[0];
              buf[10] = dbt_bp_entry[1];
@@ -571,7 +571,7 @@ m32r_resume (struct target_ops *ops,
        }
       else
        {
-         if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+         if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
            {
              if ((bp_addr & 2) == 0)
                {
@@ -618,7 +618,7 @@ m32r_resume (struct target_ops *ops,
        continue;
 
       /* DBC register.  */
-      if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+      if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
        {
          switch (ab_type[i])
            {
@@ -760,7 +760,7 @@ m32r_wait (struct target_ops *ops,
   if (last_pc_addr != 0xffffffff)
     {
       buf[0] = SDI_WRITE_MEMORY;
-      if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+      if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
        store_long_parameter (buf + 1, last_pc_addr);
       else
        store_long_parameter (buf + 1, last_pc_addr - 1);
@@ -789,7 +789,7 @@ m32r_wait (struct target_ops *ops,
             address, we have to take care of it later.  */
          if ((pc_addr & 0x2) != 0)
            {
-             if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+             if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
                {
                  if ((bp_data[i][2] & 0x80) != 0)
                    {
@@ -851,7 +851,7 @@ m32r_wait (struct target_ops *ops,
          c = serial_readchar (sdi_desc, SDI_TIMEOUT);
          if (c != '-' && recv_data (buf, 4) != -1)
            {
-             if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+             if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)
                {
                  if ((buf[3] & 0x1) == 0x1)
                    hit_watchpoint_addr = ab_address[i];
@@ -1055,10 +1055,10 @@ m32r_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
     {
       if (write)
        fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,write)\n",
-                           paddress (target_gdbarch, memaddr), len);
+                           paddress (target_gdbarch (), memaddr), len);
       else
        fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,read)\n",
-                           paddress (target_gdbarch, memaddr), len);
+                           paddress (target_gdbarch (), memaddr), len);
     }
 
   if (write)
@@ -1424,7 +1424,7 @@ m32r_insert_watchpoint (CORE_ADDR addr, int len, int type,
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_insert_watchpoint(%s,%d,%d)\n",
-                       paddress (target_gdbarch, addr), len, type);
+                       paddress (target_gdbarch (), addr), len, type);
 
   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
     {
@@ -1449,7 +1449,7 @@ m32r_remove_watchpoint (CORE_ADDR addr, int len, int type,
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_remove_watchpoint(%s,%d,%d)\n",
-                       paddress (target_gdbarch, addr), len, type);
+                       paddress (target_gdbarch (), addr), len, type);
 
   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
     {
index eee2460ef3af9981f88889cbe4df6f80b519ead5..ff5806ecfc009f46289b4ea3256c2af3d0f75645 100644 (file)
@@ -1242,7 +1242,7 @@ mips_request (int cmd,
              int timeout,
              char *buff)
 {
-  int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
+  int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
   char myBuff[DATA_MAXLEN + 1];
   char response_string[17];
   int len;
@@ -1663,10 +1663,10 @@ static void
 mips_open (char *name, int from_tty)
 {
   const char *monitor_prompt = NULL;
-  if (gdbarch_bfd_arch_info (target_gdbarch) != NULL
-      && gdbarch_bfd_arch_info (target_gdbarch)->arch == bfd_arch_mips)
+  if (gdbarch_bfd_arch_info (target_gdbarch ()) != NULL
+      && gdbarch_bfd_arch_info (target_gdbarch ())->arch == bfd_arch_mips)
     {
-    switch (gdbarch_bfd_arch_info (target_gdbarch)->mach)
+    switch (gdbarch_bfd_arch_info (target_gdbarch ())->mach)
       {
       case bfd_mach_mips4100:
       case bfd_mach_mips4300:
@@ -2147,7 +2147,7 @@ static int
 mips_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
                  struct mem_attrib *attrib, struct target_ops *target)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   int i;
   CORE_ADDR addr;
   int count;
@@ -2479,7 +2479,7 @@ static int
 mips_check_lsi_error (CORE_ADDR addr, int rerrflg)
 {
   struct lsi_error *err;
-  const char *saddr = paddress (target_gdbarch, addr);
+  const char *saddr = paddress (target_gdbarch (), addr);
 
   if (rerrflg == 0)            /* no error */
     return 0;
@@ -2547,13 +2547,13 @@ mips_common_breakpoint (%s): Unknown error: 0x%x\n",
 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;
+  int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
   char buf[DATA_MAXLEN + 1];
   char cmd, rcmd;
   int rpid, rerrflg, rresponse, rlen;
   int nfields;
 
-  addr = gdbarch_addr_bits_remove (target_gdbarch, addr);
+  addr = gdbarch_addr_bits_remove (target_gdbarch (), addr);
 
   if (mips_monitor == MON_LSI)
     {
@@ -2581,7 +2581,7 @@ mips_common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
            {
              warning (_("\
 mips_common_breakpoint: Attempt to clear bogus breakpoint at %s"),
-                      paddress (target_gdbarch, addr));
+                      paddress (target_gdbarch (), addr));
              return 1;
            }
 
@@ -2732,7 +2732,7 @@ mips_common_breakpoint: Attempt to clear bogus breakpoint at %s"),
          if (rresponse != 22)  /* invalid argument */
            fprintf_unfiltered (gdb_stderr, "\
 mips_common_breakpoint (%s):  Got error: 0x%x\n",
-                               paddress (target_gdbarch, addr), rresponse);
+                               paddress (target_gdbarch (), addr), rresponse);
          return 1;
        }
     }
@@ -2765,7 +2765,7 @@ send_srec (char *srec, int len, CORE_ADDR addr)
        case 0x15:              /* NACK */
          fprintf_unfiltered (gdb_stderr,
                              "Download got a NACK at byte %s!  Retrying.\n",
-                             paddress (target_gdbarch, addr));
+                             paddress (target_gdbarch (), addr));
          continue;
        default:
          error (_("Download got unexpected ack char: 0x%x, retrying."),
index adc77e7bc1b61add47929804a6314c327d14f190..e2738a88980bab3b9761049728597ccf6fbfda6d 100644 (file)
@@ -1098,7 +1098,7 @@ gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
       gdb_print_host_address (myaddr, gdb_stdout);
       printf_filtered (", memaddr %s, len %d, write %d\n",
-                      paddress (target_gdbarch, memaddr), len, write);
+                      paddress (target_gdbarch (), memaddr), len, write);
       if (remote_debug && write)
        dump_mem (myaddr, len);
     }
index 24bb9bca394fafea90af67cfc7cd3bb78a59589e..be77ad168ff53fd411a1d20d9fb55a283cc147ea 100644 (file)
@@ -397,9 +397,9 @@ struct packet_reg
   long regnum; /* GDB's internal register number.  */
   LONGEST pnum; /* Remote protocol register number.  */
   int in_g_packet; /* Always part of G packet.  */
-  /* long size in bytes;  == register_size (target_gdbarch, regnum);
+  /* long size in bytes;  == register_size (target_gdbarch (), regnum);
      at present.  */
-  /* char *name; == gdbarch_register_name (target_gdbarch, regnum);
+  /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
      at present.  */
 };
 
@@ -484,7 +484,7 @@ remote_get_noisy_reply (char **buf_p,
 
          TRY_CATCH (ex, RETURN_MASK_ALL)
            {
-             gdbarch_relocate_instruction (target_gdbarch, &to, from);
+             gdbarch_relocate_instruction (target_gdbarch (), &to, from);
            }
          if (ex.reason >= 0)
            {
@@ -525,7 +525,7 @@ static struct gdbarch_data *remote_gdbarch_data_handle;
 static struct remote_arch_state *
 get_remote_arch_state (void)
 {
-  return gdbarch_data (target_gdbarch, remote_gdbarch_data_handle);
+  return gdbarch_data (target_gdbarch (), remote_gdbarch_data_handle);
 }
 
 /* Fetch the global remote target state.  */
@@ -698,7 +698,7 @@ get_remote_packet_size (void)
 static struct packet_reg *
 packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum)
 {
-  if (regnum < 0 && regnum >= gdbarch_num_regs (target_gdbarch))
+  if (regnum < 0 && regnum >= gdbarch_num_regs (target_gdbarch ()))
     return NULL;
   else
     {
@@ -714,7 +714,7 @@ packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)
 {
   int i;
 
-  for (i = 0; i < gdbarch_num_regs (target_gdbarch); i++)
+  for (i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++)
     {
       struct packet_reg *r = &rsa->regs[i];
 
@@ -1481,7 +1481,7 @@ remote_add_inferior (int fake_pid_p, int pid, int attached)
   if (attached == -1)
     attached = remote_query_attached (pid);
 
-  if (gdbarch_has_global_solist (target_gdbarch))
+  if (gdbarch_has_global_solist (target_gdbarch ()))
     {
       /* If the target shares code across all inferiors, then every
         attach adds a new inferior.  */
@@ -3338,7 +3338,7 @@ remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
 
   /* On OSs where the list of libraries is global to all
      processes, we fetch them early.  */
-  if (gdbarch_has_global_solist (target_gdbarch))
+  if (gdbarch_has_global_solist (target_gdbarch ()))
     solib_add (NULL, from_tty, target, auto_solib_add);
 
   if (non_stop)
@@ -3420,7 +3420,7 @@ remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
         supported for non-stop; it could be, but it is tricky if
         there are no stopped threads when we connect.  */
       if (remote_read_description_p (target)
-         && gdbarch_target_desc (target_gdbarch) == NULL)
+         && gdbarch_target_desc (target_gdbarch ()) == NULL)
        {
          target_clear_description ();
          target_find_description ();
@@ -3539,7 +3539,7 @@ remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
   rs->starting_up = 0;
 
   /* If breakpoints are global, insert them now.  */
-  if (gdbarch_has_global_breakpoints (target_gdbarch)
+  if (gdbarch_has_global_breakpoints (target_gdbarch ())
       && breakpoints_always_inserted_mode ())
     insert_breakpoints ();
 }
@@ -3619,12 +3619,12 @@ remote_check_symbols (struct objfile *objfile)
        xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
       else
        {
-         int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
+         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
             instead of any data function descriptor.  */
-         sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch,
+         sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
                                                         sym_addr,
                                                         &current_target);
 
@@ -5407,10 +5407,10 @@ Packet: '%s'\n"),
              cached_reg.num = reg->regnum;
 
              fieldsize = hex2bin (p, cached_reg.data,
-                                  register_size (target_gdbarch,
+                                  register_size (target_gdbarch (),
                                                  reg->regnum));
              p += 2 * fieldsize;
-             if (fieldsize < register_size (target_gdbarch,
+             if (fieldsize < register_size (target_gdbarch (),
                                             reg->regnum))
                warning (_("Remote reply is too short: %s"), buf);
 
@@ -5604,7 +5604,7 @@ process_stop_reply (struct stop_reply *stop_reply,
       if (stop_reply->regcache)
        {
          struct regcache *regcache
-           = get_thread_arch_regcache (ptid, target_gdbarch);
+           = get_thread_arch_regcache (ptid, target_gdbarch ());
          cached_reg_t *reg;
          int ix;
 
@@ -6318,7 +6318,7 @@ remote_address_masked (CORE_ADDR addr)
 
   /* If "remoteaddresssize" was not set, default to target address size.  */
   if (!address_size)
-    address_size = gdbarch_addr_bit (target_gdbarch);
+    address_size = gdbarch_addr_bit (target_gdbarch ());
 
   if (address_size > 0
       && address_size < (sizeof (ULONGEST) * 8))
@@ -6854,7 +6854,7 @@ static void
 remote_flash_erase (struct target_ops *ops,
                     ULONGEST address, LONGEST length)
 {
-  int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
+  int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
   int saved_remote_timeout = remote_timeout;
   enum packet_result ret;
   struct cleanup *back_to = make_cleanup (restore_remote_timeout,
@@ -8378,12 +8378,12 @@ compare_sections_command (char *args, int from_tty)
 
       if (res == -1)
        error (_("target memory fault, section %s, range %s -- %s"), sectname,
-              paddress (target_gdbarch, lma),
-              paddress (target_gdbarch, lma + size));
+              paddress (target_gdbarch (), lma),
+              paddress (target_gdbarch (), lma + size));
 
       printf_filtered ("Section %s, range %s -- %s: ", sectname,
-                      paddress (target_gdbarch, lma),
-                      paddress (target_gdbarch, lma + size));
+                      paddress (target_gdbarch (), lma),
+                      paddress (target_gdbarch (), lma + size));
       if (res)
        printf_filtered ("matched.\n");
       else
@@ -8739,7 +8739,7 @@ remote_search_memory (struct target_ops* ops,
                      const gdb_byte *pattern, ULONGEST pattern_len,
                      CORE_ADDR *found_addrp)
 {
-  int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
+  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 =
@@ -9273,7 +9273,7 @@ static int
 remote_read_description_p (struct target_ops *target)
 {
   struct remote_g_packet_data *data
-    = gdbarch_data (target_gdbarch, remote_g_packet_data_handle);
+    = gdbarch_data (target_gdbarch (), remote_g_packet_data_handle);
 
   if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
     return 1;
@@ -9285,7 +9285,7 @@ static const struct target_desc *
 remote_read_description (struct target_ops *target)
 {
   struct remote_g_packet_data *data
-    = gdbarch_data (target_gdbarch, remote_g_packet_data_handle);
+    = gdbarch_data (target_gdbarch (), remote_g_packet_data_handle);
 
   /* Do not try this during initial connection, when we do not know
      whether there is a running but stopped thread.  */
@@ -10279,7 +10279,7 @@ remote_download_tracepoint (struct bp_location *loc)
        {
          int isize;
 
-         if (gdbarch_fast_tracepoint_valid_at (target_gdbarch,
+         if (gdbarch_fast_tracepoint_valid_at (target_gdbarch (),
                                                tpaddr, &isize, NULL))
            xsnprintf (buf + strlen (buf), BUF_SIZE - strlen (buf), ":F%x",
                       isize);
index acd36c25d781c46055d1a74c9899fc65be8674a1..23232762b4ffed9ef737f747d90349b2e49a8a30 100644 (file)
@@ -616,7 +616,7 @@ check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size,
   if (value.kind == pvk_register
       && value.k == 0
       && pv_is_register (addr, RL78_SP_REGNUM)
-      && size == register_size (target_gdbarch, value.reg))
+      && size == register_size (target_gdbarch (), value.reg))
     result->reg_offset[value.reg] = addr.k;
 }
 
@@ -643,7 +643,7 @@ rl78_analyze_prologue (CORE_ADDR start_pc,
       result->reg_offset[rn] = 1;
     }
 
-  stack = make_pv_area (RL78_SP_REGNUM, gdbarch_addr_bit (target_gdbarch));
+  stack = make_pv_area (RL78_SP_REGNUM, gdbarch_addr_bit (target_gdbarch ()));
   back_to = make_cleanup_free_pv_area (stack);
 
   /* The call instruction has saved the return address on the stack.  */
index 2d2df5bce2da46f18504716cab0e7a97944bdc6d..f46169b91de32e7cc19fca48f1b4170d50bcabd6 100644 (file)
@@ -76,7 +76,7 @@
 #ifndef ARCH3264
 # define ARCH64() 0
 #else
-# define ARCH64() (register_size (target_gdbarch, 0) == 8)
+# define ARCH64() (register_size (target_gdbarch (), 0) == 8)
 #endif
 
 /* Union of 32-bit and 64-bit versions of ld_info.  */
index 8637c0c31b1a747c41fd9a731385609ac24a2429..5990126bc7a5d276132c9b231165839c161565eb 100644 (file)
@@ -154,7 +154,7 @@ check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
   if (value.kind == pvk_register
       && value.k == 0
       && pv_is_register (addr, RX_SP_REGNUM)
-      && size == register_size (target_gdbarch, value.reg))
+      && size == register_size (target_gdbarch (), value.reg))
     result->reg_offset[value.reg] = addr.k;
 }
 
@@ -207,7 +207,7 @@ rx_analyze_prologue (CORE_ADDR start_pc,
       result->reg_offset[rn] = 1;
     }
 
-  stack = make_pv_area (RX_SP_REGNUM, gdbarch_addr_bit (target_gdbarch));
+  stack = make_pv_area (RX_SP_REGNUM, gdbarch_addr_bit (target_gdbarch ()));
   back_to = make_cleanup_free_pv_area (stack);
 
   /* The call instruction has saved the return address on the stack.  */
index bad1b437f88ba93306f42e91d47476a4cd902a27..ff68676967ba8780d843ed591217f236b57be497 100644 (file)
@@ -601,7 +601,7 @@ s390_auxv_parse (struct target_ops *ops, gdb_byte **readptr,
                 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp)
 {
   int sizeof_auxv_field = s390_target_wordsize ();
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   gdb_byte *ptr = *readptr;
 
   if (endptr == ptr)
index bd31f4f1155cc481c9db35506e01834b6ff604e6..b2c1806583d305af876ffd9d769e735ebdfa37e4 100644 (file)
@@ -861,7 +861,7 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
   old_chain = save_inferior_ptid ();
 
   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
-  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
+  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
 
   target_fetch_registers (regcache, -1);
   fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
@@ -883,7 +883,7 @@ ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
   old_chain = save_inferior_ptid ();
 
   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
-  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
+  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
 
   supply_gregset (regcache, (const gdb_gregset_t *) gregset);
   target_store_registers (regcache, -1);
@@ -917,7 +917,7 @@ ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
   old_chain = save_inferior_ptid ();
 
   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
-  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
+  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
 
   target_fetch_registers (regcache, -1);
   fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
@@ -939,7 +939,7 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
   old_chain = save_inferior_ptid ();
 
   inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
-  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
+  regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
 
   supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
   target_store_registers (regcache, -1);
@@ -1119,7 +1119,7 @@ info_cb (const td_thrhandle_t *th, void *s)
                             SYMBOL_PRINT_NAME (msym));
          else
            printf_filtered ("   startfunc: %s\n",
-                            paddress (target_gdbarch, ti.ti_startfunc));
+                            paddress (target_gdbarch (), ti.ti_startfunc));
        }
 
       /* If thread is asleep, print function that went to sleep.  */
@@ -1132,7 +1132,7 @@ info_cb (const td_thrhandle_t *th, void *s)
                             SYMBOL_PRINT_NAME (msym));
          else
            printf_filtered (" - Sleep func: %s\n",
-                            paddress (target_gdbarch, ti.ti_startfunc));
+                            paddress (target_gdbarch (), ti.ti_startfunc));
        }
 
       /* Wrap up line, if necessary.  */
index 55ecb91de0db2b74a4bd7cf6ff4d8c774e6c243f..4ea07223117a060d0b17085fcab1af71e91379ca 100644 (file)
@@ -127,8 +127,8 @@ static void
 darwin_load_image_infos (struct darwin_info *info)
 {
   gdb_byte buf[24];
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
-  struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
+  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
   int len;
 
   /* If the structure address is not known, don't continue.  */
@@ -245,8 +245,8 @@ open_symbol_file_object (void *from_ttyp)
 static struct so_list *
 darwin_current_sos (void)
 {
-  struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   int ptr_len = TYPE_LENGTH (ptr_type);
   unsigned int image_info_size;
   struct so_list *head = NULL;
@@ -378,7 +378,7 @@ darwin_solib_get_all_image_info_addr_at_init (struct darwin_info *info)
 
       make_cleanup_bfd_unref (dyld_bfd);
       sub = bfd_mach_o_fat_extract (dyld_bfd, bfd_object,
-                                   gdbarch_bfd_arch_info (target_gdbarch));
+                                   gdbarch_bfd_arch_info (target_gdbarch ()));
       if (sub)
        {
          dyld_bfd = sub;
@@ -420,7 +420,7 @@ darwin_solib_read_all_image_info_addr (struct darwin_info *info)
 {
   gdb_byte buf[8 + 8 + 4];
   LONGEST len;
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 
   len = target_read (&current_target, TARGET_OBJECT_DARWIN_DYLD_INFO, NULL,
                      buf, 0, sizeof (buf));
@@ -450,7 +450,7 @@ darwin_solib_create_inferior_hook (int from_tty)
   darwin_load_image_infos (info);
 
   if (darwin_dyld_version_ok (info))
-    create_solib_event_breakpoint (target_gdbarch, info->all_image.notifier);
+    create_solib_event_breakpoint (target_gdbarch (), info->all_image.notifier);
 }
 
 static void
@@ -515,7 +515,7 @@ darwin_bfd_open (char *pathname)
   abfd = solib_bfd_fopen (found_pathname, found_file);
 
   res = bfd_mach_o_fat_extract (abfd, bfd_object,
-                               gdbarch_bfd_arch_info (target_gdbarch));
+                               gdbarch_bfd_arch_info (target_gdbarch ()));
   if (!res)
     {
       make_cleanup_bfd_unref (abfd);
index 8276db295156938664ed1b75445b2d6d1efcc4f2..9024be2caf04d9fab96885bda855a5500d71038b 100644 (file)
@@ -212,13 +212,13 @@ dsbt_print_loadmap (struct int_elf32_dsbt_loadmap *map)
 
       for (i = 0; i < map->nsegs; i++)
        printf_filtered ("%s:%s -> %s:%s\n",
-                        print_core_address (target_gdbarch,
+                        print_core_address (target_gdbarch (),
                                             map->segs[i].p_vaddr),
-                        print_core_address (target_gdbarch,
+                        print_core_address (target_gdbarch (),
                                             map->segs[i].p_vaddr
                                             + map->segs[i].p_memsz),
-                        print_core_address (target_gdbarch, map->segs[i].addr),
-                        print_core_address (target_gdbarch, map->segs[i].addr
+                        print_core_address (target_gdbarch (), map->segs[i].addr),
+                        print_core_address (target_gdbarch (), map->segs[i].addr
                                             + map->segs[i].p_memsz));
     }
 }
@@ -228,7 +228,7 @@ dsbt_print_loadmap (struct int_elf32_dsbt_loadmap *map)
 static struct int_elf32_dsbt_loadmap *
 decode_loadmap (gdb_byte *buf)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   struct ext_elf32_dsbt_loadmap *ext_ldmbuf;
   struct int_elf32_dsbt_loadmap *int_ldmbuf;
 
@@ -327,7 +327,7 @@ dsbt_get_initial_loadmaps (void)
 static struct int_elf32_dsbt_loadmap *
 fetch_loadmap (CORE_ADDR ldmaddr)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   struct ext_elf32_dsbt_loadmap ext_ldmbuf_partial;
   struct ext_elf32_dsbt_loadmap *ext_ldmbuf;
   struct int_elf32_dsbt_loadmap *int_ldmbuf;
@@ -496,7 +496,7 @@ scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
             gdb_byte ptr_buf[8];
             CORE_ADDR ptr_addr;
 
-            ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+            ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
             ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
             if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
               dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
@@ -555,7 +555,7 @@ displacement_from_map (struct int_elf32_dsbt_loadmap *map,
 static CORE_ADDR
 lm_base (void)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   struct minimal_symbol *got_sym;
   CORE_ADDR addr;
   gdb_byte buf[TIC6X_PTR_SIZE];
@@ -635,7 +635,7 @@ lm_base (void)
 static struct so_list *
 dsbt_current_sos (void)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   CORE_ADDR lm_addr;
   struct so_list *sos_head = NULL;
   struct so_list **sos_next_ptr = &sos_head;
@@ -814,7 +814,7 @@ cmp_name (asymbol *sym, void *data)
 static int
 enable_break2 (void)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   int success = 0;
   char **bkpt_namep;
   asection *interp_sect;
@@ -965,7 +965,7 @@ enable_break2 (void)
       remove_solib_event_breakpoints ();
 
       /* Now (finally!) create the solib breakpoint.  */
-      create_solib_event_breakpoint (target_gdbarch, addr);
+      create_solib_event_breakpoint (target_gdbarch (), addr);
 
       info->enable_break2_done = 1;
 
@@ -1007,7 +1007,7 @@ enable_break (void)
       return 0;
     }
 
-  create_solib_event_breakpoint (target_gdbarch,
+  create_solib_event_breakpoint (target_gdbarch (),
                                 SYMBOL_VALUE_ADDRESS (start));
 
   if (solib_dsbt_debug)
index 57a14a83781ccb843bab675a871e10c6fbc50871..d2594403adbf62e0d18dcc9328a6e27176422846 100644 (file)
@@ -98,7 +98,7 @@ struct int_elf32_fdpic_loadmap {
 static struct int_elf32_fdpic_loadmap *
 fetch_loadmap (CORE_ADDR ldmaddr)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   struct ext_elf32_fdpic_loadmap ext_ldmbuf_partial;
   struct ext_elf32_fdpic_loadmap *ext_ldmbuf;
   struct int_elf32_fdpic_loadmap *int_ldmbuf;
@@ -265,7 +265,7 @@ static CORE_ADDR main_lm_addr = 0;
 static CORE_ADDR
 lm_base (void)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   struct minimal_symbol *got_sym;
   CORE_ADDR addr;
   gdb_byte buf[FRV_PTR_SIZE];
@@ -317,7 +317,7 @@ lm_base (void)
 static struct so_list *
 frv_current_sos (void)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   CORE_ADDR lm_addr, mgot;
   struct so_list *sos_head = NULL;
   struct so_list **sos_next_ptr = &sos_head;
@@ -518,7 +518,7 @@ static int enable_break2_done = 0;
 static int
 enable_break2 (void)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   int success = 0;
   char **bkpt_namep;
   asection *interp_sect;
@@ -569,7 +569,7 @@ enable_break2 (void)
          return 0;
        }
 
-      status = frv_fdpic_loadmap_addresses (target_gdbarch,
+      status = frv_fdpic_loadmap_addresses (target_gdbarch (),
                                             &interp_loadmap_addr, 0);
       if (status < 0)
        {
@@ -703,7 +703,7 @@ enable_break2 (void)
       remove_solib_event_breakpoints ();
 
       /* Now (finally!) create the solib breakpoint.  */
-      create_solib_event_breakpoint (target_gdbarch, addr);
+      create_solib_event_breakpoint (target_gdbarch (), addr);
 
       enable_break2_done = 1;
 
@@ -751,7 +751,7 @@ enable_break (void)
       return 0;
     }
 
-  create_solib_event_breakpoint (target_gdbarch,
+  create_solib_event_breakpoint (target_gdbarch (),
                                 symfile_objfile->ei.entry_point);
 
   if (solib_frv_debug)
@@ -782,7 +782,7 @@ frv_relocate_main_executable (void)
   int changed;
   struct obj_section *osect;
 
-  status = frv_fdpic_loadmap_addresses (target_gdbarch,
+  status = frv_fdpic_loadmap_addresses (target_gdbarch (),
                                         &interp_addr, &exec_addr);
 
   if (status < 0 || (exec_addr == 0 && interp_addr == 0))
@@ -1021,7 +1021,7 @@ find_canonical_descriptor_in_load_object
   (CORE_ADDR entry_point, CORE_ADDR got_value, const char *name, bfd *abfd,
    struct lm_info *lm)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   arelent *rel;
   unsigned int i;
   CORE_ADDR addr = 0;
index f349c4c8674590a3bff55dfcdfe4490b660e14ac..0d2b835b896e0b7da9b00f95ab45d533595f65e8 100644 (file)
@@ -396,7 +396,7 @@ ia64_hpux_clear_solib (void)
 static CORE_ADDR
 ia64_hpux_get_load_info_addr (void)
 {
-  struct type *data_ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+  struct type *data_ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
   CORE_ADDR addr;
   int status;
 
index 1cec28202153872724fd870f077e4eae123fd511..52378e9d5cbdbf06fe9e21d478d53873789811bb 100644 (file)
@@ -142,7 +142,7 @@ extract_mips_address (void *addr, int len, enum bfd_endian byte_order)
 static struct lm_info
 fetch_lm_info (CORE_ADDR addr)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   struct lm_info li;
   union irix_obj_info buf;
 
@@ -306,7 +306,7 @@ disable_break (void)
   /* Note that breakpoint address and original contents are in our address
      space, so we just need to write the original contents back.  */
 
-  if (deprecated_remove_raw_breakpoint (target_gdbarch, base_breakpoint) != 0)
+  if (deprecated_remove_raw_breakpoint (target_gdbarch (), base_breakpoint) != 0)
     {
       status = 0;
     }
@@ -339,7 +339,7 @@ enable_break (void)
       if (!entry_point_address_query (&entry_point))
        return 0;
 
-      base_breakpoint = deprecated_insert_raw_breakpoint (target_gdbarch,
+      base_breakpoint = deprecated_insert_raw_breakpoint (target_gdbarch (),
                                                          aspace, entry_point);
 
       if (base_breakpoint != NULL)
@@ -453,8 +453,8 @@ irix_solib_create_inferior_hook (int from_tty)
 static struct so_list *
 irix_current_sos (void)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
-  int addr_size = gdbarch_addr_bit (target_gdbarch) / TARGET_CHAR_BIT;
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
+  int addr_size = gdbarch_addr_bit (target_gdbarch ()) / TARGET_CHAR_BIT;
   CORE_ADDR lma;
   char addr_buf[8];
   struct so_list *head = 0;
@@ -545,8 +545,8 @@ irix_current_sos (void)
 static int
 irix_open_symbol_file_object (void *from_ttyp)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
-  int addr_size = gdbarch_addr_bit (target_gdbarch) / TARGET_CHAR_BIT;
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
+  int addr_size = gdbarch_addr_bit (target_gdbarch ()) / TARGET_CHAR_BIT;
   CORE_ADDR lma;
   char addr_buf[8];
   struct lm_info lm;
index 60b36847d8f76e564efc8c2efcbc6061dbbbda0d..c37b617738cf5a454ce1f09fcb66ef9b62f93e18 100644 (file)
@@ -391,7 +391,7 @@ manpage for methods to privately map shared library text."));
       /* Create the shared library breakpoint.  */
       {
        struct breakpoint *b
-         = create_solib_event_breakpoint (target_gdbarch, sym_addr);
+         = create_solib_event_breakpoint (target_gdbarch (), sym_addr);
 
        /* The breakpoint is actually hard-coded into the dynamic linker,
           so we don't need to actually insert a breakpoint instruction
index 6fea10809d456406e00a8e71b0fa2482a94f3c54..47bf5a345bd09f3bdd68d22a2248f188a3f19830 100644 (file)
@@ -185,7 +185,7 @@ struct {
 static void
 som_solib_create_inferior_hook (int from_tty)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   struct minimal_symbol *msymbol;
   unsigned int dld_flags, status, have_endo;
   asection *shlib_info;
@@ -288,7 +288,7 @@ Suggest linking with /opt/langtools/lib/end.o.\n\
 GDB will be unable to track shl_load/shl_unload calls"));
       goto keep_going;
     }
-  create_solib_event_breakpoint (target_gdbarch,
+  create_solib_event_breakpoint (target_gdbarch (),
                                 SYMBOL_VALUE_ADDRESS (msymbol));
 
   /* We have all the support usually found in end.o, so we can track
@@ -353,7 +353,7 @@ manpage for methods to privately map shared library text."));
   anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
 
   /* Make the breakpoint at "_start" a shared library event breakpoint.  */
-  create_solib_event_breakpoint (target_gdbarch, anaddr);
+  create_solib_event_breakpoint (target_gdbarch (), anaddr);
 
   clear_symtab_users (0);
 }
@@ -525,7 +525,7 @@ struct dld_list {
 static CORE_ADDR
 link_map_start (void)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   struct minimal_symbol *sym;
   CORE_ADDR addr;
   char buf[4];
@@ -575,7 +575,7 @@ match_main (const char *name)
 static struct so_list *
 som_current_sos (void)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   CORE_ADDR lm;
   struct so_list *head = 0;
   struct so_list **link_ptr = &head;
@@ -642,27 +642,27 @@ som_current_sos (void)
 
 #ifdef SOLIB_SOM_DBG
            printf ("\n+ library \"%s\" is described at %s\n", new->so_name,
-                   paddress (target_gdbarch, lm));
+                   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 %s\n",
-                   paddress (target_gdbarch, new->lm_info->text_addr));
+                   paddress (target_gdbarch (), new->lm_info->text_addr));
            printf ("  'text_link_addr' is %s\n",
-                   paddress (target_gdbarch, new->lm_info->text_link_addr));
+                   paddress (target_gdbarch (), new->lm_info->text_link_addr));
            printf ("  'text_end' is %s\n",
-                   paddress (target_gdbarch, new->lm_info->text_end));
+                   paddress (target_gdbarch (), new->lm_info->text_end));
            printf ("  'data_start' is %s\n",
-                   paddress (target_gdbarch, new->lm_info->data_start));
+                   paddress (target_gdbarch (), new->lm_info->data_start));
            printf ("  'bss_start' is %s\n",
-                   paddress (target_gdbarch, new->lm_info->bss_start));
+                   paddress (target_gdbarch (), new->lm_info->bss_start));
            printf ("  'data_end' is %s\n",
-                   paddress (target_gdbarch, new->lm_info->data_end));
+                   paddress (target_gdbarch (), new->lm_info->data_end));
            printf ("  'got_value' is %s\n",
-                   paddress (target_gdbarch, new->lm_info->got_value));
+                   paddress (target_gdbarch (), new->lm_info->got_value));
            printf ("  'tsd_start_addr' is %s\n",
-                   paddress (target_gdbarch, new->lm_info->tsd_start_addr));
+                   paddress (target_gdbarch (), new->lm_info->tsd_start_addr));
 #endif
 
            new->addr_low = lmi->text_addr;
@@ -692,7 +692,7 @@ som_current_sos (void)
 static int
 som_open_symbol_file_object (void *from_ttyp)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   CORE_ADDR lm, l_name;
   char *filename;
   int errcode;
index f62d96cf57ff4c780735a1b07f4f1a1dfdd715eb..09a40474a754fcddc5c73641d4235aed7496fb02 100644 (file)
@@ -158,7 +158,7 @@ append_ocl_sos (struct so_list **link_ptr)
 static struct so_list *
 spu_current_sos (void)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   struct so_list *head;
   struct so_list **link_ptr;
 
@@ -418,9 +418,9 @@ spu_enable_break (struct objfile *objfile)
     {
       CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (spe_event_sym);
 
-      addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch, addr,
+      addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (), addr,
                                                  &current_target);
-      create_solib_event_breakpoint (target_gdbarch, addr);
+      create_solib_event_breakpoint (target_gdbarch (), addr);
       return 1;
     }
 
index b17ef8a8ddd48e2ec2a2f845b9ba81deb56a9a49..b8b3806bb8f6bb9c94957c4ff921c34817af9356 100644 (file)
@@ -121,7 +121,7 @@ static char *main_name_list[] =
 
 #define SOLIB_EXTRACT_ADDRESS(MEMBER) \
        extract_unsigned_integer (&(MEMBER), sizeof (MEMBER), \
-                                 gdbarch_byte_order (target_gdbarch))
+                                 gdbarch_byte_order (target_gdbarch ()))
 
 /* local data declarations */
 
@@ -141,7 +141,7 @@ static CORE_ADDR flag_addr;
 static CORE_ADDR
 lm_addr (struct so_list *so)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   int lm_addr_offset = offsetof (struct link_map, lm_addr);
   int lm_addr_size = fieldsize (struct link_map, lm_addr);
 
@@ -152,7 +152,7 @@ lm_addr (struct so_list *so)
 static CORE_ADDR
 lm_next (struct so_list *so)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   int lm_next_offset = offsetof (struct link_map, lm_next);
   int lm_next_size = fieldsize (struct link_map, lm_next);
 
@@ -164,7 +164,7 @@ lm_next (struct so_list *so)
 static CORE_ADDR
 lm_name (struct so_list *so)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   int lm_name_offset = offsetof (struct link_map, lm_name);
   int lm_name_size = fieldsize (struct link_map, lm_name);
 
@@ -690,9 +690,9 @@ sunos_solib_create_inferior_hook (int from_tty)
      the GDB software break point list.  Thus we have to adjust the
      PC here.  */
 
-  if (gdbarch_decr_pc_after_break (target_gdbarch))
+  if (gdbarch_decr_pc_after_break (target_gdbarch ()))
     {
-      stop_pc -= gdbarch_decr_pc_after_break (target_gdbarch);
+      stop_pc -= gdbarch_decr_pc_after_break (target_gdbarch ());
       regcache_write_pc (get_current_regcache (), stop_pc);
     }
 
index 3d60aa1ae4f5bec6dd089940183094b2c7632e75..37cc654dbdd58212f68bf25cc736d60e6ea53b35 100644 (file)
@@ -155,12 +155,12 @@ lm_info_read (CORE_ADDR lm_addr)
   if (target_read_memory (lm_addr, lm, lmo->link_map_size) != 0)
     {
       warning (_("Error reading shared library list entry at %s"),
-              paddress (target_gdbarch, lm_addr)),
+              paddress (target_gdbarch (), lm_addr)),
       lm_info = NULL;
     }
   else
     {
-      struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+      struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 
       lm_info = xzalloc (sizeof (*lm_info));
       lm_info->lm_addr = lm_addr;
@@ -264,7 +264,7 @@ lm_addr_check (struct so_list *so, bfd *abfd)
              if (info_verbose)
                printf_unfiltered (_("Using PIC (Position Independent Code) "
                                     "prelink displacement %s for \"%s\".\n"),
-                                  paddress (target_gdbarch, l_addr),
+                                  paddress (target_gdbarch (), l_addr),
                                   so->so_name);
            }
          else
@@ -363,7 +363,7 @@ static int match_main (const char *);
 static gdb_byte *
 read_program_header (int type, int *p_sect_size, int *p_arch_size)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   CORE_ADDR at_phdr, at_phent, at_phnum, pt_phdr = 0;
   int arch_size, sect_size;
   CORE_ADDR sect_addr;
@@ -612,7 +612,7 @@ scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
             gdb_byte ptr_buf[8];
             CORE_ADDR ptr_addr;
 
-            ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+            ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
             ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
             if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
               dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
@@ -632,7 +632,7 @@ scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
 static int
 scan_dyntag_auxv (int dyntag, CORE_ADDR *ptr)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   int sect_size, arch_size, step;
   long dyn_tag;
   CORE_ADDR dyn_ptr;
@@ -709,7 +709,7 @@ elf_locate_base (void)
   if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr)
       || scan_dyntag_auxv (DT_MIPS_RLD_MAP, &dyn_ptr))
     {
-      struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+      struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
       gdb_byte *pbuf;
       int pbuf_size = TYPE_LENGTH (ptr_type);
 
@@ -787,7 +787,7 @@ static CORE_ADDR
 solib_svr4_r_map (struct svr4_info *info)
 {
   struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
-  struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
   CORE_ADDR addr = 0;
   volatile struct gdb_exception ex;
 
@@ -806,7 +806,7 @@ static CORE_ADDR
 solib_svr4_r_brk (struct svr4_info *info)
 {
   struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
-  struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 
   return read_memory_typed_address (info->debug_base + lmo->r_brk_offset,
                                    ptr_type);
@@ -819,8 +819,8 @@ static CORE_ADDR
 solib_svr4_r_ldsomap (struct svr4_info *info)
 {
   struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
-  struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   ULONGEST version;
 
   /* Check version, and return zero if `struct r_debug' doesn't have
@@ -889,7 +889,7 @@ open_symbol_file_object (void *from_ttyp)
   int errcode;
   int from_tty = *(int *)from_ttyp;
   struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
-  struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
   int l_name_size = TYPE_LENGTH (ptr_type);
   gdb_byte *l_name_buf = xmalloc (l_name_size);
   struct cleanup *cleanups = make_cleanup (xfree, l_name_buf);
@@ -1197,8 +1197,8 @@ svr4_read_so_list (CORE_ADDR lm, struct so_list ***link_ptr_ptr,
       if (new->lm_info->l_prev != prev_lm)
        {
          warning (_("Corrupted shared library list: %s != %s"),
-                  paddress (target_gdbarch, prev_lm),
-                  paddress (target_gdbarch, new->lm_info->l_prev));
+                  paddress (target_gdbarch (), prev_lm),
+                  paddress (target_gdbarch (), new->lm_info->l_prev));
          do_cleanups (old_chain);
          break;
        }
@@ -1396,7 +1396,7 @@ exec_entry_point (struct bfd *abfd, struct target_ops *targ)
      gdbarch_convert_from_func_ptr_addr().  The method
      gdbarch_convert_from_func_ptr_addr() is the merely the identify
      function for targets which don't use function descriptors.  */
-  return gdbarch_convert_from_func_ptr_addr (target_gdbarch,
+  return gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
                                             bfd_get_start_address (abfd),
                                             targ);
 }
@@ -1468,7 +1468,7 @@ enable_break (struct svr4_info *info, int from_tty)
       struct obj_section *os;
 
       sym_addr = gdbarch_addr_bits_remove
-       (target_gdbarch, gdbarch_convert_from_func_ptr_addr (target_gdbarch,
+       (target_gdbarch (), gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
                                                             sym_addr,
                                                             &current_target));
 
@@ -1522,7 +1522,7 @@ enable_break (struct svr4_info *info, int from_tty)
                + bfd_section_size (tmp_bfd, interp_sect);
            }
 
-         create_solib_event_breakpoint (target_gdbarch, sym_addr);
+         create_solib_event_breakpoint (target_gdbarch (), sym_addr);
          return 1;
        }
     }
@@ -1585,7 +1585,7 @@ enable_break (struct svr4_info *info, int from_tty)
       if (!load_addr_found)
         if (target_auxv_search (&current_target, AT_BASE, &load_addr) > 0)
          {
-           int addr_bit = gdbarch_addr_bit (target_gdbarch);
+           int addr_bit = gdbarch_addr_bit (target_gdbarch ());
 
            /* Ensure LOAD_ADDR has proper sign in its possible upper bits so
               that `+ load_addr' will overflow CORE_ADDR width not creating
@@ -1621,7 +1621,7 @@ enable_break (struct svr4_info *info, int from_tty)
       if (!load_addr_found)
        {
          struct regcache *regcache
-           = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
+           = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
 
          load_addr = (regcache_read_pc (regcache)
                       - exec_entry_point (tmp_bfd, tmp_bfd_target));
@@ -1669,7 +1669,7 @@ enable_break (struct svr4_info *info, int from_tty)
        /* Convert 'sym_addr' from a function pointer to an address.
           Because we pass tmp_bfd_target instead of the current
           target, this will always produce an unrelocated value.  */
-       sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch,
+       sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
                                                       sym_addr,
                                                       tmp_bfd_target);
 
@@ -1680,7 +1680,7 @@ enable_break (struct svr4_info *info, int from_tty)
 
       if (sym_addr != 0)
        {
-         create_solib_event_breakpoint (target_gdbarch, load_addr + sym_addr);
+         create_solib_event_breakpoint (target_gdbarch (), load_addr + sym_addr);
          xfree (interp_name);
          return 1;
        }
@@ -1703,10 +1703,10 @@ enable_break (struct svr4_info *info, int from_tty)
       if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
        {
          sym_addr = SYMBOL_VALUE_ADDRESS (msymbol);
-         sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch,
+         sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
                                                         sym_addr,
                                                         &current_target);
-         create_solib_event_breakpoint (target_gdbarch, sym_addr);
+         create_solib_event_breakpoint (target_gdbarch (), sym_addr);
          return 1;
        }
     }
@@ -1719,10 +1719,10 @@ enable_break (struct svr4_info *info, int from_tty)
          if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
            {
              sym_addr = SYMBOL_VALUE_ADDRESS (msymbol);
-             sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch,
+             sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
                                                             sym_addr,
                                                             &current_target);
-             create_solib_event_breakpoint (target_gdbarch, sym_addr);
+             create_solib_event_breakpoint (target_gdbarch (), sym_addr);
              return 1;
            }
        }
@@ -1863,7 +1863,7 @@ svr4_exec_displacement (CORE_ADDR *displacementp)
       buf2 = read_program_headers_from_bfd (exec_bfd, &phdrs2_size);
       if (buf != NULL && buf2 != NULL)
        {
-         enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+         enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 
          /* We are dealing with three different addresses.  EXEC_BFD
             represents current address in on-disk file.  target memory content
@@ -2118,7 +2118,7 @@ svr4_exec_displacement (CORE_ADDR *displacementp)
 
       printf_unfiltered (_("Using PIE (Position Independent Executable) "
                           "displacement %s for \"%s\".\n"),
-                        paddress (target_gdbarch, displacement),
+                        paddress (target_gdbarch (), displacement),
                         bfd_get_filename (exec_bfd));
     }
 
@@ -2301,12 +2301,12 @@ svr4_clear_solib (void)
 static CORE_ADDR
 svr4_truncate_ptr (CORE_ADDR addr)
 {
-  if (gdbarch_ptr_bit (target_gdbarch) == sizeof (CORE_ADDR) * 8)
+  if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR) * 8)
     /* We don't need to truncate anything, and the bit twiddling below
        will fail due to overflow problems.  */
     return addr;
   else
-    return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch)) - 1);
+    return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
 }
 
 
@@ -2364,7 +2364,7 @@ set_solib_svr4_fetch_link_map_offsets (struct gdbarch *gdbarch,
 static struct link_map_offsets *
 svr4_fetch_link_map_offsets (void)
 {
-  struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch, solib_svr4_data);
+  struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch (), solib_svr4_data);
 
   gdb_assert (ops->fetch_link_map_offsets);
   return ops->fetch_link_map_offsets ();
@@ -2375,7 +2375,7 @@ svr4_fetch_link_map_offsets (void)
 static int
 svr4_have_link_map_offsets (void)
 {
-  struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch, solib_svr4_data);
+  struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch (), solib_svr4_data);
 
   return (ops->fetch_link_map_offsets != NULL);
 }
index d795678e7f5dc235b75b9abe42152ab71f497953..db3842a54f9e88306a2c1ad8973bd080a6d3ac6a 100644 (file)
@@ -143,12 +143,12 @@ show_solib_search_path (struct ui_file *file, int from_tty,
 char *
 solib_find (char *in_pathname, int *fd)
 {
-  struct target_so_ops *ops = solib_ops (target_gdbarch);
+  struct target_so_ops *ops = solib_ops (target_gdbarch ());
   int found_file = -1;
   char *temp_pathname = NULL;
   int gdb_sysroot_is_empty;
   const char *solib_symbols_extension
-    = gdbarch_solib_symbols_extension (target_gdbarch);
+    = gdbarch_solib_symbols_extension (target_gdbarch ());
   const char *fskind = effective_target_file_system_kind ();
   struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
   char *sysroot = NULL;
@@ -424,7 +424,7 @@ solib_bfd_open (char *pathname)
     }
 
   /* Check bfd arch.  */
-  b = gdbarch_bfd_arch_info (target_gdbarch);
+  b = gdbarch_bfd_arch_info (target_gdbarch ());
   if (!b->compatible (b, bfd_get_arch_info (abfd)))
     warning (_("`%s': Shared library architecture %s is not compatible "
                "with target architecture %s."), bfd_get_filename (abfd),
@@ -448,7 +448,7 @@ solib_bfd_open (char *pathname)
 static int
 solib_map_sections (struct so_list *so)
 {
-  struct target_so_ops *ops = solib_ops (target_gdbarch);
+  struct target_so_ops *ops = solib_ops (target_gdbarch ());
   char *filename;
   struct target_section *p;
   struct cleanup *old_chain;
@@ -549,7 +549,7 @@ free_so_symbols (struct so_list *so)
 void
 free_so (struct so_list *so)
 {
-  struct target_so_ops *ops = solib_ops (target_gdbarch);
+  struct target_so_ops *ops = solib_ops (target_gdbarch ());
 
   free_so_symbols (so);
   ops->free_so (so);
@@ -668,7 +668,7 @@ solib_used (const struct so_list *const known)
 static void
 update_solib_list (int from_tty, struct target_ops *target)
 {
-  struct target_so_ops *ops = solib_ops (target_gdbarch);
+  struct target_so_ops *ops = solib_ops (target_gdbarch ());
   struct so_list *inferior = ops->current_sos();
   struct so_list *gdb, **gdb_link;
 
@@ -930,7 +930,7 @@ solib_add (char *pattern, int from_tty,
 
     if (loaded_any_symbols)
       {
-       struct target_so_ops *ops = solib_ops (target_gdbarch);
+       struct target_so_ops *ops = solib_ops (target_gdbarch ());
 
        /* Getting new symbols may change our opinion about what is
           frameless.  */
@@ -954,7 +954,7 @@ info_sharedlibrary_command (char *pattern, int from_tty)
   int addr_width;
   int nr_libs;
   struct cleanup *table_cleanup;
-  struct gdbarch *gdbarch = target_gdbarch;
+  struct gdbarch *gdbarch = target_gdbarch ();
   struct ui_out *uiout = current_uiout;
 
   if (pattern)
@@ -1103,7 +1103,7 @@ solib_name_from_address (struct program_space *pspace, CORE_ADDR address)
 int
 solib_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
 {
-  struct target_so_ops *ops = solib_ops (target_gdbarch);
+  struct target_so_ops *ops = solib_ops (target_gdbarch ());
 
   if (ops->keep_data_in_core)
     return ops->keep_data_in_core (vaddr, size);
@@ -1116,7 +1116,7 @@ solib_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
 void
 clear_solib (void)
 {
-  struct target_so_ops *ops = solib_ops (target_gdbarch);
+  struct target_so_ops *ops = solib_ops (target_gdbarch ());
 
   /* This function is expected to handle ELF shared libraries.  It is
      also used on Solaris, which can run either ELF or a.out binaries
@@ -1164,7 +1164,7 @@ clear_solib (void)
 void
 solib_create_inferior_hook (int from_tty)
 {
-  struct target_so_ops *ops = solib_ops (target_gdbarch);
+  struct target_so_ops *ops = solib_ops (target_gdbarch ());
 
   ops->solib_create_inferior_hook (from_tty);
 }
@@ -1175,7 +1175,7 @@ solib_create_inferior_hook (int from_tty)
 int
 in_solib_dynsym_resolve_code (CORE_ADDR pc)
 {
-  struct target_so_ops *ops = solib_ops (target_gdbarch);
+  struct target_so_ops *ops = solib_ops (target_gdbarch ());
 
   return ops->in_dynsym_resolve_code (pc);
 }
@@ -1277,7 +1277,7 @@ reload_shared_libraries (char *ignored, int from_tty,
 
   reload_shared_libraries_1 (from_tty);
 
-  ops = solib_ops (target_gdbarch);
+  ops = solib_ops (target_gdbarch ());
 
   /* Creating inferior hooks here has two purposes.  First, if we reload 
      shared libraries then the address of solib breakpoint we've computed
@@ -1344,7 +1344,7 @@ solib_global_lookup (const struct objfile *objfile,
                     const char *name,
                     const domain_enum domain)
 {
-  struct target_so_ops *ops = solib_ops (target_gdbarch);
+  struct target_so_ops *ops = solib_ops (target_gdbarch ());
 
   if (ops->lookup_lib_global_symbol != NULL)
     return ops->lookup_lib_global_symbol (objfile, name, domain);
index 1932aae6adad6ddb95d88b4dfdf9249a2a54d870..1db97cebedfc1b41a010115a1f0e5343b35dc624 100644 (file)
@@ -206,7 +206,7 @@ store_ppc_memory (ULONGEST memaddr, const gdb_byte *myaddr, int len)
 static int 
 parse_spufs_run (int *fd, ULONGEST *addr)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   gdb_byte buf[4];
   ULONGEST pc = fetch_ppc_register (32);  /* nip */
 
index 8d4ef570dcad725197a20e5e771ff6c747ebf6d4..5ace7c590bc3c4c5c892cff22380f8a1540f86e0 100644 (file)
@@ -57,19 +57,19 @@ static int spu_nr_solib;
 static int
 parse_spufs_run (ptid_t ptid, int *fd, CORE_ADDR *addr)
 {
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   struct gdbarch_tdep *tdep;
   struct regcache *regcache;
   char buf[4];
   ULONGEST regval;
 
   /* If we're not on PPU, there's nothing to detect.  */
-  if (gdbarch_bfd_arch_info (target_gdbarch)->arch != bfd_arch_powerpc)
+  if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_powerpc)
     return 0;
 
   /* Get PPU-side registers.  */
-  regcache = get_thread_arch_regcache (ptid, target_gdbarch);
-  tdep = gdbarch_tdep (target_gdbarch);
+  regcache = get_thread_arch_regcache (ptid, target_gdbarch ());
+  tdep = gdbarch_tdep (target_gdbarch ());
 
   /* Fetch instruction preceding current NIP.  */
   if (target_read_memory (regcache_read_pc (regcache) - 4, buf, 4) != 0)
@@ -113,7 +113,7 @@ spu_thread_architecture (struct target_ops *ops, ptid_t ptid)
   if (parse_spufs_run (ptid, &spufs_fd, &spufs_addr))
     return spu_gdbarch (spufs_fd);
 
-  return target_gdbarch;
+  return target_gdbarch ();
 }
 
 /* Override the to_region_ok_for_hw_watchpoint routine.  */
index 8419a5a7124ef5ff1903d04352a1b4d6dfdc3d27..85baf3eed3f137c76786884fef441e9e68bf044f 100644 (file)
@@ -1186,7 +1186,7 @@ spu2ppu_sniffer (const struct frame_unwind *self,
   CORE_ADDR base, func, backchain;
   gdb_byte buf[4];
 
-  if (gdbarch_bfd_arch_info (target_gdbarch)->arch == bfd_arch_spu)
+  if (gdbarch_bfd_arch_info (target_gdbarch ())->arch == bfd_arch_spu)
     return 0;
 
   base = get_frame_sp (this_frame);
@@ -1217,7 +1217,7 @@ spu2ppu_sniffer (const struct frame_unwind *self,
       else
        {
          struct regcache *regcache;
-         regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
+         regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
          cache->regcache = regcache_dup (regcache);
          *this_prologue_cache = cache;
          return 1;
index 2e53be05de42b91280062a4a16f4a61b1cc2b3f4..1b1e456c885029cd0719b5b34cc2d13b001625c4 100644 (file)
@@ -220,7 +220,7 @@ add_vsyscall_page (struct target_ops *target, int from_tty)
       args.bfd = bfd;
       args.sysinfo_ehdr = sysinfo_ehdr;
       args.name = xstrprintf ("system-supplied DSO at %s",
-                             paddress (target_gdbarch, sysinfo_ehdr));
+                             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 6cac666f663eceba41925c24c00e5cd364a9c598..55af541e93c077af4b7432ea032b4614a06b7dfd 100644 (file)
@@ -1957,7 +1957,7 @@ load_progress (ULONGEST bytes, void *untyped_arg)
         this section.  */
       ui_out_message (current_uiout, 0, "Loading section %s, size %s lma %s\n",
                      args->section_name, hex_string (args->section_size),
-                     paddress (target_gdbarch, args->lma));
+                     paddress (target_gdbarch (), args->lma));
       return;
     }
 
@@ -1975,10 +1975,10 @@ load_progress (ULONGEST bytes, void *untyped_arg)
 
       if (target_read_memory (args->lma, check, bytes) != 0)
        error (_("Download verify read failed at %s"),
-              paddress (target_gdbarch, args->lma));
+              paddress (target_gdbarch (), args->lma));
       if (memcmp (args->buffer, check, bytes) != 0)
        error (_("Download verify compare failed at %s"),
-              paddress (target_gdbarch, args->lma));
+              paddress (target_gdbarch (), args->lma));
       do_cleanups (verify_cleanups);
     }
   totals->data_count += bytes;
@@ -2133,7 +2133,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", "%s", paddress (target_gdbarch, 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");
index 7e1622226a214d30db8a993dee337b88d358b6d0..65542a79e5224c49cfca378c390fa63d3934db3d 100644 (file)
@@ -1767,7 +1767,7 @@ lookup_symbol_global (const char *name,
   lookup_data.name = name;
   lookup_data.domain = domain;
   gdbarch_iterate_over_objfiles_in_search_order
-    (objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch,
+    (objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (),
      lookup_symbol_global_iterator_cb, &lookup_data, objfile);
 
   return lookup_data.result;
index 468fe4274cc9266cdea395c3b264f09e83e60191..12593df6525cd2a544180fc174c73b6b5478952d 100644 (file)
@@ -334,7 +334,7 @@ target_find_description (void)
   /* The current architecture should not have any target description
      specified.  It should have been cleared, e.g. when we
      disconnected from the previous target.  */
-  gdb_assert (gdbarch_target_desc (target_gdbarch) == NULL);
+  gdb_assert (gdbarch_target_desc (target_gdbarch ()) == NULL);
 
   /* First try to fetch an XML description from the user-specified
      file.  */
@@ -367,7 +367,7 @@ target_find_description (void)
        {
          struct tdesc_arch_data *data;
 
-         data = gdbarch_data (target_gdbarch, tdesc_data);
+         data = gdbarch_data (target_gdbarch (), tdesc_data);
          if (tdesc_has_registers (current_target_desc)
              && data->arch_regs == NULL)
            warning (_("Target-supplied registers are not supported "
index 62de33632dbb8fc09144f52b2f23856a94861599..5015e5196cff6f432c6558b11b83449554f766fb 100644 (file)
@@ -1128,7 +1128,7 @@ target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
     }
 
   if (target != NULL
-      && gdbarch_fetch_tls_load_module_address_p (target_gdbarch))
+      && gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
     {
       ptid_t ptid = inferior_ptid;
       volatile struct gdb_exception ex;
@@ -1138,7 +1138,7 @@ target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
          CORE_ADDR lm_addr;
          
          /* Fetch the load module address for this objfile.  */
-         lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch,
+         lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch (),
                                                           objfile);
          /* If it's 0, throw the appropriate exception.  */
          if (lm_addr == 0)
@@ -2497,7 +2497,7 @@ target_pre_inferior (int from_tty)
   /* In some OSs, the shared library list is the same/global/shared
      across inferiors.  If code is shared between processes, so are
      memory regions and features.  */
-  if (!gdbarch_has_global_solist (target_gdbarch))
+  if (!gdbarch_has_global_solist (target_gdbarch ()))
     {
       no_shared_libraries (NULL, from_tty);
 
@@ -2566,7 +2566,7 @@ target_detach (char *args, int from_tty)
 {
   struct target_ops* t;
   
-  if (gdbarch_has_global_breakpoints (target_gdbarch))
+  if (gdbarch_has_global_breakpoints (target_gdbarch ()))
     /* Don't remove global breakpoints here.  They're removed on
        disconnection from the target.  */
     ;
@@ -3554,7 +3554,7 @@ target_fileio_read_stralloc (const char *filename)
 static int
 default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
 {
-  return (len <= gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT);
+  return (len <= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT);
 }
 
 static int
@@ -3568,7 +3568,7 @@ default_watchpoint_addr_within_range (struct target_ops *target,
 static struct gdbarch *
 default_thread_architecture (struct target_ops *ops, ptid_t ptid)
 {
-  return target_gdbarch;
+  return target_gdbarch ();
 }
 
 static int
@@ -4055,7 +4055,7 @@ target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
          if (targetdebug)
            fprintf_unfiltered (gdb_stdlog,
                                "target_verify_memory (%s, %s) = %d\n",
-                               paddress (target_gdbarch, memaddr),
+                               paddress (target_gdbarch (), memaddr),
                                pulongest (size),
                                retval);
          return retval;
@@ -4169,7 +4169,7 @@ deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
 
   fprintf_unfiltered (gdb_stdlog,
                      "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
-                     paddress (target_gdbarch, memaddr), len,
+                     paddress (target_gdbarch (), memaddr), len,
                      write ? "write" : "read", retval);
 
   if (retval > 0)
index 9a8dda8a81aea1fd90407f91dc8f0cb427b7fd07..7907ee11729c8e2cb3bce5f8ee66540af0114300 100644 (file)
@@ -687,9 +687,9 @@ struct target_ops
        to_thread_architecture would return SPU, otherwise PPC32 or PPC64).
        This is architecture used to perform decr_pc_after_break adjustment,
        and also determines the frame architecture of the innermost frame.
-       ptrace operations need to operate according to target_gdbarch.
+       ptrace operations need to operate according to target_gdbarch ().
 
-       The default implementation always returns target_gdbarch.  */
+       The default implementation always returns target_gdbarch ().  */
     struct gdbarch *(*to_thread_architecture) (struct target_ops *, ptid_t);
 
     /* Determine current address space of thread PTID.
index 6e55d57033de30695fb3c089eb2e779324ca44dd..912341af710cf5f7472de926d399ee3e9732d352 100644 (file)
@@ -4206,7 +4206,7 @@ tfile_get_traceframe_address (off_t tframe_offset)
   tfile_read ((gdb_byte *) &tpnum, 2);
   tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
                                          gdbarch_byte_order
-                                             (target_gdbarch));
+                                             (target_gdbarch ()));
 
   tp = get_tracepoint_by_number_on_target (tpnum);
   /* FIXME this is a poor heuristic if multiple locations.  */
@@ -4250,14 +4250,14 @@ tfile_trace_find (enum trace_find_type type, int num,
       tfile_read ((gdb_byte *) &tpnum, 2);
       tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
                                              gdbarch_byte_order
-                                                 (target_gdbarch));
+                                                 (target_gdbarch ()));
       offset += 2;
       if (tpnum == 0)
        break;
       tfile_read ((gdb_byte *) &data_size, 4);
       data_size = (unsigned int) extract_unsigned_integer
                                      ((gdb_byte *) &data_size, 4,
-                                     gdbarch_byte_order (target_gdbarch));
+                                     gdbarch_byte_order (target_gdbarch ()));
       offset += 4;
       switch (type)
        {
@@ -4365,7 +4365,7 @@ traceframe_walk_blocks (walk_blocks_callback_func callback,
           mlen = (unsigned short)
                 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
                                           gdbarch_byte_order
-                                              (target_gdbarch));
+                                              (target_gdbarch ()));
          lseek (trace_fd, mlen, SEEK_CUR);
          pos += (8 + 2 + mlen);
          break;
@@ -4502,7 +4502,7 @@ tfile_xfer_partial (struct target_ops *ops, enum target_object object,
        {
          ULONGEST maddr, amt;
          unsigned short mlen;
-         enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+         enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 
          tfile_read ((gdb_byte *) &maddr, 8);
          maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
@@ -4585,13 +4585,13 @@ tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
       tfile_read ((gdb_byte *) &vnum, 4);
       vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
                                           gdbarch_byte_order
-                                          (target_gdbarch));
+                                          (target_gdbarch ()));
       if (tsvnum == vnum)
        {
          tfile_read ((gdb_byte *) val, 8);
          *val = extract_signed_integer ((gdb_byte *) val, 8,
                                         gdbarch_byte_order
-                                        (target_gdbarch));
+                                        (target_gdbarch ()));
          return 1;
        }
       pos += (4 + 8);
@@ -4739,7 +4739,7 @@ parse_static_tracepoint_marker_definition (char *line, char **pp,
   p = unpack_varlen_hex (p, &addr);
   p++;  /* skip a colon */
 
-  marker->gdbarch = target_gdbarch;
+  marker->gdbarch = target_gdbarch ();
   marker->address = (CORE_ADDR) addr;
 
   endp = strchr (p, ':');
@@ -4916,7 +4916,7 @@ info_static_tracepoint_markers_command (char *arg, int from_tty)
   ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
 
   ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
-  if (gdbarch_addr_bit (target_gdbarch) <= 32)
+  if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
     ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
   else
     ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
index 5eb8f6710a9069477894a6083cdd276a8a5f49b9..a8766cd5500a43de0980e16968a24fb3ecdefc38 100644 (file)
@@ -2404,7 +2404,7 @@ windows_xfer_shared_libraries (struct target_ops *ops,
   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,
-                                target_gdbarch, &obstack);
+                                target_gdbarch (), &obstack);
   obstack_grow_str0 (&obstack, "</library-list>\n");
 
   buf = obstack_finish (&obstack);
index 116525c9fa290c175a045599222288fd35a19915..9c89e920a2441a9d1e58c5fc4abd1f3481641ef7 100644 (file)
@@ -290,8 +290,8 @@ display_one_tib (ptid_t ptid)
   gdb_byte *index;
   CORE_ADDR thread_local_base;
   ULONGEST i, val, max, max_name, size, tib_size;
-  ULONGEST sizeof_ptr = gdbarch_ptr_bit (target_gdbarch);
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+  ULONGEST sizeof_ptr = gdbarch_ptr_bit (target_gdbarch ());
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 
   if (sizeof_ptr == 64)
     {
@@ -329,13 +329,13 @@ display_one_tib (ptid_t ptid)
       printf_filtered (_("Unable to read thread information "
                         "block for %s at address %s\n"),
        target_pid_to_str (ptid), 
-       paddress (target_gdbarch, thread_local_base));
+       paddress (target_gdbarch (), thread_local_base));
       return -1;
     }
 
   printf_filtered (_("Thread Information Block %s at %s\n"),
                   target_pid_to_str (ptid),
-                  paddress (target_gdbarch, thread_local_base));
+                  paddress (target_gdbarch (), thread_local_base));
 
   index = (gdb_byte *) tib;
 
index 46cf808a85a8cde221cf19fe29c91bdbb0120c15..b72be5ccdd6d45e63d56b3206295f45e992d22c0 100644 (file)
@@ -62,7 +62,7 @@ static void sharedlibrary_command (char *pattern, int from_tty);
 static void
 solib_info (char *args, int from_tty)
 {
-  int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;
+  int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
   struct vmap *vp = vmap;
 
   /* Check for new shared libraries loaded with load ().  */