Mostly rs6000 changes from IBM.

12 files changed, 1222 insertions, 406 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 26bce5f..821d3c0 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,30 @@
+Thu Feb 27 22:57:19 1992  Per Bothner  (bothner@cygnus.com)
+
+	* rs6k-opcode.h, tm-rs6000.h, xm-rs6000.h, rs6000-tdep.c,
+	rs6000-xdep.c, xcoffexec.c, xcoffread.c:
+	Merge in changes (mostly from IBM) for RS6000.
+	* breakpoint.c, buildsym.c, infptrace.c, stack.c, symtab.c:
+	More changes from IBM for RS6000.  These are in machine-
+	independent code, and probably could do with some cleaning
+	up.  The most questionable of these are #ifdef IBM6000.
+	* infrun.c, sparc-tdep.c: Pass a parameter (signal number)
+	to single_step() (for consistency with rs6000 and i860).
+	* utils.c:  Allow the 1st arg to xrealloc to be NULL
+	(in which case do malloc).  This removes the need for
+	some tests in xcoff code (and perhaps other places?).
+	* coffread.c: Removed variables last_source_file,
+	type_vector, and type_vector_length as these are now
+	defined by buildsym.[ch].
+	* defs.h:  Remove prototypes for malloc and realloc, since
+	these should only be used to implement xmalloc and xrealloc,
+	and they conflict with <stdlib.h> in AIX - where they
+	return void* even when __STDC__ isn't defined.  Sigh.
+	* munch:  Recognize *initialize* in data as well as text
+	(AIX uses data).  Also, incorporate a patch from Garrett
+	Wollman <wollman@uvm-gen.uvm.edu> to make the sed script
+	much more sensible, by only trying to match the name of
+	the initialize_foo function, and not the junk before it.
+	
 Thu Feb 27 20:07:43 1992  Stu Grossman  (grossman at cygnus.com)
 
 	* breakpoint.c (breakpoint_re_set_one):  Don't reset breakpoint
diff --git a/gdb/buildsym.c b/gdb/buildsym.c
index 11d5091..d71bdd0 100644
--- a/gdb/buildsym.c
+++ b/gdb/buildsym.c
@@ -842,6 +842,10 @@ end_symtab (end_addr, sort_pending, sort_linevec, objfile)
     blockvector = make_blockvector (objfile);
   }
 
+#ifdef PROCESS_LINENUMBER_HOOK
+    PROCESS_LINENUMBER_HOOK ();			/* Needed for aixcoff. */
+#endif
+
   /* Now create the symtab objects proper, one for each subfile.  */
   /* (The main file is the last one on the chain.)  */
 
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 3be0bb9..f8bc976 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -307,7 +307,7 @@ resume (step, sig)
 
 #ifdef NO_SINGLE_STEP
   if (step) {
-    single_step();	/* Do it the hard way, w/temp breakpoints */
+    single_step(sig);	/* Do it the hard way, w/temp breakpoints */
     step = 0;		/* ...and don't ask hardware to do it.  */
   }
 #endif
@@ -555,7 +555,7 @@ child_create_inferior (exec_file, allargs, env)
 #ifdef NEED_POSIX_SETPGID
       debug_setpgrp = setpgid (0, 0);
 #else
-#ifdef USG
+#if defined(USG) && !defined(SETPGRP_ARGS)
       debug_setpgrp = setpgrp ();
 #else
       debug_setpgrp = setpgrp (getpid (), getpid ());
@@ -916,7 +916,7 @@ wait_for_inferior ()
 	     will be set and we should check whether we've hit the
 	     step breakpoint.  */
 	  if (stop_signal == SIGTRAP && trap_expected
-	      && step_resume_break_address == NULL)
+	      && step_resume_break_address == 0)
 	    bpstat_clear (&stop_bpstat);
 	  else
 	    {
@@ -1046,7 +1046,7 @@ wait_for_inferior ()
 		/* Need to blow away step-resume breakpoint, as it
 		   interferes with us */
 		remove_step_breakpoint ();
-		step_resume_break_address = NULL;
+		step_resume_break_address = 0;
 		stop_step_resume_break = 0;
 
 #if 0				/* FIXME - Need to implement nested temporary breakpoints */
@@ -1409,7 +1409,7 @@ wait_for_inferior ()
 	      breakpoints_inserted = 0;
 	    }
 	  else if (!breakpoints_inserted &&
-		   (step_resume_break_address != NULL || !another_trap))
+		   (step_resume_break_address != 0 || !another_trap))
 	    {
 	      insert_step_breakpoint ();
 	      breakpoints_failed = insert_breakpoints ();
diff --git a/gdb/munch b/gdb/munch
index 7b1202f..7d96a47 100755
--- a/gdb/munch
+++ b/gdb/munch
@@ -20,7 +20,7 @@ if test "`$MUNCH_NM main.o | egrep main | egrep FUNC | egrep GLOB`" != "" ; then
     # System V Release 4 style nm
     $MUNCH_NM $* | egrep '|__?initialize_' | egrep FUNC | \
 	sed -e 's/^.*\(_initialize_[a-zA-Z0-9_]*\).*$/   {extern void \1 (); \1 ();}/'
-elif test "`$MUNCH_NM main.o | egrep 'T _?main$'`" = "" ; then
+elif test "`$MUNCH_NM main.o | egrep '[TD] _?main$'`" = "" ; then
     # System V style nm
     shift;
     $MUNCH_NM $* | egrep '^(.*[^a-zA-Z_]_|_)_?initialize_.*\.text' | \
@@ -28,8 +28,8 @@ elif test "`$MUNCH_NM main.o | egrep 'T _?main$'`" = "" ; then
 else
     # BSD style nm
     # We now accept either text or data symbols, since the RT/PC uses data.
-    $MUNCH_NM -p $* | egrep '[TD] *_?_initialize_' | \
-	sed -e 's/^.*[TD] *_*\(.*\)/    {extern void _\1 (); _\1 ();}/'
+    $MUNCH_NM -p $* | egrep '[TD] *_?[_.]initialize_' | \
+	sed -e 's/^.*\(initialize_.*\)/    {extern void _\1 (); _\1 ();}/'
 fi
 
 echo '}'
diff --git a/gdb/rs6000-tdep.c b/gdb/rs6000-tdep.c
index eb203b2..e90222f 100644
--- a/gdb/rs6000-tdep.c
+++ b/gdb/rs6000-tdep.c
@@ -46,190 +46,6 @@ extern int attach_flag;
 /* Nonzero if we just simulated a single step break. */
 int one_stepped;
 
-#if 0
-
-/* This is Damon's implementation of single step simulation. It suffers the
-   following program:
-
-   1 main () {
-   2   char buf[10];
-   3   puts ("test");
-   4   strcmp (buf, "test");  puts ("test");
-   5   exit (0);
-   6 }
-
-   You cannot `next' on line 4 in the above program. gdb puts a breakpoint
-   to the return address of `strcmp', and when execution arrives that point,
-   it is still in the line range and gdb attemps to resume it with single 
-   steps. At that point the breakpoint at step_resume_break_address (return 
-   address of strcmp) and single step's breakpoint mixes up and we end up
-   with a breakpoint which its shadow and itself are identical.
-
-   Fix that problem and use this version. FIXMEmgo.
-*/
-
-
-static struct sstep_breaks {
-	int address;
-	int data;
-} tbreak[2];
-
-
-/*
- * branch_dest -	calculate all places the current instruction may go
- */
-static
-branch_dest(tb)
-     register struct sstep_breaks *tb; 
-{
-    register ulong opcode, iar;
-    long instr;
-    int immediate, absolute;;
-
-    iar = read_pc();					/* current IAR	*/
-    target_read_memory(iar, &instr, sizeof (instr));	/* current inst	*/
-
-    opcode   = instr >> 26;
-    absolute = instr & 2;
-
-    tb[1].address = -1;
-
-    switch (opcode) {
-      case 0x10:			/* branch conditional	*/
-	immediate = ((instr & ~3) << 16) >> 16;
-
-	/*
-	 * two possible locations for next instruction
-	 */
-	tb[0].address = iar + 4;
-	tb[1].address = immediate + (absolute ? 0 : iar);
-
-	break;
-
-      case 0x12:			/* branch unconditional	*/
-	immediate = ((instr & ~3) << 6) >> 6;
-
-	/*
-	 * only one possible location for next instr
-	 */
-	tb[0].address = immediate + (absolute ? 0 : iar);
-
-	break;
-
-      case 0x13:			/* branch conditional register	*/
-	/*
-	 * WE NEED TO CHECK THE CR HERE, TO SEE IF THIS IS
-	 * REALLY UNCONDITIONAL.
-	 */
-	tb++->address = iar + 4;
-
-	switch ((instr >> 1) & 0x3ff) {
-	  case 0x10:			/* branch conditional register	*/
-	    tb->address = read_register(LR_REGNUM) & ~3;
-	    sigtramp_chk(tb);		/* return from sig handler?	*/
-	    break;
-
-	  case 0x210:			/* branch cond to CTR		*/
-	    tb->address = read_register(CTR_REGNUM) & ~3;
-	    sigtramp_chk(tb);		/* return from sig handler?	*/
-	    break;
-
-	  default:
-	    /*
-	     * not a branch.
-	     */
-	    tb->address = iar + 4;
-	    break;
-	}
-	break;
-	
-      default:
-	/*
-	 * not a branch, flow proceeds normally
-	 */
-	tb->address = iar + 4;
-	break;
-    }
-}
-
-/*
- * sigtramp_chk -	heuristic check to see if we think we are returning
- *			from a signal handler.
- *
- * Input:
- *	tb	-	^ to a single step branch location
- *
- * Note:
- *	When we are at the "br" instruction returning to a signal handler,
- *	we return in user mode to an address in the kernel.  If the
- *	segment of the branch target is 0, we may very well be in a
- *	signal handler.  From scrounging through this code, we note that
- *	register 29 has the signal context pointer, from which we can
- *	determine where we will end up next.
- */
-sigtramp_chk(tb)
-register struct sstep_breaks *tb; {
-    struct sigcontext sc;
-
-    if (tb->address & 0xf0000000)
-	return;		/* can't have been sigtramp	*/
-
-    if (target_read_memory(read_register(GPR29), &sc, sizeof (sc)))
-	return;		/* read fails, heuristic fails	*/
-
-    if ((sc.sc_jmpbuf.jmp_context.iar & 0xf0000000) == 0x10000000) {
-	/*
-	 * looks like it might be ok.....
-	 */
-	tb->address = sc.sc_jmpbuf.jmp_context.iar;
-    }
-}
-
-
-/*
- * single_step -	no trace mode harware support, or software support.
- *			sigh.
- */
-single_step(signal) {
-    register i;
-
-    if (!one_stepped) {
-	/*
-	 * need to set breakpoints for single step.
-	 * figure out all places the current instruction could go.
-	 */
-	branch_dest(&tbreak[0]);
-
-	/*
-	 * always at least one place to go to
-	 */
-	target_insert_breakpoint(tbreak[0].address, &tbreak[0].data);
-
-	/*
-	 * if there is another possible location, set a breakpoint there
-	 * as well.
-	 */
-	if (tbreak[1].address != -1)
-	    target_insert_breakpoint(tbreak[1].address, &tbreak[1].data);
-
-	one_stepped = 1;
-	ptrace(PT_CONTINUE, inferior_pid, 1, signal, 0);
-    } else {
-	/*
-	 * need to clear the breakpoints.
-	 */
-	for (i = 0; i < 2; ++i)
-	    if (tbreak[i].address != -1)
-		target_remove_breakpoint(tbreak[i].address, &tbreak[i].data);
-
-	one_stepped = 0;
-    }
-
-    return 1;
-}
-
-#else	/* !DAMON'S VERSION */
-
 /* Breakpoint shadows for the single step instructions will be kept here. */
 
 static struct sstep_breaks {
@@ -280,7 +96,7 @@ branch_dest (opcode, instr, pc, safety)
 	
        default: return -1;
   }
-  return (dest < 0x10000000) ? safety : dest;
+  return (dest < TEXT_SEGMENT_BASE) ? safety : dest;
 }
 
 
