path: root/bfd/seclet.c

/* This module is part of BFD */


/* The intention is that one day, all the code which uses sections
   will change and use seclets instead - maybe seglet would have been
   a better name..

   Anyway, a seclet contains enough info to be able to describe an
   area of output memory in one go.

   The only description so far catered for is that of the
   <<bfd_indirect_seclet>>, which is a select which points to a
   <<section>> and the <<asymbols>> associated with the section, so
   that relocation can be done when needed.

   One day there will be more types - they will at least migrate from
   the linker's data structures - also there could be extra stuff,
   like a bss seclet, which descibes a lump of memory as containing
   zeros compactly, without the horrible SEC_* flag cruft.


*/

#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
#include "seclet.h"
#include "coff/internal.h"
bfd_seclet_type *
DEFUN(bfd_new_seclet,(abfd, section),
      bfd *abfd AND
      asection *section)
{
  bfd_seclet_type *n = (bfd_seclet_type *)bfd_alloc(abfd, sizeof(bfd_seclet_type));
  if (section->seclets_tail != (bfd_seclet_type *)NULL) {
      section->seclets_tail->next = n;
    }
  else
  {
    section->seclets_head = n;
  }
  section->seclets_tail = n;

  return n;
  
}




#define MAX_ERRORS_IN_A_ROW 10
extern bfd_error_vector_type bfd_error_vector;
bfd_vma 
DEFUN(get_value,(reloc, seclet),
      arelent  *reloc AND
      bfd_seclet_type *seclet)
{
  bfd_vma value;
  if (reloc->sym_ptr_ptr) 
  {
    asymbol *symbol = *(reloc->sym_ptr_ptr);

  
    /* A symbol holds a pointer to a section, and an offset from the
       base of the section.  To relocate, we find where the section will
       live in the output and add that in */

    if (symbol->section == (asection *)NULL) 
    {
      /* Ouch, this is an undefined symbol.. */
      bfd_error_vector.undefined_symbol(reloc, seclet);
      value = symbol->value;
    }
    else 
    {
      value = symbol->value +
       symbol->section->output_offset +
	symbol->section->output_section->vma;
    }  
  }
  
  else 
  {
    value = 0;  
  }
  
  /* Add the value contained in the relocation */
  value += (short)((reloc->addend) & 0xffff);
  
  return value;
  

}

static char *
DEFUN(foo_bfd_get_relocated_section_contents,(seclet),
      bfd_seclet_type *seclet)

