* aoutx.h (aout_swap_ext_reloc_out, aout_swap_std_reloc_out)

	bout.c (b_out_squirt_out_relocs): treat abs sumbols the right way.
	* reloc.c (bfd_perform-relocation): don't relocate refs to
	absolute symbols if doing a partial link.

3 files changed, 100 insertions, 96 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index f382987..b2d6d36 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,10 @@
+Wed Apr 29 12:37:07 1992  Steve Chamberlain  (sac@thepub.cygnus.com)
+
+	* aoutx.h (aout_swap_ext_reloc_out, aout_swap_std_reloc_out)
+	bout.c (b_out_squirt_out_relocs): treat abs sumbols the right way.
+	* reloc.c (bfd_perform-relocation): don't relocate refs to
+	absolute symbols if doing a partial link.
+
 Fri Apr 24 07:35:26 1992  Stu Grossman  (grossman at cygnus.com)
 
 	* configure.in:  Add a29k-amd-udi.
diff --git a/bfd/bout.c b/bfd/bout.c
index 58df3d1..867f2fd 100644
--- a/bfd/bout.c
+++ b/bfd/bout.c
@@ -269,16 +269,14 @@ asymbol *symbol_in;
 PTR data;
 asection *input_section;
 {
-  int  word = bfd_get_32(abfd, data+reloc_entry->address);
+  int  word = bfd_get_32(abfd, (bfd_byte *)data + reloc_entry->address);
   aout_symbol_type  *symbol = aout_symbol(symbol_in);
 
   if (IS_OTHER(symbol->other)) {
     /* Call to a system procedure - replace code with system
-       procedure number 
-       */
-
+       procedure number */
     word = CALLS | (symbol->other - 1);
-    bfd_put_32(abfd, word,  data+reloc_entry->address); /* replace */
+    bfd_put_32(abfd, word, (bfd_byte *)data + reloc_entry->address); /* rplc */
     return bfd_reloc_ok;
   }
 
@@ -298,7 +296,7 @@ asection *input_section;
 	( input_section->output_section->vma + input_section->output_offset))
        & BAL_MASK);
 
-    bfd_put_32(abfd, word,  data+reloc_entry->address); /* replace */
+    bfd_put_32(abfd, word, (bfd_byte *) data + reloc_entry->address); /* rplc */
     return bfd_reloc_ok;
   }
   return bfd_reloc_continue;
@@ -438,10 +436,10 @@ b_out_slurp_reloc_table (abfd, asect, symbols)
 	      break;
 	    case N_ABS:
 	    case N_ABS | N_EXT:
-	      bfd_assert(0);
+	      BFD_ASSERT(0);
 	      break;
 	    default:
-	      bfd_assert(0);
+	      BFD_ASSERT(0);
 	      break;
 	    }
 	