@@ -309,6 +125,10 @@ int signal;
     opcode = insn >> 26;
     breaks[1] = branch_dest (opcode, insn, loc, breaks[0]);
 
+    /* Don't put two breakpoints on the same address. */
+    if (breaks[1] == breaks[0])
+      breaks[1] = -1;
+
     stepBreaks[1].address = -1;
 
     for (ii=0; ii < 2; ++ii) {
@@ -324,7 +144,7 @@ int signal;
     }  
 
     one_stepped = 1;
-    ptrace (PT_CONTINUE, inferior_pid, 1, signal);
+    ptrace (PT_CONTINUE, inferior_pid, 1, signal, 0);
   }
   else {
 
@@ -336,10 +156,9 @@ int signal;
 
     one_stepped = 0;
   }
+  errno = 0;
   return 1;
 }
-#endif /* !DAMON's version of single step. */
-
 
 
 /* return pc value after skipping a function prologue. */
@@ -360,8 +179,6 @@ int pc;
     pc += 4;
     op = read_memory_integer (pc, 4);
   }
-  else				/* else, this is a frameless invocation */
-    return pc;
 
   if ((op & 0xfc00003e) == 0x7c000026) { /* mfcr Rx */
     pc += 4;
@@ -373,10 +190,12 @@ int pc;
     op = read_memory_integer (pc, 4);
   }
 
+#if 0
   if ((op & 0xfc1f0000) == 0xd8010000) { /* stfd Rx,NUM(r1) */
     pc += 4;				 /* store floating register double */
     op = read_memory_integer (pc, 4);
   }
+#endif
 
   if ((op & 0xfc1f0000) == 0xbc010000) { /* stm Rx, NUM(r1) */
     pc += 4;
@@ -396,23 +215,32 @@ int pc;
     op = read_memory_integer (pc, 4);
   }
 
-  while ((op & 0xfc1f0000) == 0x90010000) {	/* st r?, NUM(r1) */  
-    pc += 4;
-    op = read_memory_integer (pc, 4);
-  }
+   /* store parameters into stack */
+  while(
+	(op & 0xfc1f0000) == 0xd8010000 || 	/* stfd Rx,NUM(r1) */
+	(op & 0xfc1f0000) == 0x90010000 ||	/* st r?, NUM(r1)  */
+	(op & 0xfc000000) == 0xfc000000 ||	/* frsp, fp?, .. */
+	(op & 0xd0000000) == 0xd0000000)	/* stfs, fp?, .. */
+    {
+      pc += 4;					/* store fpr double */
+      op = read_memory_integer (pc, 4);
+    }
 
   if (op == 0x603f0000) {			/* oril r31, r1, 0x0 */
     pc += 4;					/* this happens if r31 is used as */
     op = read_memory_integer (pc, 4);		/* frame ptr. (gcc does that)	  */
 
-    if ((op >> 16) == 0x907f) {			/* st r3, NUM(r31) */
-      pc += 4;
+    tmp = 0;
+    while ((op >> 16) == (0x907f + tmp)) {	/* st r3, NUM(r31) */
+      pc += 4;					/* st r4, NUM(r31), ... */
       op = read_memory_integer (pc, 4);
+      tmp += 0x20;
     }
   }
   return pc;
 }
 
+
 /* text start and end addresses in virtual memory. */
 
 CORE_ADDR text_start;
@@ -424,10 +252,21 @@ CORE_ADDR text_end;
   frames, etc. 
 *************************************************************************/
 
+/* The total size of dummy frame is 436, which is;
+
+	32 gpr's	- 128 bytes
+	32 fpr's	- 256   "
+	7  the rest	- 28    "
+	and 24 extra bytes for the callee's link area. The last 24 bytes
+	for the link area might not be necessary, since it will be taken
+	care of by push_arguments(). */
+
+#define DUMMY_FRAME_SIZE 436
+
 #define	DUMMY_FRAME_ADDR_SIZE 10
 
 /* Make sure you initialize these in somewhere, in case gdb gives up what it
-   was debugging and starts debugging something else. FIXMEmgo */
+   was debugging and starts debugging something else. FIXMEibm */
 
 static int dummy_frame_count = 0;
 static int dummy_frame_size = 0;
@@ -464,15 +303,13 @@ push_dummy_frame ()
      before writing register values into the new frame, decrement and update
      %sp first in order to secure your frame. */
 
-  write_register (SP_REGNUM, sp-408);
+  write_register (SP_REGNUM, sp-DUMMY_FRAME_SIZE);
 
-#if 1
   /* gdb relies on the state of current_frame. We'd better update it,
      otherwise things like do_registers_info() wouldn't work properly! */
 
   flush_cached_frames ();
-  set_current_frame (create_new_frame (sp-408, pc));
-#endif /* 0 */
+  set_current_frame (create_new_frame (sp-DUMMY_FRAME_SIZE, pc));
 
   /* save program counter in link register's space. */
   write_memory (sp+8, &pc, 4);
@@ -488,12 +325,17 @@ push_dummy_frame ()
   for (ii=1; ii <=32; ++ii)
     write_memory (sp-256-(ii*4), &registers[REGISTER_BYTE (32-ii)], 4);
 
-  /* so far, 32*2 + 32 words = 384 bytes have been written. We need 6 words
-     (24 bytes) for the rest of the registers. It brings the total to 408 
-     bytes.
-     save sp or so call back chain right here. */
-  write_memory (sp-408, &sp, 4);
-  sp -= 408;
+  /* so far, 32*2 + 32 words = 384 bytes have been written. 
+     7 extra registers in our register set: pc, ps, cnd, lr, cnt, xer, mq */
+
+  for (ii=1; ii <= (LAST_SP_REGNUM-FIRST_SP_REGNUM+1); ++ii) {
+    write_memory (sp-384-(ii*4), 
+	       &registers[REGISTER_BYTE (FPLAST_REGNUM + ii)], 4);
+  }
+
+  /* Save sp or so called back chain right here. */
+  write_memory (sp-DUMMY_FRAME_SIZE, &sp, 4);
+  sp -= DUMMY_FRAME_SIZE;
 
   /* And finally, this is the back chain. */
   write_memory (sp+8, &pc, 4);
@@ -505,12 +347,13 @@ push_dummy_frame ()
    In rs6000 when we push a dummy frame, we save all of the registers. This
    is usually done before user calls a function explicitly.
 
-   After a dummy frame is pushed, some instructions are copied into stack, and
-   stack pointer is decremented even more. Since we don't have a frame pointer to
-   get back to the parent frame of the dummy, we start having trouble poping it.
-   Therefore, we keep a dummy frame stack, keeping addresses of dummy frames as
-   such. When poping happens and when we detect that was a dummy frame, we pop
-   it back to its parent by using dummy frame stack (`dummy_frame_addr' array).
+   After a dummy frame is pushed, some instructions are copied into stack,
+   and stack pointer is decremented even more.  Since we don't have a frame
+   pointer to get back to the parent frame of the dummy, we start having
+   trouble poping it.  Therefore, we keep a dummy frame stack, keeping
+   addresses of dummy frames as such.  When poping happens and when we
+   detect that was a dummy frame, we pop it back to its parent by using
+   dummy frame stack (`dummy_frame_addr' array). 
  */
    
 pop_dummy_frame ()
@@ -528,7 +371,13 @@ pop_dummy_frame ()
     read_memory (sp-256-(ii*4), &registers[REGISTER_BYTE (32-ii)], 4);
   }
 
-  read_memory (sp-400, &registers [REGISTER_BYTE(PC_REGNUM)], 4);
+  /* restore the rest of the registers. */
+  for (ii=1; ii <=(LAST_SP_REGNUM-FIRST_SP_REGNUM+1); ++ii)
+    read_memory (sp-384-(ii*4),
+    		&registers[REGISTER_BYTE (FPLAST_REGNUM + ii)], 4);
+
+  read_memory (sp-(DUMMY_FRAME_SIZE-8), 
+  				&registers [REGISTER_BYTE(PC_REGNUM)], 4);
 
   /* when a dummy frame was being pushed, we had to decrement %sp first, in 
      order to secure astack space. Thus, saved %sp (or %r1) value, is not the
diff --git a/gdb/rs6000-xdep.c b/gdb/rs6000-xdep.c
index 557ecb1..6a5543a 100644
--- a/gdb/rs6000-xdep.c
+++ b/gdb/rs6000-xdep.c
@@ -39,6 +39,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include <sys/stat.h>
 #include <sys/core.h>
 #include <sys/ldr.h>
+#include <sys/utsname.h>
 
 extern int errno;
 extern int attach_flag;
@@ -60,6 +61,7 @@ static int special_regs[] = {
 extern int one_stepped;
 
 
+void
 fetch_inferior_registers (regno)
      int regno;
 {
@@ -196,30 +198,19 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
 frameless_function_invocation (fi)
 struct frame_info *fi;
 {
-  int ret;
-  CORE_ADDR func_start, after_prologue;			                 
+  CORE_ADDR func_start;
+  int frameless, dummy;
 
-#if 0
-  func_start = (LOAD_ADDR (get_pc_function_start (fi->pc)) +
-		FUNCTION_START_OFFSET);			                 
-#else
   func_start = get_pc_function_start (fi->pc) + FUNCTION_START_OFFSET;
-#endif
-  if (func_start)                                                        
-    {									 
-      after_prologue = func_start;					 
-      SKIP_PROLOGUE (after_prologue);					 
-      ret  = (after_prologue == func_start);			 
-    }									 
-  else									 
-    /* If we can't find the start of the function, we don't really */    
-    /* know whether the function is frameless, but we should be	   */    
-    /* able to get a reasonable (i.e. best we can do under the	   */    
-    /* circumstances) backtrace by saying that it isn't.  */	         
-	ret = 0;
- 
-  return ret;
 
+  /* If we failed to find the start of the function, it is a mistake
+     to inspect the instructions. */
+
+  if (!func_start)
+    return 0;
+
+  function_frame_info (func_start, &frameless, &dummy, &dummy, &dummy);
+  return frameless;
 }
 
 
@@ -245,8 +236,10 @@ unsigned int pid;
 
     errno = 0;
     ptrace(PT_LDINFO, pid, ldi, MAX_LOAD_SEGS * sizeof(*ldi), ldi);
-    if (errno)
+    if (errno) {
       perror_with_name ("ptrace ldinfo");
+      return 0;
+    }
 
     vmap_ldinfo(ldi);
 
@@ -255,8 +248,10 @@ unsigned int pid;
     } while (ldi->ldinfo_next
 	     && (ldi = (void *) (ldi->ldinfo_next + (char *) ldi)));
 
+#if 0
   /* Now that we've jumbled things around, re-sort them.  */
   sort_minimal_symbols ();
+#endif
 
   /* relocate the exec and core sections as well. */
   vmap_exec ();