{
  asymbol **symbols = 0;
  extern bfd *output_bfd;
  bfd *abfd;    

  /* Get enough memory to hold the stuff */
  bfd *input_bfd = seclet->u.indirect.section->owner;
  asection *input_section = seclet->u.indirect.section;

  char *data = malloc(input_section->_raw_size);
  char *dst = data;
  char *prev_dst = data;
  unsigned int gap = 0;

  bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
						       input_section);
  arelent **reloc_vector = (arelent **)ldmalloc(reloc_size);
  abfd = output_bfd;
  
  /* read in the section */
  bfd_get_section_contents(input_bfd,
			   input_section,
			   data,
			   0,
			   input_section->_raw_size);
  
  
  if (bfd_canonicalize_reloc(input_bfd, 
			     input_section,
			     reloc_vector,
			     seclet->u.indirect.symbols) )
  {
    arelent **parent = reloc_vector;
    arelent *reloc ;
    


    unsigned int dst_address = 0;
    unsigned int src_address = 0;
    unsigned int run;
    unsigned int idx;
    
    /* Find how long a run we can do */
    while (dst_address < seclet->size) 
    {
      
      reloc = *parent;
      if (reloc) 
      {
	/* Note that the relaxing didn't tie up the addresses in the
	   relocation, so we use the original address to work out the
	   run of non-relocated data */
	run = reloc->address - src_address;
	parent++;
	
      }
      else 
      {
	run = seclet->size - dst_address;
      }
      /* Copy the bytes */
      for (idx = 0; idx < run; idx++)
      {
	data[dst_address++] = data[src_address++];
      }
    
      /* Now do the relocation */
    
      if (reloc) 
      {
	switch (reloc->howto->type) 
	{
	case R_JMP2:
	  /* Speciial relaxed type */
	{
	  bfd_vma dot = seclet->offset + dst_address + seclet->u.indirect.section->output_section->vma;	  
	  int   gap = get_value(reloc,seclet)-dot-1;
	  if ((gap & ~0xff  ) != 0 &&((gap & 0xff00)!= 0xff00)) abort();

	  bfd_put_8(abfd,gap,   data+dst_address);

	  switch (data[dst_address-1]) 
	  {
	    
	  case 0x5e:
	    /* jsr -> bsr */
	    bfd_put_8(abfd, 0x55, data+dst_address-1);
	    break;
	  case 0x5a:	 
	    /* jmp ->bra */
	    bfd_put_8(abfd, 0x40, data+dst_address-1);
	    break;
	  
	  default:
	    abort();
	  
	  }
	
	

	     
	  dst_address++;
	  src_address+=3;
  
	  break;
	}

	     
	case R_MOVB2:
	  /* Special relaxed type, there will be a gap between where we
	     get stuff from and where we put stuff to now 
	     
	     for a mov.b @aa:16 -> mov.b @aa:8
	     opcode 0x6a 0x0y offset
	     ->     0x2y off
	     */
	  if (data[dst_address-1] != 0x6a)
	   abort();
	  switch (data[dst_address] & 0xf0) 
	  {
	  case 0x00:
	    /* Src is memory */
	    data[dst_address-1] = (data[src_address] & 0xf) | 0x20;
	    break;
	  case 0x80:
	    /* Src is reg */
	    data[dst_address-1] = (data[src_address] & 0xf) | 0x30;
	    break;
	  default:
	    abort();
	  }
	
	  /* the offset must fit ! after all, what was all the relaxing
	     about ? */

	  bfd_put_8(abfd, get_value(reloc, seclet), data + dst_address);

	  /* Note the magic - src goes up by two bytes, but dst by only
	     one */
	  dst_address+=1;
	  src_address+=3;
	
	  break;
	  /* PCrel 8 bits */
	case R_PCRBYTE:	  
	{
	  bfd_vma dot = seclet->offset + dst_address + seclet->u.indirect.section->output_section->vma;	  
	  int   gap = get_value(reloc,seclet)-dot;
	  if (gap > 127 || gap < -128) 
	  {
	    bfd_error_vector.reloc_value_truncated(reloc, seclet);
	  }
	  
	  bfd_put_8(abfd,gap,   data+dst_address);
	  dst_address++;
	  src_address++;
  
	  break;
	}

	case R_RELBYTE:
	{
	  unsigned  int gap =get_value(reloc,seclet);
	  if (gap > 256)
	  {
	    bfd_error_vector.reloc_value_truncated(reloc, seclet);
	  }
	  
	  bfd_put_8(abfd, gap, data+dst_address);
	  dst_address+=1;
	  src_address+=1;


	}
	  break; 
	case R_JMP1:
	  /* A relword which would have like to have been a pcrel */
	case R_MOVB1:	
	  /* A relword which would like to have been modified but
	     didn't make it */
	case R_RELWORD:
	  bfd_put_16(abfd, get_value(reloc,seclet), data+dst_address);
	  dst_address+=2;
	  src_address+=2;
	  break;
	
	default:
	  abort();
	}
      }    
    }
  }
  free((char *)reloc_vector);
  return data;
  
}

void
DEFUN(rel,(abfd, seclet, output_section),
      bfd *abfd AND
      bfd_seclet_type *seclet AND
      asection *output_section)
{
  bfd_byte *data;
  if (output_section->flags & SEC_HAS_CONTENTS )
  {
    
  data = bfd_get_relocated_section_contents(abfd, seclet);

  if(bfd_set_section_contents(abfd,
			      output_section,
			      data,
			      seclet->offset,
			      seclet->size) == false)
  {
    abort();
  }
  
}

    

  

}

void
DEFUN(seclet_dump_seclet,(abfd, seclet, section),
      bfd *abfd AND
      bfd_seclet_type *seclet AND
      asection *section)
{
  switch (seclet->type) 
  {
    
  case bfd_indirect_seclet:
    /* The contents of this section come from another one somewhere
       else */
    rel(abfd, seclet, section);
    
    
    break;
    
  default:
    abort();
  }
  


}

void
DEFUN(seclet_dump,(abfd),
      bfd *abfd)
{
  /* Write all the seclets on the bfd out, relocate etc according to the
     rules */

  asection *o = abfd->sections;
  while (o != (asection *)NULL) 
  {
    bfd_seclet_type *p = o->seclets_head;
    while (p != (bfd_seclet_type *)NULL) 
    {
      seclet_dump_seclet(abfd, p, o);
      p = p ->next;
    }
 
    o = o->next;
  }

}