Merge GDB 7.5.1

gdb/hppa-hpux-tdep.c

 /* Target-dependent code for HP-UX on PA-RISC.
 
    Copyright (C) 2002-2005, 2007-2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
@@ skipping 159 matching lines @@
      stub and return.
 
      Then see if the PC value falls within the section bounds for the
      section containing the minimal symbol we found in the first
      step.  If it does, then assume we are not in a stub and return.
 
      Finally peek at the instructions to see if they look like a stub.  */
   struct minimal_symbol *minsym;
   asection *sec;
   CORE_ADDR addr;
-  int insn, i;
+  int insn;
 
   minsym = lookup_minimal_symbol_by_pc (pc);
   if (! minsym)
     return 0;
 
   sec = SYMBOL_OBJ_SECTION (minsym)->the_bfd_section;
 
   if (bfd_get_section_vma (sec->owner, sec) <= pc
       && pc < (bfd_get_section_vma (sec->owner, sec)
                  + bfd_section_size (sec->owner, sec)))
@@ skipping 32 matching lines @@
   return 1;
 }
 
 /* Return one if PC is in the return path of a trampoline, else return zero.
 
    Note we return one for *any* call trampoline (long-call, arg-reloc), not
    just shared library trampolines (import, export).  */
 
 static int
 hppa_hpux_in_solib_return_trampoline (struct gdbarch *gdbarch,
-                                      CORE_ADDR pc, char *name)
+                                      CORE_ADDR pc, const char *name)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   struct unwind_table_entry *u;
 
   /* Get the unwind descriptor corresponding to PC, return zero
      if no unwind was found.  */
   u = find_unwind_entry (pc);
   if (!u)
     return 0;
 
@@ skipping 705 matching lines @@
 static CORE_ADDR
 hppa64_hpux_search_dummy_call_sequence (struct gdbarch *gdbarch, CORE_ADDR pc,
                                         int *argreg)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   struct objfile *obj;
   struct obj_section *sec;
   struct hppa_objfile_private *priv;
   CORE_ADDR addr;
   struct minimal_symbol *msym;
-  int i;
 
   sec = find_pc_section (pc);
   obj = sec->objfile;
   priv = objfile_data (obj, hppa_objfile_priv_data);
 
   if (!priv)
     priv = hppa_init_objfile_priv_data (obj);
   if (!priv)
     error (_("Internal error creating objfile private data."));
 
   /* Use the cached value if we have one.  */
   if (priv->dummy_call_sequence_addr != 0)
     {
       *argreg = priv->dummy_call_sequence_reg;
       return priv->dummy_call_sequence_addr;
     }
 
   /* FIXME: Without stub unwind information, locating a suitable sequence is
      fairly difficult.  For now, we implement a very naive and inefficient
      scheme; try to read in blocks of code, and look for a "bve,n (rp)" 
      instruction.  These are likely to occur at the end of functions, so
      we only look at the last two instructions of each function.  */
-  for (i = 0, msym = obj->msymbols; i < obj->minimal_symbol_count; i++, msym++)
+  ALL_OBJFILE_MSYMBOLS (obj, msym)
     {
       CORE_ADDR begin, end;
-      char *name;
+      const char *name;
       gdb_byte buf[2 * HPPA_INSN_SIZE];
       int offset;
 
       find_pc_partial_function (SYMBOL_VALUE_ADDRESS (msym), &name,
                                 &begin, &end);
 
       if (name == NULL || begin == 0 || end == 0)
         continue;
 
       if (target_read_memory (end - sizeof (buf), buf, sizeof (buf)) == 0)
@@ skipping 84 matching lines @@
      prematurely.  Instead, we try to look for an address in the same space to 
      put the breakpoint.  
      
      This is similar in spirit to putting the breakpoint at the "entry point"
      of an executable.  */
 
   struct obj_section *sec;
   struct unwind_table_entry *u;
   struct minimal_symbol *msym;
   CORE_ADDR func;
-  int i;
 
   sec = find_pc_section (addr);
   if (sec)
     {
       /* First try the lowest address in the section; we can use it as long
          as it is "regular" code (i.e. not a stub).  */
       u = find_unwind_entry (obj_section_addr (sec));
       if (!u || u->stub_unwind.stub_type == 0)
         return obj_section_addr (sec);
 
       /* Otherwise, we need to find a symbol for a regular function.  We
          do this by walking the list of msymbols in the objfile.  The symbol
          we find should not be the same as the function that was passed in.  */
 
       /* FIXME: this is broken, because we can find a function that will be
          called by the dummy call target function, which will still not 
          work.  */
 
       find_pc_partial_function (addr, NULL, &func, NULL);
-      for (i = 0, msym = sec->objfile->msymbols;
-           i < sec->objfile->minimal_symbol_count;
-           i++, msym++)
+      ALL_OBJFILE_MSYMBOLS (sec->objfile, msym)
         {
           u = find_unwind_entry (SYMBOL_VALUE_ADDRESS (msym));
           if (func != SYMBOL_VALUE_ADDRESS (msym) 
               && (!u || u->stub_unwind.stub_type == 0))
             return SYMBOL_VALUE_ADDRESS (msym);
         }
     }
 
   warning (_("Cannot find suitable address to place dummy breakpoint; nested "
              "calls may fail."));
@@ skipping 458 matching lines @@
                                   hppa_hpux_core_osabi_sniffer);
   gdbarch_register_osabi_sniffer (bfd_arch_hppa,
                                   bfd_target_elf_flavour,
                                   hppa_hpux_core_osabi_sniffer);
 
   gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_HPUX_SOM,
                           hppa_hpux_som_init_abi);
   gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, GDB_OSABI_HPUX_ELF,
                           hppa_hpux_elf_init_abi);
 }