@@ -511,7 +509,6 @@ else
   {
     arelent *g = *generic;
     unsigned char *raw = (unsigned char *)natptr;
-    unsigned int symnum;
     asymbol *sym = *(g->sym_ptr_ptr);
       
     asection *output_section = sym->section->output_section;
@@ -532,14 +529,9 @@ else
     else {
 	raw[7] = len_2;
       }
-    if (output_section == &bfd_abs_section) 
-    {
-      r_extern = 0;
-      r_idx = N_ABS;
-      r_addend += sym->value;
-    }
-    else if (output_section == &bfd_com_section 
-	     || output_section == &bfd_und_section) 
+    if (output_section == &bfd_com_section 
+	output_section == &bfd_abs_section
+	|| output_section == &bfd_und_section) 
     {
       /* Fill in symbol */
       r_extern = 1;
diff --git a/bfd/reloc.c b/bfd/reloc.c
index 89a92b4..1c715a5 100644
--- a/bfd/reloc.c
+++ b/bfd/reloc.c
@@ -247,6 +247,7 @@ SUBSUBSECTION
         information that BFD needs to know to tie up a back end's data.
 
 CODE_FRAGMENT
+.struct symbol_cache_entry;		{* Forward declaration *}
 .
 .typedef CONST struct reloc_howto_struct 
 .{ 
@@ -289,7 +290,12 @@ CODE_FRAGMENT
 .          called rather than the normal function. This allows really
 .          strange relocation methods to be accomodated (eg, i960 callj
 .          instructions). *}
-.  bfd_reloc_status_type (*special_function)();
+.  bfd_reloc_status_type EXFUN ((*special_function), 
+.					    (bfd *abfd,
+.					     arelent *reloc_entry,
+.                                            struct symbol_cache_entry *symbol,
+.                                            PTR data,
+.                                            asection *input_section));
 .
 .       {* The textual name of the relocation type. *}
 .  char *name;
@@ -431,19 +437,28 @@ DEFUN(bfd_perform_relocation,(abfd,
   asymbol *symbol;
 
   symbol = *( reloc_entry->sym_ptr_ptr);
+  if ((symbol->section == &bfd_abs_section) 
+      && output_bfd != (bfd *)NULL) 
+  {
+    reloc_entry->address += input_section->output_offset;
+       
+    return bfd_reloc_ok;
+       
+  }
+
   if ((symbol->section == &bfd_und_section) && output_bfd == (bfd *)NULL) {
-      flag = bfd_reloc_undefined;
-    }
+    flag = bfd_reloc_undefined;
+  }
 
   if (howto->special_function){
-      bfd_reloc_status_type cont;
-      cont = howto->special_function(abfd,
-				     reloc_entry,
-				     symbol,
-				     data,
-				     input_section);
-      if (cont != bfd_reloc_continue) return cont;
-    }
+    bfd_reloc_status_type cont;
+    cont = howto->special_function(abfd,
+				   reloc_entry,
+				   symbol,
+				   data,
+				   input_section);
+    if (cont != bfd_reloc_continue) return cont;
+  }
 
   /* 
     Work out which section the relocation is targetted at and the
@@ -452,22 +467,22 @@ DEFUN(bfd_perform_relocation,(abfd,
 
 
   if (symbol->section == &bfd_com_section) {
-      relocation = 0;
-    }
+    relocation = 0;
+  }
   else {
-      relocation = symbol->value;
-    }
+    relocation = symbol->value;
+  }
 
 
   reloc_target_output_section = symbol->section->output_section;
 
   if (output_bfd && howto->partial_inplace==false) {
-      output_base = 0;
-    }
+    output_base = 0;
+  }
   else {
-      output_base = reloc_target_output_section->vma;
+    output_base = reloc_target_output_section->vma;
 
-    }
+  }
 
   relocation += output_base +   symbol->section->output_offset;
   
@@ -499,41 +514,41 @@ DEFUN(bfd_perform_relocation,(abfd,
      input_section->output_section->vma + input_section->output_offset;
 
     if (howto->pcrel_offset == true) {
-	relocation -= reloc_entry->address;
-      }
+      relocation -= reloc_entry->address;
+    }
 
   }
 
   if (output_bfd!= (bfd *)NULL) {
-      if ( howto->partial_inplace == false)  {
-	  /*
-	    This is a partial relocation, and we want to apply the relocation
-	    to the reloc entry rather than the raw data. Modify the reloc
-	    inplace to reflect what we now know.
-	    */
-	  reloc_entry->addend = relocation  ;
-	  reloc_entry->address +=  input_section->output_offset;
-	  return flag;
-	}
-      else 
-      {
-	/* This is a partial relocation, but inplace, so modify the
-	   reloc record a bit. 
-	   
-	   If we've relocated with a symbol with a section, change
-	   into a ref to  the section belonging to the symbol
-	   */
-	  reloc_entry->addend = relocation  ;
-	  reloc_entry->address +=  input_section->output_offset;
+    if ( howto->partial_inplace == false)  {
+      /*
+	This is a partial relocation, and we want to apply the relocation
+	to the reloc entry rather than the raw data. Modify the reloc
+	inplace to reflect what we now know.
+	*/
+      reloc_entry->addend = relocation  ;
+      reloc_entry->address +=  input_section->output_offset;
+      return flag;
+    }
+    else 
+    {
+      /* This is a partial relocation, but inplace, so modify the
+	 reloc record a bit. 
+	 
+	 If we've relocated with a symbol with a section, change
+	 into a ref to  the section belonging to the symbol
+	 */
+      reloc_entry->addend = relocation  ;
+      reloc_entry->address +=  input_section->output_offset;
 
 
-      }
     }
+  }
   else 
   {
     
-  reloc_entry->addend = 0;
-}
+    reloc_entry->addend = 0;
+  }
   
 
 