@@ -275,13 +270,13 @@ typedef struct {
 static	LoadInfo *loadInfo = NULL;
 static	int	loadInfoLen = 0;
 static	int	loadInfoTocIndex = 0;
-static	int	loadInfoTextIndex = 0;
+int	aix_loadInfoTextIndex = 0;
 
 
 xcoff_init_loadinfo ()
 {
   loadInfoTocIndex = 0;
-  loadInfoTextIndex = 0;
+  aix_loadInfoTextIndex = 0;
 
   if (loadInfoLen == 0) {
     loadInfo = (void*) xmalloc (sizeof (LoadInfo) * LOADINFOLEN);
@@ -297,7 +292,7 @@ free_loadinfo ()
   loadInfo = NULL;
   loadInfoLen = 0;
   loadInfoTocIndex = 0;
-  loadInfoTextIndex = 0;
+  aix_loadInfoTextIndex = 0;
 }
 
 
@@ -313,24 +308,26 @@ xcoff_add_toc_to_loadinfo (unsigned long tocaddr)
 
 add_text_to_loadinfo (unsigned long textaddr, unsigned long dataaddr)
 {
-  while (loadInfoTextIndex >= loadInfoLen) {
+  while (aix_loadInfoTextIndex >= loadInfoLen) {
     loadInfoLen += LOADINFOLEN;
     loadInfo = (void*) xrealloc (loadInfo, sizeof(LoadInfo) * loadInfoLen);
   }
-  loadInfo [loadInfoTextIndex].textorg = textaddr;
-  loadInfo [loadInfoTextIndex].dataorg = dataaddr;
-  ++loadInfoTextIndex;
+  loadInfo [aix_loadInfoTextIndex].textorg = textaddr;
+  loadInfo [aix_loadInfoTextIndex].dataorg = dataaddr;
+  ++aix_loadInfoTextIndex;
 }
 
 
 unsigned long
 find_toc_address (unsigned long pc)
 {
-  int ii, toc_entry;
+  int ii, toc_entry, tocbase = 0;
 
-  for (ii=0; ii < loadInfoTextIndex; ++ii)
-    if (pc > loadInfo [ii].textorg)
+  for (ii=0; ii < aix_loadInfoTextIndex; ++ii)
+    if (pc > loadInfo [ii].textorg && loadInfo [ii].textorg > tocbase) {
       toc_entry = ii;
+      tocbase =  loadInfo [ii].textorg;
+    }
 
   return loadInfo [toc_entry].dataorg + loadInfo [toc_entry].toc_offset;
 }
@@ -342,11 +339,14 @@ find_toc_address (unsigned long pc)
 
 exec_one_dummy_insn ()
 {
-#define	DUMMY_INSN_ADDR	0x10000200
+#define	DUMMY_INSN_ADDR	(TEXT_SEGMENT_BASE)+0x200
 
   unsigned long shadow;
   unsigned int status, pid;
 
+  /* We plant one dummy breakpoint into DUMMY_INSN_ADDR address. We assume that
+     this address will never be executed again by the real code. */
+
   target_insert_breakpoint (DUMMY_INSN_ADDR, &shadow);
 
   errno = 0;
@@ -361,3 +361,24 @@ exec_one_dummy_insn ()
   target_remove_breakpoint (DUMMY_INSN_ADDR, &shadow);
 }
 
+
+/* Return the number of initial trap signals we need to ignore once the inferior
+   process starts running. This will be `2' for aix-3.1, `3' for aix-3.2 */
+
+int
+aix_starting_inferior_traps ()
+{
+  struct utsname unamebuf;
+
+  if (uname (&unamebuf) == -1)
+    fatal ("uname(3) failed.");
+
+  /* Assume the future versions will behave like 3.2 and return '3' for
+     anything other than 3.1x. The extra trap in 3.2 is the "trap after the
+     program is loaded" signal. */
+  
+  if (unamebuf.version[0] == '3' && unamebuf.release[0] == '1')
+    return 2;
+  else
+    return 3;
+}
diff --git a/gdb/rs6k-opcode.h b/gdb/rs6k-opcode.h
index ec2832a..7f616b5 100755
--- a/gdb/rs6k-opcode.h
+++ b/gdb/rs6k-opcode.h
@@ -1,13 +1,13 @@
 /* IBM RS/6000 instruction set definitions, for GNU software.  */
 
-struct rs6000_insn {
+typedef struct rs6000_insn {
   char	*operator;			/* opcode name		*/
   char	*opr_ext;			/* opcode name extension */
   char	*format;			/* opcode format	*/
   char	p_opcode;			/* primary opcode	*/
   int	e_opcode;			/* extended opcode	*/
   char	oprnd_format[6];		/* operand format	*/
-};
+} OPCODE;
 
 /* operand format specifiers */
 
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 9d1bf3f..407a608 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -517,6 +517,17 @@ lookup_symbol (name, block, namespace, is_a_field_of_this, symtab)
 	      bv = BLOCKVECTOR (s);
 	      block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
 	      sym = lookup_block_symbol (block, msymbol -> name, namespace);
+#if 0 /* defined(IBM6000) */
+              /* we kept static functions in misc_function_vector as well as
+		 in static scope. We want to find them in the symbol table. */
+
+		if (!sym) {
+		  block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
+		  sym = lookup_block_symbol (block, misc_function_vector[ind].name,
+							namespace);
+		}
+#endif
+
 	      /* sym == 0 if symbol was found in the minimal symbol table
 		 but not in the symtab.
 		 Return 0 to use the msymbol definition of "foo_".
diff --git a/gdb/tm-rs6000.h b/gdb/tm-rs6000.h
index 3b90fe3..07ec07b 100644
--- a/gdb/tm-rs6000.h
+++ b/gdb/tm-rs6000.h
@@ -18,14 +18,32 @@ You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
+
+/* A successful ptrace(continue) might return errno != 0 in this particular port
+   of rs6000. I am not sure why. We will use this kludge and ignore it until
+   we figure out the real problem. */
+
+#define AIX_BUGGY_PTRACE_CONTINUE	\
+{ \
+  int ret = ptrace (PT_CONTINUE, inferior_pid, (int *)1, signal, 0); \
+  if (errno) { \
+/*    printf ("ret: %d, errno: %d, signal: %d\n", ret, errno, signal); */ \
+    errno = 0; } \
+}
+
 extern int	symtab_relocated;
 
+/* Minimum possible text address in AIX */
+
+#define TEXT_SEGMENT_BASE	0x10000000
+
+
 /* text addresses in a core file does not necessarily match to symbol table,
    if symbol table relocation wasn't done yet. */
 
 #define	CORE_NEEDS_RELOCATION(PC)	\
-  if (!symtab_relocated && !inferior_pid && (PC) > 0x10000000)	\
-    (PC) -= (0x10000000 + text_adjustment (exec_bfd));
+  if (!symtab_relocated && !inferior_pid && (PC) >  TEXT_SEGMENT_BASE)	\
+    (PC) -= ( TEXT_SEGMENT_BASE + text_adjustment (exec_bfd));
 
 /* Conversion between a register number in stab string to actual register num. */
 
@@ -89,14 +107,40 @@ struct fp_status {
 
 /* When a child process is just starting, we sneak in and relocate
    the symbol table (and other stuff) after the dynamic linker has
-   figured out where they go.  */
+   figured out where they go. But we want to do this relocation just
+   once. */
+
+extern int aix_loadInfoTextIndex;
+
+#define	SOLIB_CREATE_INFERIOR_HOOK()	\
+  do {					\
+    if (aix_loadInfoTextIndex == 0)	\
+	aixcoff_relocate_symtab (pid);	\
+  } while (0)
+	
+
+/* In aix, number of the trap signals we need to skip over once the
+   inferior process starts running is different in version 3.1 and 3.2.
+   This will be 2 for version 3.1x, 3 for version 3.2x. */
 
-#define	SOLIB_CREATE_INFERIOR_HOOK(PID)	aixcoff_relocate_symtab (PID)
+#define	START_INFERIOR_TRAPS_EXPECTED	aix_starting_inferior_traps ()
 
+/* In aixcoff, we cannot process line numbers when we see them. This is
+   mainly because we don't know the boundaries of the include files. So,
+   we postpone that, and then enter and sort(?) the whole line table at
+   once, when we are closing the current symbol table in end_symtab(). */
+
+#define	PROCESS_LINENUMBER_HOOK()	aix_process_linenos ()
+   
+   
 /* When a target process or core-file has been attached, we sneak in
-   and figure out where the shared libraries have got to.  */
+   and figure out where the shared libraries have got to. In case there
+   is no inferior_process exists (e.g. bringing up a core file), we can't
+   attemtp to relocate symbol table, since we don't have information about
+   load segments. */
 
-#define	SOLIB_ADD(a, b, c)		aixcoff_relocate_symtab (inferior_pid)
+#define	SOLIB_ADD(a, b, c)	\
+   if (inferior_pid)	aixcoff_relocate_symtab (inferior_pid)
 
 /* Immediately after a function call, return the saved pc.
    Can't go through the frames for this because on some machines
@@ -173,7 +217,7 @@ extern char registers[];
    There should be NUM_REGS strings in this initializer.  */
 
 #define REGISTER_NAMES  \
- {"r0", "sp", "toc", "r3", "r4", "r5", "r6", "r7",  \
+ {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",  \
   "r8", "r9", "r10","r11","r12","r13","r14","r15", \
   "r16","r17","r18","r19","r20","r21","r22","r23", \
   "r24","r25","r26","r27","r28","r29","r30","r31", \
@@ -194,6 +238,8 @@ extern char registers[];
 #define SP_REGNUM 1		/* Contains address of top of stack */
 #define	TOC_REGNUM 2		/* TOC register */
 #define FP0_REGNUM 32		/* Floating point register 0 */
+#define	GP0_REGNUM 0		/* GPR register 0 */
+#define FP0_REGNUM 32		/* FPR (Floating point) register 0 */
 #define FPLAST_REGNUM 63	/* Last floating point register */  
 
 /* Special purpose registers... */
@@ -307,7 +353,21 @@ extern unsigned int rs6000_struct_return_address;
    of type TYPE, given in virtual format.  */
 
 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
-  printf ("FIXMEmgo! STORE_RETURN_VALUE not implemented yet!\n")
+  {									\
+    if (TYPE_CODE (TYPE) == TYPE_CODE_FLT)				\
+									\
+     /* Floating point values are returned starting from FPR1 and up.	\
+	Say a double_double_double type could be returned in		\
+	FPR1/FPR2/FPR3 triple. */					\
+									\
+      write_register_bytes (REGISTER_BYTE (FP0_REGNUM+1), (VALBUF),	\
+						TYPE_LENGTH (TYPE));	\
+    else								\
+      /* Everything else is returned in GPR3 and up. */			\
+      write_register_bytes (REGISTER_BYTE (GP0_REGNUM+3), (VALBUF),	\
+						TYPE_LENGTH (TYPE));	\
+  }
+
 
 /* Extract from an array REGBUF containing the (raw) register state
    the address in which a function should return its structure value,
@@ -318,7 +378,12 @@ extern unsigned int rs6000_struct_return_address;
 
 /* Do implement the attach and detach commands.  */
 
-#define ATTACH_DETACH	/* FIXMEmgo! Not implemented yet! */
+#define ATTACH_DETACH
+
+/* infptrace.c requires those. */
+
+#define PTRACE_ATTACH 30
+#define	PTRACE_DETACH 31
 
 
 /* Describe the pointer in each stack frame to the previous stack frame
@@ -453,3 +518,8 @@ extern unsigned int rs6000_struct_return_address;
 
 #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, using_gcc) \
 	fix_call_dummy(dummyname, pc, fun, nargs, type)
+
+/* Flag for machine-specific stuff in shared files.  FIXME */
+#ifndef IBM6000
+#define IBM6000
+#endif
diff --git a/gdb/xcoffexec.c b/gdb/xcoffexec.c
index fa65151..7259b21 100644
--- a/gdb/xcoffexec.c
+++ b/gdb/xcoffexec.c
@@ -43,9 +43,6 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 /* Prototypes for local functions */
 
 static void
-add_to_section_table PARAMS ((bfd *, sec_ptr, PTR));
-
-static void
 file_command PARAMS ((char *, int));
 
 static void
@@ -59,6 +56,8 @@ struct section_table *exec_sections, *exec_sections_end;
 
 int write_files = 0;
 
+extern int info_verbose;
+
 bfd *exec_bfd;			/* needed by core.c	*/
 
 extern char *getenv();
@@ -66,6 +65,7 @@ extern void child_create_inferior (), child_attach ();
 extern void add_syms_addr_command ();
 extern void symbol_file_command ();
 static void exec_files_info();
+extern struct objfile *lookup_objfile_bfd ();
 
 /*
  * the vmap struct is used to describe the virtual address space of
@@ -102,18 +102,29 @@ extern struct target_ops exec_ops;
 /* exec_close -	done with exec file, clean up all resources. */
 
 static void
-exec_close(quitting) {
-	register struct vmap *vp, *nxt;
-
-	for (nxt = vmap; vp = nxt; ) {
-		nxt = vp->nxt;
-		bfd_close(vp->bfd);
-		free_named_symtabs(vp->name, vp->member);	/* XXX	*/
-		free(vp);
-	}
-
-	vmap = 0;
-	exec_bfd = 0;
+exec_close(quitting)
+{
+  register struct vmap *vp, *nxt;
+  struct objfile *obj;
+  
+  for (nxt = vmap; vp = nxt; )
+    {
+      nxt = vp->nxt;
+
+      /* if there is an objfile associated with this bfd,
+	 free_objfile() will do proper cleanup of objfile *and* bfd. */
+		   
+      if (obj = lookup_objfile_bfd (vp->bfd))
+	free_objfile (obj);
+      else
+	bfd_close(vp->bfd);
+      
+      free_named_symtabs(vp->name);
+      free(vp);
+    }
+  
+  vmap = 0;
+  exec_bfd = 0;
 }
 
 /*
@@ -327,7 +338,8 @@ relocate_minimal_symbol (objfile, msymbol, arg1, arg2, arg3)
      PTR arg2;
      PTR arg3;
 {
-  msymbol -> address += (int) arg1;
+  if (msymbol->address < TEXT_SEGMENT_BASE)
+    msymbol -> address += (int) arg1;
 }
 
 /* true, if symbol table and minimal symbol table are relocated. */
@@ -391,24 +403,18 @@ struct stat *vip;
 	  vmap_symtab_1(s, vp, old_start);
       }
     }
-  if (vp->tstart != old_start)
+  if (vp->tstart != old_start) {
     iterate_over_msymbols (relocate_minimal_symbol,
 			   (PTR) (vp->tstart - old_start),
 			   (PTR) NULL, (PTR) NULL);
+
+    /* breakpoints need to be relocated as well. */
+    fixup_breakpoints (0, TEXT_SEGMENT_BASE, vp->tstart - old_start);
+  }
   
   symtab_relocated = 1;
 }
 
-
-fixup_misc_vector (int disp)
-{
-  int ii;
-  for (ii=0; ii < misc_function_count; ++ii)
-    if (misc_function_vector[ii].address < 0x10000000)
-      misc_function_vector[ii].address += disp;
-}
-
-
 vmap_symtab_1(s, vp, old_start)
 register struct symtab *s;
 register struct vmap *vp;
@@ -429,12 +435,14 @@ CORE_ADDR old_start;
 
     /*
      * The line table must be relocated.  This is only present for
-     * b.text sections, so only vp->text type maps need be considered.
+     * .text sections, so only vp->text type maps need be considered.
      */
     l = LINETABLE (s);
-    len = l->nitems;
-    for (i = 0; i < len; i++)
+    if (l) {
+      len = l->nitems;
+      for (i = 0; i < len; i++)
 	l->item[i].pc += reloc;
+    }
 
     /* if this symbol table is not relocatable, only line table should
        be relocated and the rest ignored. */
@@ -693,7 +701,6 @@ retry:
   } while (ldi->ldinfo_next
 	 && (ldi = (void *) (ldi->ldinfo_next + (char *) ldi)));
 
-  breakpoint_re_set();
 }
 
 /*
@@ -728,18 +735,17 @@ vmap_inferior() {
     we just tail-call it with more arguments to select between them.  */
 
 int
-xfer_memory (memaddr, myaddr, len, write, abfd, sections, sections_end)
+xfer_memory (memaddr, myaddr, len, write, target)
      CORE_ADDR memaddr;
      char *myaddr;
      int len;
      int write;
-     bfd *abfd;
-     struct section_table *sections, *sections_end;
+     struct target_ops *target;
 {
   boolean res;
   struct section_table *p;
   CORE_ADDR nextsectaddr, memend;
-  boolean (*xfer_fn) ();
+  boolean (*xfer_fn) PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
 
   if (len <= 0)
     abort();
@@ -748,13 +754,13 @@ xfer_memory (memaddr, myaddr, len, write, abfd, sections, sections_end)
   xfer_fn = write? bfd_set_section_contents: bfd_get_section_contents;
   nextsectaddr = memend;
 
-  for (p = sections; p < sections_end; p++)
+  for (p = target->to_sections; p < target->to_sections_end; p++)
     {
       if (p->addr <= memaddr)
 	if (p->endaddr >= memend)
 	  {
 	    /* Entire transfer is within this section.  */
-	    res = xfer_fn (abfd, p->sec_ptr, myaddr, memaddr - p->addr, len);
+	    res = xfer_fn (p->bfd, p->sec_ptr, myaddr, memaddr - p->addr, len);
 	    return (res != false)? len: 0;
 	  }
 	else if (p->endaddr <= memaddr)
@@ -766,7 +772,7 @@ xfer_memory (memaddr, myaddr, len, write, abfd, sections, sections_end)
 	  {
 	    /* This section overlaps the transfer.  Just do half.  */
 	    len = p->endaddr - memaddr;
-	    res = xfer_fn (abfd, p->sec_ptr, myaddr, memaddr - p->addr, len);
+	    res = xfer_fn (p->bfd, p->sec_ptr, myaddr, memaddr - p->addr, len);
 	    return (res != false)? len: 0;
 	  }
       else if (p->addr < nextsectaddr)
@@ -779,24 +785,31 @@ xfer_memory (memaddr, myaddr, len, write, abfd, sections, sections_end)
     return - (nextsectaddr - memaddr);	/* Next boundary where we can help */
 }
 
-/* The function called by target_xfer_memory via our target_ops */
-
-int
-exec_xfer_memory (memaddr, myaddr, len, write)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
-     int write;
+void
+print_section_info (t, abfd)
+  struct target_ops *t;
+  bfd *abfd;
 {
-  return xfer_memory (memaddr, myaddr, len, write,
-		      exec_bfd, exec_sections, exec_sections_end);
-}
+#if 1
+  struct section_table *p;
 
-/*
- * exec_files_info -	"info files" command processor
- */
-static void
-exec_files_info() {
+  printf_filtered ("\t`%s', ", bfd_get_filename(abfd));
+  wrap_here ("        ");
+  printf_filtered ("file type %s.\n", bfd_get_target(abfd));
+
+  for (p = t->to_sections; p < t->to_sections_end; p++) {
+    printf_filtered ("\t%s", local_hex_string_custom (p->addr, "08"));
+    printf_filtered (" - %s", local_hex_string_custom (p->endaddr, "08"));
+    if (info_verbose)
+      printf_filtered (" @ %s",
+		       local_hex_string_custom (p->sec_ptr->filepos, "08"));
+    printf_filtered (" is %s", bfd_section_name (p->bfd, p->sec_ptr));
+    if (p->bfd != abfd) {
+      printf_filtered (" in %s", bfd_get_filename (p->bfd));
+    }
+    printf_filtered ("\n");
+  }
+#else
 	register struct vmap *vp = vmap;
 
 	if (!vp)
@@ -814,6 +827,14 @@ exec_files_info() {
 		       , *vp->member ? "(" : ""
 		       ,  vp->member
 		       , *vp->member ? ")" : "");
+#endif
+}
+
+static void
+exec_files_info (t)
+  struct target_ops *t;
+{
+  print_section_info (t, exec_bfd);
 }
 
 #ifdef DAMON
@@ -914,7 +935,7 @@ Specify the filename of the executable file.",
 	child_attach, 0, 0, 0, /* attach, detach, resume, wait, */
 	0, 0, /* fetch_registers, store_registers, */
 	0, 0, 0, /* prepare_to_store, conv_to, conv_from, */
-	exec_xfer_memory, exec_files_info,
+	xfer_memory, exec_files_info,
 	0, 0, /* insert_breakpoint, remove_breakpoint, */
 	0, 0, 0, 0, 0, /* terminal stuff */
 	0, 0, /* kill, load */
diff --git a/gdb/xcoffread.c b/gdb/xcoffread.c
index 13c0e17..4d66f51 100644
--- a/gdb/xcoffread.c
+++ b/gdb/xcoffread.c
@@ -23,6 +23,9 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "defs.h"
 #include "bfd.h"
 
+#ifdef IBM6000
+/* Native only:  Need struct tbtable in <sys/debug.h>. */
+
 /* AIX COFF names have a preceeding dot `.' */
 #define NAMES_HAVE_DOT 1
 
@@ -36,6 +39,8 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include <sys/file.h>
 #endif
 #include <sys/stat.h>
+/*#include <linenum.h>*/
+#include <sys/debug.h>
 
 #include "symtab.h"
 #include "gdbtypes.h"
@@ -73,7 +78,7 @@ static bfd *symfile_bfd;
    This is calculated from the first function seen after a C_FILE
    symbol. */
 
-static CORE_ADDR cur_src_start_addr;
+
 static CORE_ADDR cur_src_end_addr;
 
 /* Core address of the end of the first object file.  */
@@ -97,7 +102,7 @@ static char *symtbl;
 #define	INITIAL_STABVECTOR_LENGTH	40
 
 struct pending_stabs *global_stabs;
-struct pending_stabs *file_stabs;
+
 
 /* Nonzero if within a function (so symbols should be local,
    if nothing says specifically).  */
@@ -125,6 +130,7 @@ static unsigned	local_n_tmask;
 
 static unsigned	local_symesz;
 
+
 /* coff_symfile_init()
    is the coff-specific initialization routine for reading symbols.
    It is passed a struct sym_fns which contains, among other things,
@@ -145,8 +151,8 @@ struct coff_symfile_info {
 
 
 static void
-enter_line_range PARAMS ((struct subfile *, unsigned, unsigned, CORE_ADDR,
-			  unsigned *));
+enter_line_range PARAMS ((struct subfile *, unsigned, unsigned,
+			  CORE_ADDR, CORE_ADDR, unsigned *));
 
 static void
 aixcoff_symfile_read PARAMS ((struct sym_fns *, CORE_ADDR, int));
@@ -185,10 +191,6 @@ static void
 read_xcoff_symtab PARAMS ((struct objfile *, int));
 
 static void
-enter_line_range PARAMS ((struct subfile *, unsigned, unsigned, CORE_ADDR,
-			  unsigned *));
-
-static void
 add_stab_to_list PARAMS ((char *, struct pending_stabs **));
 
 static void
@@ -273,22 +275,412 @@ struct pending_stabs **stabvector;
 }
 
 
+#if 0
+/* for all the stabs in a given stab vector, build appropriate types 
+   and fix their symbols in given symbol vector. */
+
+void
+patch_block_stabs (symbols, stabs)
+struct pending *symbols;
+struct pending_stabs *stabs;
+{
+  int ii;
+
+  if (!stabs)
+    return;
+
+  /* for all the stab entries, find their corresponding symbols and 
+     patch their types! */
+
+  for (ii=0; ii < stabs->count; ++ii) {
+    char *name = stabs->stab[ii];
+    char *pp = (char*) index (name, ':');
+    struct symbol *sym = find_symbol_in_list (symbols, name, pp-name);
+    if (!sym) {
+      ;
+      /* printf ("ERROR! stab symbol not found!\n");	/* FIXME */
+      /* The above is a false alarm. There are cases the we can have
+         a stab, without its symbol. xlc generates this for the extern
+	 definitions in inner blocks. */
+    }
+    else {
+      pp += 2;
+
+      if (*(pp-1) == 'F' || *(pp-1) == 'f')
+	SYMBOL_TYPE (sym) = lookup_function_type (read_type (&pp));
+      else
+	SYMBOL_TYPE (sym) = read_type (&pp, objfile);
+    }
+  }
+}
+#endif
+
+
+/* compare line table entry addresses. */
+
+  static int
+compare_lte (lte1, lte2)
+  struct linetable_entry *lte1, *lte2;
+{
+  return lte1->pc - lte2->pc;
+}
+
+/* Give a line table with function entries are marked, arrange its functions
+   in assending order and strip off function entry markers and return it in
+   a newly created table. If the old one is good enough, return the old one. */
+
+static struct linetable *
+arrange_linetable (oldLineTb)
+  struct linetable *oldLineTb;			/* old linetable */
+{
+  int ii, jj, 
+      newline, 					/* new line count */
+      function_count;				/* # of functions */
+
+  struct linetable_entry *fentry;		/* function entry vector */
+  int fentry_size;				/* # of function entries */
+  struct linetable *newLineTb;			/* new line table */
+
+#define NUM_OF_FUNCTIONS 20
+
+  fentry_size = NUM_OF_FUNCTIONS;
+  fentry = (struct linetable_entry*)
+	malloc (fentry_size * sizeof (struct linetable_entry));
+
+  for (function_count=0, ii=0; ii <oldLineTb->nitems; ++ii) {
+
+    if (oldLineTb->item[ii].line == 0) {	/* function entry found. */
+
+      if (function_count >= fentry_size) {	/* make sure you have room. */
+	fentry_size *= 2;
+	fentry = (struct linetable_entry*) 
+	   realloc (fentry, fentry_size * sizeof (struct linetable_entry));
+      }
+      fentry[function_count].line = ii;
+      fentry[function_count].pc = oldLineTb->item[ii].pc;
+      ++function_count;
+    }
+  }
+
+  if (function_count == 0) {
+    free (fentry);
+    return oldLineTb;
+  }
+  else if (function_count > 1)
+    qsort (fentry, function_count, sizeof(struct linetable_entry), compare_lte);
+
+  /* allocate a new line table. */
+  newLineTb = (struct linetable*) malloc (sizeof (struct linetable) + 
+	(oldLineTb->nitems - function_count) * sizeof (struct linetable_entry));
+
+  /* if line table does not start with a function beginning, copy up until
+     a function begin. */
+
+  newline = 0;
+  if (oldLineTb->item[0].line != 0)
+    for (newline=0; 
+	newline < oldLineTb->nitems && oldLineTb->item[newline].line; ++newline)
+      newLineTb->item[newline] = oldLineTb->item[newline];
+
+  /* Now copy function lines one by one. */
+
+  for (ii=0; ii < function_count; ++ii) {
+    for (jj = fentry[ii].line + 1;
+	         jj < oldLineTb->nitems && oldLineTb->item[jj].line != 0; 
+							 ++jj, ++newline)
+      newLineTb->item[newline] = oldLineTb->item[jj];
+  }
+  free (fentry);
+  newLineTb->nitems = oldLineTb->nitems - function_count;
+  return newLineTb;  
+}     
+
+
+
+/* We try to detect the beginning of a compilation unit. That info will
+   be used as an entry in line number recording routines (enter_line_range) */
+
+static unsigned first_fun_line_offset;
+static unsigned first_fun_bf;
+
+#define mark_first_line(OFFSET, SYMNUM) \
+  if (!first_fun_line_offset) {         \
+    first_fun_line_offset = OFFSET;     \
+    first_fun_bf = SYMNUM;              \
+  }
+  
+
+/* include file support: C_BINCL/C_EINCL pairs will be kept in the 
+   following `IncludeChain'. At the end of each symtab (end_symtab),
+   we will determine if we should create additional symtab's to
+   represent if (the include files. */
+
+
+typedef struct _inclTable {
+  char		*name;				/* include filename */
+  int		begin, end;			/* offsets to the line table */
+  struct subfile *subfile;
+  unsigned	funStartLine;			/* start line # of its function */
+} InclTable;
+
+#define	INITIAL_INCLUDE_TABLE_LENGTH	20
+static InclTable  *inclTable;			/* global include table */
+static int	  inclIndx;			/* last entry to table */
+static int	  inclLength;			/* table length */
+static int	  inclDepth;			/* nested include depth */
+
+
+static void
+record_include_begin (cs)
+struct coff_symbol *cs;
+{
+  /* In aixcoff, we assume include files cannot be nested (not in .c file
+     of course, but in corresponding .s files.) */
+
+  if (inclDepth)
+    fatal ("aix internal: pending include file exists.");
+
+  ++inclDepth;
+
+  /* allocate an include file, or make room for the new entry */
+  if (inclLength == 0) {
+    inclTable = (InclTable*) 
+	xmalloc (sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
+    bzero (inclTable, sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
+    inclLength = INITIAL_INCLUDE_TABLE_LENGTH;
+    inclIndx = 0;
+  }
+  else if (inclIndx >= inclLength) {
+    inclLength += INITIAL_INCLUDE_TABLE_LENGTH;
+    inclTable = (InclTable*) 
+	xrealloc (inclTable, sizeof (InclTable) * inclLength);
+    bzero (inclTable+inclLength-INITIAL_INCLUDE_TABLE_LENGTH, 
+			sizeof (InclTable)*INITIAL_INCLUDE_TABLE_LENGTH);
+  }
+
+  inclTable [inclIndx].name  = cs->c_name;
+  inclTable [inclIndx].begin = cs->c_value;
+}
+
+
+static void
+record_include_end (cs)
+struct coff_symbol *cs;
+{
+  InclTable *pTbl;  
+
+  if (inclDepth == 0)
+    fatal ("aix internal: Mismatch C_BINCL/C_EINCL pair found.");
+
+  pTbl = &inclTable [inclIndx];
+  pTbl->end = cs->c_value;
+
+  --inclDepth;
+  ++inclIndx;
+}
+
+
+static void
+dumpIncludeChain ()
+{
+  int ii;
+  if (inclTable && inclLength)
+    for (ii=0; ii < inclIndx; ++ii)
+      printf ("name: %s, begin: 0x%x, end: 0x%x\n",
+		inclTable[ii].name, inclTable[ii].begin, inclTable[ii].end);
+}
+
+
+/* given the start and end addresses of a compilation unit (or a csect, at times)
+   process its lines and create appropriate line vectors. */
+
+static void
+process_linenos (start, end)
+  CORE_ADDR start, end;
+{
+  char *pp;
+  int offset, ii;
+
+  struct subfile main_subfile;		/* subfile structure for the main
+  					   compilation unit. */
+
+  /* in the main source file, any time we see a function entry, we reset
+     this variable to function's absolute starting line number. All the
+     following line numbers in the function are relative to this, and
+     we record absolute line numbers in record_line(). */
+
+  int main_source_baseline = 0;
+
+  
+  unsigned *firstLine;
+  CORE_ADDR addr;
+
+  if (!(offset = first_fun_line_offset))
+    goto return_after_cleanup;
+
+  bzero (&main_subfile, sizeof (main_subfile));
+  first_fun_line_offset = 0;
+
+  if (inclIndx == 0)
+    enter_line_range (&main_subfile, offset, 0, start, end, 
+    						&main_source_baseline);
+
+  /* else, there was source with line numbers in include files */
+  else {
+
+    main_source_baseline = 0;
+    for (ii=0; ii < inclIndx; ++ii) {
+
+      struct subfile *tmpSubfile;
+
+      /* if there is main file source before include file, enter it. */
+      if (offset < inclTable[ii].begin) {
+	enter_line_range
+	  (&main_subfile, offset, inclTable[ii].begin - LINESZ, start, 0, 
+	  					&main_source_baseline);
+      }
+
+      /* Have a new subfile for the include file */
+
+      tmpSubfile = inclTable[ii].subfile = (struct subfile*) 
+      				xmalloc (sizeof (struct subfile));
+
+      bzero (tmpSubfile, sizeof (struct subfile));
+      firstLine = &(inclTable[ii].funStartLine);
+
+      /* enter include file's lines now. */
+      enter_line_range (tmpSubfile, inclTable[ii].begin, 
+      				inclTable[ii].end, start, 0, firstLine);
+
+      offset = inclTable[ii].end + LINESZ;
+    }
+
+    /* all the include files' line have been processed at this point. Now,
+       enter remaining lines of the main file, if any left. */
+    if (offset < (linetab_offset + linetab_size + 1 - LINESZ)) {
+      enter_line_range (&main_subfile, offset, 0, start, end, 
+      						&main_source_baseline);
+    }
+  }
+
+  /* Process main file's line numbers. */
+  if (main_subfile.line_vector) {
+    struct linetable *lineTb, *lv;
+
+    lv = main_subfile.line_vector;
+
+    /* Line numbers are not necessarily ordered. xlc compilation will
+       put static function to the end. */
+
+    lineTb = arrange_linetable (lv);
+    if (lv == lineTb) {
+      current_subfile->line_vector = (struct linetable *)
+	xrealloc (lv, (sizeof (struct linetable)
+			+ lv->nitems * sizeof (struct linetable_entry)));
+
+    }
+    else {
+	free (lv);
+	current_subfile->line_vector = lineTb;
+    }
+
+    current_subfile->line_vector_length = 
+    			current_subfile->line_vector->nitems;
+
+
+    /* Now, process included files' line numbers. */
+
+    for (ii=0; ii < inclIndx; ++ii) {
+
+      if ( (inclTable[ii].subfile)->line_vector) { /* Useless if!!! FIXMEmgo */
+        struct linetable *lineTb, *lv;
+
+        lv = (inclTable[ii].subfile)->line_vector;
+
+        /* Line numbers are not necessarily ordered. xlc compilation will
+           put static function to the end. */
+
+        lineTb = arrange_linetable (lv);
+
+	push_subfile ();
+
+	/* For the same include file, we might want to have more than one subfile.
+	   This happens if we have something like:
+   
+  		......
+	        #include "foo.h"
+		......
+	 	#include "foo.h"
+		......
+
+	   while foo.h including code in it. (stupid but possible)
+	   Since start_subfile() looks at the name and uses an existing one if finds,
+	   we need to provide a fake name and fool it. */
+
+/*	start_subfile (inclTable[ii].name, (char*)0);  */
+	start_subfile (" ?", (char*)0);
+	current_subfile->name = 
+		obsavestring (inclTable[ii].name, strlen (inclTable[ii].name),
+			      &current_objfile->symbol_obstack);
+
+        if (lv == lineTb) {
+	  current_subfile->line_vector = (struct linetable *)
+		xrealloc (lv, (sizeof (struct linetable)
+			+ lv->nitems * sizeof (struct linetable_entry)));
+
+	}
+	else {
+	  free (lv);
+	  current_subfile->line_vector = lineTb;
+	}
+
+	current_subfile->line_vector_length = 
+    			current_subfile->line_vector->nitems;
+	start_subfile (pop_subfile (), (char*)0);
+      }
+    }
+  }
+  else
+    /* I am not sure this logic is correct. There might be no lines in the
+       main file, whereas there are some in included ones. FIXMEibm */
+    current_subfile->line_vector = NULL;
+
+return_after_cleanup:
+
+  /* We don't want to keep alloc/free'ing the global include file table. */
+  inclIndx = 0;
+
+  /* start with a fresh subfile structure for the next file. */
+  bzero (&main_subfile, sizeof (struct subfile));
+}
+
+void
+aix_process_linenos ()
+{
+  /* process line numbers and enter them into line vector */
+  process_linenos (last_source_start_addr, cur_src_end_addr);
+}
+
+
 /* Enter a given range of lines into the line vector.
    can be called in the following two ways:
-     enter_line_range (subfile, beginoffset, endoffset, 0, firstLine)  or
-     enter_line_range (subfile, beginoffset, 0, endaddr, firstLine) */
+     enter_line_range (subfile, beginoffset, endoffset, startaddr, 0, firstLine)  or
+     enter_line_range (subfile, beginoffset, 0, startaddr, endaddr, firstLine) */
 
 static void
-enter_line_range (subfile, beginoffset, endoffset, endaddr, firstLine)
-  struct subfile *subfile;		/* which sub-file to put line#s in */
+enter_line_range (subfile, beginoffset, endoffset, startaddr, endaddr, firstLine)
+  struct subfile *subfile;
   unsigned   beginoffset, endoffset;	/* offsets to line table */
-  CORE_ADDR  endaddr;
+  CORE_ADDR  startaddr, endaddr;
   unsigned   *firstLine;
 {
   char		*pp, *limit;
   CORE_ADDR	addr;
-  struct internal_lineno lptr;
-  unsigned local_linesz = coff_data (symfile_bfd)->local_linesz;
+
+/* Do Byte swapping, if needed. FIXME! */
+#define	P_LINENO(PP)  (*(unsigned short*)((struct external_lineno*)(PP))->l_lnno)
+#define	P_LINEADDR(PP)	(*(long*)((struct external_lineno*)(PP))->l_addr.l_paddr)
+#define	P_LINESYM(PP)	    (*(long*)((struct external_lineno*)(PP))->l_addr.l_symndx)
 
   pp = &linetab [beginoffset - linetab_offset];
   limit = endoffset ? &linetab [endoffset - linetab_offset]
@@ -296,26 +688,230 @@ enter_line_range (subfile, beginoffset, endoffset, endaddr, firstLine)
 
   while (pp <= limit) {
 
-    /* Swap and align this lineno entry into lptr.  */
-    bfd_coff_swap_lineno_in (symfile_bfd, pp, &lptr);
-
     /* find the address this line represents */
-    addr = lptr.l_lnno ? 
-      lptr.l_addr.l_paddr : read_symbol_nvalue (symtbl, lptr.l_addr.l_symndx);
+    addr = P_LINENO(pp) ? 
+      P_LINEADDR(pp) : read_symbol_nvalue (symtbl, P_LINESYM(pp)); 
 
-    if (endaddr && addr >= endaddr)
+    if (addr < startaddr || (endaddr && addr > endaddr))
       return;
 
-    if (lptr.l_lnno == 0) {
-      *firstLine = read_symbol_lineno (symtbl, lptr.l_addr.l_symndx);
+    if (P_LINENO(pp) == 0) {
+      *firstLine = read_symbol_lineno (symtbl, P_LINESYM(pp));
+      record_line (subfile, 0, addr);
       --(*firstLine);
     }
     else
-      record_line (subfile, *firstLine + lptr.l_lnno, addr);
+      record_line (subfile, *firstLine + P_LINENO(pp), addr);
+
+    pp += LINESZ;
+  }
+}
+
+typedef struct {
+  int fsize;				/* file size */
+  int fixedparms;			/* number of fixed parms */
+  int floatparms;			/* number of float parms */
+  unsigned int parminfo;		/* parameter info. 
+  					   See /usr/include/sys/debug.h
+					   tbtable_ext.parminfo */
+  int framesize;			/* function frame size */
+} TracebackInfo;
+
+
+/* Given a function symbol, return its traceback information. */
+
+  TracebackInfo *
+retrieve_tracebackinfo (abfd, textsec, cs)
+  bfd *abfd;
+  sec_ptr textsec;
+  struct coff_symbol *cs;
+{
+#define TBTABLE_BUFSIZ  2000
+#define	MIN_TBTABSIZ	50		/* minimum buffer size to hold a
+					   traceback table. */
+
+  static TracebackInfo tbInfo;
+  struct tbtable *ptb;
+
+  static char buffer [TBTABLE_BUFSIZ];
+
+  int  *pinsn;
+  int  bytesread=0;			/* total # of bytes read so far */
+  int  bufferbytes;			/* number of bytes in the buffer */
+
+  int functionstart = cs->c_value - textsec->vma;
+
+  bzero (&tbInfo, sizeof (tbInfo));
+
+  /* keep reading blocks of data from the text section, until finding a zero
+     word and a traceback table. */
+
+  while (bfd_get_section_contents (abfd, textsec, buffer, 
+	(file_ptr)(functionstart + bytesread), 
+	bufferbytes = (
+		(TBTABLE_BUFSIZ < (textsec->_raw_size - functionstart - bytesread)) ? 
+		 TBTABLE_BUFSIZ : (textsec->_raw_size - functionstart - bytesread))))
+  {
+    bytesread += bufferbytes;
+    pinsn = (int*) buffer;
+
+    /* if this is the first time we filled the buffer, retrieve function
+       framesize info. */
+
+    if (bytesread == bufferbytes) {
+
+      /* skip over unrelated instructions */
+
+      if (*pinsn == 0x7c0802a6)			/* mflr r0 */
+        ++pinsn;
+      if ((*pinsn & 0xfc00003e) == 0x7c000026)	/* mfcr Rx */
+	++pinsn;
+      if ((*pinsn & 0xfc000000) == 0x48000000)	/* bl foo, save fprs */
+        ++pinsn;
+      if ((*pinsn  & 0xfc1f0000) == 0xbc010000)	/* stm Rx, NUM(r1) */
+        ++pinsn;
+
+      do {
+	int tmp = (*pinsn >> 16) & 0xffff;
+
+	if (tmp ==  0x9421) {			/* stu  r1, NUM(r1) */
+	  tbInfo.framesize = 0x10000 - (*pinsn & 0xffff);
+	  break;
+	}
+	else if ((*pinsn == 0x93e1fffc) ||	/* st   r31,-4(r1) */
+		 (tmp == 0x9001))		/* st   r0, NUM(r1) */
+	;
+	/* else, could not find a frame size. */
+	else
+	  return NULL;
+
+      } while (++pinsn && *pinsn);
+
+      if (!tbInfo.framesize)
+        return NULL;      
+    }
+
+    /* look for a zero word. */
+
+    while (*pinsn && (pinsn < (int*)(buffer + bufferbytes - sizeof(int))))
+      ++pinsn;
+
+    if (pinsn >= (int*)(buffer + bufferbytes))
+      continue;
 
-    pp += local_linesz;
+    if (*pinsn == 0) {
+
+      /* function size is the amount of bytes we have skipped so far. */
+      tbInfo.fsize = bytesread - (buffer + bufferbytes - (char*)pinsn);
+
+      ++pinsn;
+
+      /* if we don't have the whole traceback table in the buffer, re-read
+         the whole thing. */
+
+      if ((char*)pinsn > (buffer + bufferbytes - MIN_TBTABSIZ)) {
+
+	/* In case if we are *very* close to the end of the text section
+	   and cannot read properly from that point on, abort by returning
+	   NULL.
+	   Handle this case more graciously -- FIXME */
+
+	if (!bfd_get_section_contents (
+		abfd, textsec, buffer, 
+		(file_ptr)(functionstart + 
+		 bytesread - (buffer + bufferbytes - (char*)pinsn)),MIN_TBTABSIZ))
+	  { printf ("Abnormal return!..\n"); return NULL; }
+
+	ptb = (struct tbtable *)buffer;
+      }
+      else
+        ptb = (struct tbtable *)pinsn;
+
+      tbInfo.fixedparms = ptb->tb.fixedparms;
+      tbInfo.floatparms = ptb->tb.floatparms;
+      tbInfo.parminfo = ptb->tb_ext.parminfo;
+      return &tbInfo;
+    }
+  }
+  return NULL;
+}
+
+#if 0
+/* Given a function symbol, return a pointer to its traceback table. */
+
+  struct tbtable *
+retrieve_traceback (abfd, textsec, cs, size)
+  bfd *abfd;
+  sec_ptr textsec;
+  struct coff_symbol *cs;
+  int *size;				/* return function size */
+{
+#define TBTABLE_BUFSIZ  2000
+#define	MIN_TBTABSIZ	50		/* minimum buffer size to hold a
+					   traceback table. */
+
+  static char buffer [TBTABLE_BUFSIZ];
+
+  int  *pinsn;
+  int  bytesread=0;			/* total # of bytes read so far */
+  int  bufferbytes;			/* number of bytes in the buffer */
+
+  int functionstart = cs->c_value - textsec->filepos + textsec->vma;
+  *size = 0;
+
+  /* keep reading blocks of data from the text section, until finding a zero
+     word and a traceback table. */
+
+  while (bfd_get_section_contents (abfd, textsec, buffer, 
+	(file_ptr)(functionstart + bytesread), 
+	bufferbytes = (
+		(TBTABLE_BUFSIZ < (textsec->size - functionstart - bytesread)) ? 
+		 TBTABLE_BUFSIZ : (textsec->size - functionstart - bytesread))))
+  {
+    bytesread += bufferbytes;
+    pinsn = (int*) buffer;
+
+    /* look for a zero word. */
+
+    while (*pinsn && (pinsn < (int*)(buffer + bufferbytes - sizeof(int))))
+      ++pinsn;
+
+    if (pinsn >= (int*)(buffer + bufferbytes))
+      continue;
+
+    if (*pinsn == 0) {
+
+      /* function size is the amount of bytes we have skipped so far. */
+      *size = bytesread - (buffer + bufferbytes - pinsn);
+
+      ++pinsn;
+
+      /* if we don't have the whole traceback table in the buffer, re-read
+         the whole thing. */
+
+      if ((char*)pinsn > (buffer + bufferbytes - MIN_TBTABSIZ)) {
+
+	/* In case if we are *very* close to the end of the text section
+	   and cannot read properly from that point on, abort for now.
+	   Handle this case more graciously -- FIXME */
+
+	if (!bfd_get_section_contents (
+		abfd, textsec, buffer, 
+		(file_ptr)(functionstart + 
+		 bytesread - (buffer + bufferbytes - pinsn)),MIN_TBTABSIZ))
+	/*   abort (); */ { printf ("abort!!!\n"); return NULL; }
+
+	return (struct tbtable *)buffer;
+      }
+      else
+        return (struct tbtable *)pinsn;
+    }
   }
+  return NULL;
 }
+#endif /* 0 */
+
+
 
 
 /* Save the vital information for use when closing off the current file.
@@ -324,7 +920,7 @@ enter_line_range (subfile, beginoffset, endoffset, endaddr, firstLine)
 
 #define complete_symtab(name, start_addr) {	\
   last_source_file = savestring (name, strlen (name));	\
-  cur_src_start_addr = start_addr;			\
+  last_source_start_addr = start_addr;			\
 }
 
 
@@ -347,10 +943,33 @@ enter_line_range (subfile, beginoffset, endoffset, endaddr, firstLine)
     (ALLOCED) = 1;						\
   }								\
   prim_record_minimal_symbol (namestr, (ADDR), (TYPE));		\
-  last_recorded_fun = (ADDR);					\
+  misc_func_recorded = 1;					\
 }
 
 
+/* A parameter template, used by ADD_PARM_TO_PENDING. */
+
+static struct symbol parmsym = {		/* default parameter symbol */
+	"",					/* name */
+	VAR_NAMESPACE,				/* namespace */
+	LOC_ARG,				/* class */
+	NULL,					/* type */
+	0,					/* line number */
+	0,					/* value */
+};
+
+/* Add a parameter to a given pending symbol list. */ 
+
+#define	ADD_PARM_TO_PENDING(PARM, VALUE, PTYPE, PENDING_SYMBOLS)	\
+{									\
+  PARM = (struct symbol *)						\
+      obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol));	\
+  *(PARM) = parmsym;							\
+  SYMBOL_TYPE (PARM) = PTYPE;						\
+  SYMBOL_VALUE (PARM) = VALUE;						\
+  add_symbol_to_list (PARM, &PENDING_SYMBOLS);				\
+}
+
 
 /* aixcoff has static blocks marked in `.bs', `.es' pairs. They cannot be
    nested. At any given time, a symbol can only be in one static block.
@@ -370,9 +989,11 @@ read_xcoff_symtab (objfile, nsyms)
      int nsyms;			/* # of symbols */
 {
   bfd *abfd = objfile->obfd;
-  /* char *symtbl; */		/* Raw symbol table base */
   char *raw_symbol;		/* Pointer into raw seething symbol table */
   char *raw_auxptr;		/* Pointer to first raw aux entry for sym */
+  sec_ptr  textsec;		/* Pointer to text section */
+  TracebackInfo *ptb;		/* Pointer to traceback table */
+
   struct internal_syment symbol[1];
   union internal_auxent main_aux[1];
   struct coff_symbol cs[1];
@@ -383,7 +1004,6 @@ read_xcoff_symtab (objfile, nsyms)
   int just_started = 1;
   int depth = 0;
   int val;
-  int fcn_first_line;
   int fcn_last_line;
   int fcn_start_addr;
   long fcn_line_offset;
@@ -391,11 +1011,14 @@ read_xcoff_symtab (objfile, nsyms)
 
   /* fcn_cs_saved is global because process_xcoff_symbol needs it. */
   union internal_auxent fcn_aux_saved;
+  struct type *fcn_type_saved = NULL;
   struct context_stack *new;
 
   char *filestring = " _start_ ";	/* Name of the current file. */
-  char *last_seen_csect;
-  int last_recorded_fun = 0;		/* last recorded fun. value */
+
+  char *last_csect_name;		/* last seen csect's name and value */
+  CORE_ADDR last_csect_val;
+  int  misc_func_recorded;		/* true if any misc. function */
 
   current_objfile = objfile;
 
@@ -405,8 +1028,9 @@ read_xcoff_symtab (objfile, nsyms)
   local_symesz = coff_data (abfd)->local_symesz;
 
   last_source_file = 0;
-  last_seen_csect = 0;
-  last_recorded_fun = 0;
+  last_csect_name = 0;
+  last_csect_val = 0;
+  misc_func_recorded = 0;
 
   start_symtab (filestring, (char *)NULL, file_start_addr);
   symnum = 0;
@@ -425,6 +1049,11 @@ read_xcoff_symtab (objfile, nsyms)
 
   raw_symbol = symtbl;
 
+  textsec = bfd_get_section_by_name (abfd, ".text");
+  if (!textsec) {
+    printf ("Unable to locate text section!\n");
+  }
+
   while (symnum < nsyms) {
 
     QUIT;			/* make this command interruptable.  */
@@ -478,7 +1107,7 @@ read_xcoff_symtab (objfile, nsyms)
 
     if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE) {
       if (last_source_file)
-	end_symtab (cur_src_end_addr, 1, 1, objfile);
+	end_symtab (cur_src_end_addr, 1, 0, objfile);
 
       start_symtab ("_globals_", (char *)NULL, (CORE_ADDR)0);
       cur_src_end_addr = first_object_file_end;
@@ -527,10 +1156,22 @@ read_xcoff_symtab (objfile, nsyms)
 		   CU might get fragmented in the memory and gdb's file start and end address
 		   approach does not work!  */
 
-		if (last_seen_csect) {
+		if (last_csect_name) {
+
+		  /* if no misc. function recorded in the last seen csect, enter
+		     it as a function. This will take care of functions like
+		     strcmp() compiled by xlc. */
+
+		  if (!misc_func_recorded) {
+		     int alloced = 0;
+		     RECORD_MINIMAL_SYMBOL (last_csect_name, last_csect_val,
+					    mst_text, alloced);
+		  }
+		    
+
 		  complete_symtab (filestring, file_start_addr);
 		  cur_src_end_addr = file_end_addr;
-		  end_symtab (file_end_addr, 1, 1, objfile);
+		  end_symtab (file_end_addr, 1, 0, objfile);
 		  start_symtab ((char *)NULL, (char *)NULL, (CORE_ADDR)0);
 		}
 
@@ -544,10 +1185,11 @@ read_xcoff_symtab (objfile, nsyms)
 		file_end_addr = cs->c_value + CSECT_LEN (main_aux);
 
 		if (cs->c_name && cs->c_name[0] == '.') {
-		  last_seen_csect = cs->c_name;
-		  RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, mst_text, symname_alloced);
+		  last_csect_name = cs->c_name;
+		  last_csect_val = cs->c_value;
 		}
 	      }
+	      misc_func_recorded = 0;
 	      continue;
 
 	    case XMC_RW :
@@ -575,9 +1217,8 @@ read_xcoff_symtab (objfile, nsyms)
 	  if (CSECT_SCLAS (main_aux) == XMC_PR) {
 
 function_entry_point:
-	    if (cs->c_value != last_recorded_fun)
-	      RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, mst_text, 
-	      						symname_alloced);
+	    RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, mst_text, 
+				   symname_alloced);
 
 	    fcn_line_offset = main_aux->x_sym.x_fcnary.x_fcn.x_lnnoptr;
 	    fcn_start_addr = cs->c_value;
@@ -586,27 +1227,91 @@ function_entry_point:
 	       when `.bf' is seen. */
 	    fcn_cs_saved = *cs;
 	    fcn_aux_saved = *main_aux;
+
+
+	    ptb = NULL;
+
+	    /* If function has two auxent, then debugging information is
+	       already available for it. Process traceback table for
+	       functions with only one auxent. */
+
+	    if (cs->c_nsyms == 1)
+	      ptb = retrieve_tracebackinfo (abfd, textsec, cs);
+
+	    else if (cs->c_nsyms != 2)
+	      abort ();
+
+	    /* If there is traceback info, create and add parameters for it. */
+
+	    if (ptb && (ptb->fixedparms || ptb->floatparms)) {
+
+	      int parmcnt = ptb->fixedparms + ptb->floatparms;
+	      char *parmcode = (char*) &ptb->parminfo;
+	      int parmvalue = ptb->framesize + 0x18;	/* sizeof(LINK AREA) == 0x18 */
+	      unsigned int ii, mask;
+
+	      for (ii=0, mask = 0x80000000; ii <parmcnt; ++ii) {
+		struct symbol *parm;
+
+		if (ptb->parminfo & mask) {		/* float or double */
+		  mask = mask >> 1;
+		  if (ptb->parminfo & mask) {		/* double parm */
+		    ADD_PARM_TO_PENDING
+			(parm, parmvalue, builtin_type_double, local_symbols);
+		    parmvalue += sizeof (double);
+		  }
+		  else {				/* float parm */
+		    ADD_PARM_TO_PENDING
+			(parm, parmvalue, builtin_type_float, local_symbols);
+		    parmvalue += sizeof (float);
+		  }
+ 		}
+		else {					/* fixed parm */
+		  ADD_PARM_TO_PENDING
+			(parm, parmvalue, builtin_type_int, local_symbols);
+		  parmvalue += sizeof (int);
+		}
+		mask = mask >> 1;
+	      }
+		
+ 	      /* Fake this as a function. Needed in process_xcoff_symbol() */
+	      cs->c_type = 32;		
+	      				   
+	      finish_block(process_xcoff_symbol (cs, objfile), &local_symbols, 
+			   pending_blocks, cs->c_value,
+			   cs->c_value + ptb->fsize, objfile);
+	    }
 	    continue;
 	  }
-
-	  /* shared library function entry point. */
+	  /* shared library function trampoline code entry point. */
 	  else if (CSECT_SCLAS (main_aux) == XMC_GL) {
-	    if (last_recorded_fun != cs->c_value)
-	      RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, mst_text,
-	      						symname_alloced);
+	    RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, mst_text,
+				   symname_alloced);
 	    continue;
 	  }
 	  break;
 
 	default :		/* all other XTY_XXXs */
 	  break;
-	}			/* switch CSECT_SMTYP() */
-    }
+	}			/* switch CSECT_SMTYP() */    }
 
     switch (cs->c_sclass) {
 
     case C_FILE:
 
+      /* see if the last csect needs to be recorded. */
+
+      if (last_csect_name && !misc_func_recorded) {
+
+	  /* if no misc. function recorded in the last seen csect, enter
+	     it as a function. This will take care of functions like
+	     strcmp() compiled by xlc. */
+
+	  int alloced = 0;
+	  RECORD_MINIMAL_SYMBOL (last_csect_name, last_csect_val,
+				mst_text, alloced);
+      }
+
       /* c_value field contains symnum of next .file entry in table
 	 or symnum of first global after last .file. */
 
@@ -618,11 +1323,12 @@ function_entry_point:
       /* Whether or not there was a csect in the previous file, we have 
 	 to call `end_symtab' and `start_symtab' to reset type_vector, 
 	 line_vector, etc. structures. */
+
       complete_symtab (filestring, file_start_addr);
       cur_src_end_addr = file_end_addr;
-      end_symtab (file_end_addr, 1, 1, objfile);
+      end_symtab (file_end_addr, 1, 0, objfile);
       start_symtab (cs->c_name, (char *)NULL, (CORE_ADDR)0);
-      last_seen_csect = 0;
+      last_csect_name = 0;
 
       /* reset file start and end addresses. A compilation unit with no text
          (only data) should have zero file boundaries. */
@@ -632,6 +1338,25 @@ function_entry_point:
       break;
 
 
+    case C_FUN:
+
+      /* For a function stab, just save its type in `fcn_type_saved', and leave
+	 it for the `.bf' processing. */
+      {
+	char *pp = (char*) index (cs->c_name, ':');
+
+	if (!pp || ( *(pp+1) != 'F' && *(pp+1) != 'f'))
+	  fatal ("Unrecognized stab");
+	pp += 2;
+
+	if (fcn_type_saved)
+	  fatal ("Unprocessed function type");
+
+	fcn_type_saved = lookup_function_type (read_type (&pp, objfile));
+      }
+      break;
+    
+
     case C_FCN:
       if (strcmp (cs->c_name, ".bf") == 0) {
 
@@ -640,17 +1365,73 @@ function_entry_point:
 
 	within_function = 1;
 
-	/* value contains address of first non-init type code */
-	/* main_aux.x_sym.x_misc.x_lnsz.x_lnno
-	   contains line number of '{' } */
-	fcn_first_line = main_aux->x_sym.x_misc.x_lnsz.x_lnno;
-
 	/* Linenos are now processed on a file-by-file, not fn-by-fn, basis.
 	   Metin did it, I'm not sure why.  FIXME.  -- gnu@cygnus.com */
-	/* mark_first_line (fcn_line_offset, cs->c_symnum); */
+
+	/* Two reasons:
+	
+	    1) xlc (IBM's native c compiler) postpones static function code
+	       emission to the end of a compilation unit. This way it can
+	       determine if those functions (statics) are needed or not, and
+	       can do some garbage collection (I think). This makes line
+	       numbers and corresponding addresses unordered, and we end up
+	       with a line table like:
+	       
+
+ 			lineno	addr
+	        foo()	  10	0x100
+			  20	0x200
+			  30	0x300
+
+		foo3()	  70	0x400
+			  80	0x500
+			  90	0x600
+
+		static foo2()
+			  40	0x700
+			  50	0x800
+			  60	0x900		
+
+		and that breaks gdb's binary search on line numbers, if the
+		above table is not sorted on line numbers. And that sort
+		should be on function based, since gcc can emit line numbers
+		like:
+		
+			10	0x100	- for the init/test part of a for stmt.
+			20	0x200
+			30	0x300
+			10	0x400	- for the increment part of a for stmt.
+
+ 		arrange_linenos() will do this sorting.		
+
+
+	     2)	aix symbol table might look like:
+	
+			c_file		// beginning of a new file
+			.bi		// beginning of include file
+			.ei		// end of include file
+			.bi
+			.ei
+
+		basically, .bi/.ei pairs do not necessarily encapsulate
+		their scope. They need to be recorded, and processed later
+		on when we come the end of the compilation unit.
+		Include table (inclTable) and process_linenos() handle
+		that.
+	*/
+	mark_first_line (fcn_line_offset, cs->c_symnum);
 
 	new = push_context (0, fcn_start_addr);
 	new->name = process_xcoff_symbol (&fcn_cs_saved, objfile);
+
+	/* Between a function symbol and `.bf', there always will be a function
+	   stab. We save function type when processing that stab. */
+
+	if (fcn_type_saved == NULL)
+	  fatal ("Unknown function type");
+
+	SYMBOL_TYPE (new->name) = fcn_type_saved;
+	fcn_type_saved = NULL;
       }
       else if (strcmp (cs->c_name, ".ef") == 0) {
 
@@ -663,11 +1444,6 @@ function_entry_point:
 	   contains number of lines to '}' */
 
 	fcn_last_line = main_aux->x_sym.x_misc.x_lnsz.x_lnno;
-#if 0
-	enter_linenos (fcn_line_offset, fcn_first_line, 
-					fcn_first_line + fcn_last_line);
-#endif
-
 	new = pop_context ();
 	if (context_stack_depth != 0)
 	  error ("invalid symbol data; .bf/.ef/.bb/.eb symbol mismatch, at symbol %d.",
@@ -704,18 +1480,18 @@ function_entry_point:
       break;
 
     case C_BINCL	:		/* beginning of include file */
-	push_subfile ();
-  	start_subfile (cs->c_name, (char *)0);
-  	fcn_first_line = cs->c_value;	/* Offset to first lineno of file */
+
+	/* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted
+	   order. Thus, when wee see them, we might not know enough info
+	   to process them. Thus, we'll be saving them into a table 
+	   (inclTable) and postpone their processing. */
+
+	record_include_begin (cs);
 	break;
 
     case C_EINCL	:		/* end of include file */
-	fcn_last_line = cs->c_value;	/* Offset to last line number */
-	{ long dummy = 0;
-	enter_line_range (current_subfile, fcn_first_line, cs->c_value, 0,
-			  (unsigned *) &dummy);
-	}
-	start_subfile (pop_subfile (), (char *)0);
+			/* see the comment after case C_BINCL. */
+	record_include_end (cs);
 	break;
 
     case C_BLOCK	:
@@ -747,7 +1523,7 @@ function_entry_point:
   } /* while */
 
   if (last_source_file)
-    end_symtab (cur_src_end_addr, 1, 1, objfile);
+    end_symtab (cur_src_end_addr, 1, 0, objfile);
 
   free (symtbl);
   current_objfile = NULL;
@@ -763,7 +1539,6 @@ function_entry_point:
   (ALLOCED) ? (NAME) : obstack_copy0 (&objfile->symbol_obstack, (NAME), strlen (NAME));
 
 
-
 /* process one xcoff symbol. */
 
 static struct symbol *
@@ -776,6 +1551,7 @@ process_xcoff_symbol (cs, objfile)
   struct symbol *sym2 = NULL;
   struct type *ttype;
   char *name, *pp, *qq;
+  int struct_and_type_combined;
 
   name = cs->c_name;
   if (name[0] == '.')
@@ -794,7 +1570,7 @@ process_xcoff_symbol (cs, objfile)
        on in patch_block_stabs () */
 
     SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
-    SYMBOL_TYPE (sym) = lookup_function_type (lookup_fundamental_type (current_objfile, FT_INTEGER));
+    SYMBOL_TYPE (sym) = lookup_function_type (lookup_fundamental_type (objfile, FT_INTEGER));
 
     SYMBOL_CLASS (sym) = LOC_BLOCK;
     SYMBOL_DUP (sym, sym2);
@@ -808,23 +1584,26 @@ process_xcoff_symbol (cs, objfile)
   else {
 
     /* in case we can't figure out the type, default is `int'. */
-    SYMBOL_TYPE (sym) = lookup_fundamental_type (current_objfile, FT_INTEGER);
+    SYMBOL_TYPE (sym) = lookup_fundamental_type (objfile, FT_INTEGER);
 
     switch (cs->c_sclass)
     {
+#if 0
     case C_FUN:
       if (fcn_cs_saved.c_sclass == C_EXT)
 	add_stab_to_list (name, &global_stabs);
       else
 	add_stab_to_list (name, &file_stabs);
       break;
+#endif
 
     case C_DECL:      			/* a type decleration?? */
 	qq =  (char*) strchr (name, ':');
 	if (!qq)			/* skip if there is no ':' */
 	  return NULL;
 
-	pp = qq + 2;
+	struct_and_type_combined = (qq[1] == 'T' && qq[2] == 't');
+	pp = qq + (struct_and_type_combined ? 3 : 2);
 	ttype = SYMBOL_TYPE (sym) = read_type (&pp, objfile);
 
 	/* read_type() will return null if type (or tag) definition was
@@ -846,18 +1625,26 @@ process_xcoff_symbol (cs, objfile)
 	SYMBOL_CLASS (sym) = LOC_TYPEDEF;
 	SYMBOL_NAME (sym) = obsavestring (name, qq-name, &objfile->symbol_obstack);
 
-	if  (SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE)
+	if (struct_and_type_combined)
+	  TYPE_NAME (ttype) = SYMBOL_NAME (sym);
+	  
+	else if  (SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE)
 	    TYPE_NAME (ttype) = concat (
 		TYPE_CODE (ttype) == TYPE_CODE_UNION ? "union " :
 		TYPE_CODE (ttype) == TYPE_CODE_STRUCT? "struct " : "enum ",
 		SYMBOL_NAME (sym), NULL);
 
-	else if (!TYPE_NAME (ttype))      /* else, regular typedef. */
-	    TYPE_NAME (ttype) = SYMBOL_NAME (sym);
-
 	SYMBOL_DUP (sym, sym2);
 	add_symbol_to_list 
 	   (sym2, within_function ? &local_symbols : &file_symbols);
+
+	/* For a combination of struct and type, add one more symbol for the type. */
+	if (struct_and_type_combined) {
+	  SYMBOL_DUP (sym, sym2);
+	  SYMBOL_NAMESPACE (sym2) = VAR_NAMESPACE;
+	  add_symbol_to_list 
+	     (sym2, within_function ? &local_symbols : &file_symbols);
+	}
 	break;
 
     case C_GSYM:
@@ -865,10 +1652,11 @@ process_xcoff_symbol (cs, objfile)
       break;
 
     case C_PSYM:
+    case C_RPSYM:
 	if (*name == ':' || (pp = (char *) strchr (name, ':')) == NULL)
 	  return NULL;
 	SYMBOL_NAME (sym) = obsavestring (name, pp-name, &objfile -> symbol_obstack);
-	SYMBOL_CLASS (sym) = LOC_ARG;
+	SYMBOL_CLASS (sym) = (cs->c_sclass == C_PSYM) ? LOC_ARG : LOC_REGPARM;
 	pp += 2;
 	SYMBOL_TYPE (sym) = read_type (&pp, objfile);
 	SYMBOL_DUP (sym, sym2);
@@ -944,8 +1732,8 @@ process_xcoff_symbol (cs, objfile)
 	     `int' or `float', depending on the register class. */
 
 	  SYMBOL_TYPE (sym) = (SYMBOL_VALUE (sym) < 32)
-	      ? lookup_fundamental_type (current_objfile, FT_INTEGER)
-		  : lookup_fundamental_type (current_objfile, FT_FLOAT);
+	      ? lookup_fundamental_type (objfile, FT_INTEGER)
+		  : lookup_fundamental_type (objfile, FT_FLOAT);
 
 	SYMBOL_DUP (sym, sym2);
 	add_symbol_to_list (sym2, &local_symbols);
@@ -1020,7 +1808,7 @@ PTR vpinfo;
 
   count = asect->lineno_count;
 
-  if (count == 0)
+  if (strcmp (asect->name, ".text") || count == 0)
     return;
 
   size   = count * coff_data (symfile_bfd)->local_linesz;
@@ -1169,7 +1957,14 @@ build_function_symbol (ind, objfile)
 static void
 aixcoff_new_init ()
 {
-  /* Nothin' to do.  */
+  /* This routine is executed once per executable. We should start with a
+     fresh include table per executable. */
+
+  if (inclTable) {
+    free (inclTable);
+    inclTable = NULL;
+  }
+  inclIndx = inclLength = inclDepth = NULL;
 }
 
 static void
@@ -1375,3 +2170,11 @@ _initialize_xcoffread ()
 {
   add_symtab_fns(&aixcoff_sym_fns);
 }
+#else /* IBM6000 */
+struct type *
+builtin_type (pp)
+char **pp;
+{
+    fatal ("internals eror: builtin_type called!");
+}
+#endif /* IBM6000 */
diff --git a/gdb/xm-rs6000.h b/gdb/xm-rs6000.h
index 2c0c101..deef444 100644
--- a/gdb/xm-rs6000.h
+++ b/gdb/xm-rs6000.h
@@ -54,7 +54,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 /* Setpgrp() takes arguments, unlike ordinary Sys V's.  */
 
-#define	SETPGRP_ARGS
+#define	SETPGRP_ARGS 1
 
 /* RS6000/AIXCOFF does not support PT_STEP. Has to be simulated. */
 
@@ -65,3 +65,13 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 #define XCOFF_INIT_LOADINFO()	xcoff_init_loadinfo()
 #define XCOFF_ADD_TOC_TO_LOADINFO(x)	xcoff_add_toc_to_loadinfo (x)
+
+/* AIX's assembler doesn't grok dollar signs in identifiers.
+   So we use dots instead.  This item must be coordinated with G++. */
+#undef CPLUS_MARKER
+#define CPLUS_MARKER '.'
+
+/* Flag for machine-specific stuff in shared files.  FIXME */
+#ifndef IBM6000
+#define IBM6000
+#endif