@@ -586,33 +601,33 @@ DEFUN(bfd_perform_relocation,(abfd,
 
    switch (howto->size)
    {
-   case 0:
-   {
-     char x = bfd_get_8(abfd, (char *)data + addr);
-     DOIT(x);
-     bfd_put_8(abfd,x, (unsigned char *) data + addr);
-   }
+    case 0:
+    {
+      char x = bfd_get_8(abfd, (char *)data + addr);
+      DOIT(x);
+      bfd_put_8(abfd,x, (unsigned char *) data + addr);
+    }
      break;
 
-   case 1:
-   { 
-     short x = bfd_get_16(abfd, (bfd_byte *)data + addr);
-     DOIT(x);
-     bfd_put_16(abfd, x,   (unsigned char *)data + addr);
-   }
+    case 1:
+    { 
+      short x = bfd_get_16(abfd, (bfd_byte *)data + addr);
+      DOIT(x);
+      bfd_put_16(abfd, x,   (unsigned char *)data + addr);
+    }
      break;
-   case 2:
-   {
-     long  x = bfd_get_32(abfd, (bfd_byte *) data + addr);
-     DOIT(x);
-     bfd_put_32(abfd,x,    (bfd_byte *)data + addr);
-   }      
+    case 2:
+    {
+      long  x = bfd_get_32(abfd, (bfd_byte *) data + addr);
+      DOIT(x);
+      bfd_put_32(abfd,x,    (bfd_byte *)data + addr);
+    }      
      break;
-   case 3:
+    case 3:
 
      /* Do nothing */
      break;
-   default:
+    default:
      return bfd_reloc_other;
    }
 
@@ -745,8 +760,7 @@ SYNOPSIS
 	boolean bfd_generic_relax_section
 	 (bfd *abfd,
 	  asection *section,
-	  asymbol **symbols,
-	  struct bfd_seclet_struct *seclet);
+	  asymbol **symbols);
 
 DESCRIPTION
 	Provides default handling for relaxing for back ends which
@@ -754,11 +768,10 @@ DESCRIPTION
 */
 
 boolean
-DEFUN(bfd_generic_relax_section,(abfd, section, symbols, seclet),
+DEFUN(bfd_generic_relax_section,(abfd, section, symbols),
       bfd *abfd AND
       asection *section AND
-      asymbol **symbols AND
-      struct bfd_seclet_struct *seclet)
+      asymbol **symbols)
 {
   
   return false;
@@ -787,22 +800,16 @@ DEFUN(bfd_generic_get_relocated_section_contents,(abfd, seclet),
       struct bfd_seclet_struct *seclet)
 {
   extern bfd_error_vector_type bfd_error_vector;
-  
-
-  asymbol **symbols = 0;
 
   /* Get enough memory to hold the stuff */
   bfd *input_bfd = seclet->u.indirect.section->owner;
   asection *input_section = seclet->u.indirect.section;
 
-  bfd_byte *data = (bfd_byte *)malloc(input_section->_raw_size);
-  bfd_byte *dst = data;
-  bfd_byte *prev_dst = data;
-  unsigned int gap = 0;
+  bfd_byte *data = (bfd_byte *) bfd_xmalloc(input_section->_raw_size);
 
   bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
 						       input_section);
-  arelent **reloc_vector = (arelent **)malloc(reloc_size);
+  arelent **reloc_vector = (arelent **) bfd_xmalloc(reloc_size);
   
   /* read in the section */
   bfd_get_section_contents(input_bfd,
@@ -834,8 +841,6 @@ DEFUN(bfd_generic_get_relocated_section_contents,(abfd, seclet),
 
       if (r != bfd_reloc_ok) 
       {
-	asymbol *s;
-
 	switch (r)
 	{
 	case bfd_reloc_undefined: