tekhex.c

早期freebsd实现

unsigned int
DEFUN(tekhex_get_symtab,(abfd, table),
      bfd *abfd AND
      asymbol **table)
{
  tekhex_symbol_type *p = abfd->tdata.tekhex_data->symbols;
  unsigned int c = bfd_get_symcount(abfd)  ;
  table[c]= 0;
  while (p) {
    table[--c] = &(p->symbol);
    p = p->prev;
  }

  return bfd_get_symcount(abfd);
}
      
unsigned int
DEFUN(tekhex_get_symtab_upper_bound,(abfd),
      bfd *abfd)
{
  return (abfd->symcount+1) * (sizeof(struct tekhex_asymbol_struct *));

}

static boolean
DEFUN(tekhex_mkobject, (abfd), 
      bfd *abfd)
{
    tdata_type *tdata = (tdata_type *)bfd_alloc(abfd,  sizeof(tdata_type));
    abfd->tdata.tekhex_data = tdata;
    tdata->type = 1;
    tdata->head = (tekhex_data_list_type *)NULL;
    tdata->symbols = (struct tekhex_symbol_struct *)NULL;
tdata->data = (struct data_struct *)NULL;
    return true;
    
}

/* 
  Return true if the file looks like it's in TekHex format. Just look
  for a percent sign and some hex digits */
	

static bfd_target *
DEFUN(tekhex_object_p, (abfd),
      bfd *abfd)
{
  char b[4];
  asection *section;
  tekhex_init();
  
  bfd_seek(abfd, (file_ptr)0, SEEK_SET);
  bfd_read(b, 1, 4, abfd);

  if (b[0] != '%' || !ISHEX(b[1]) || !ISHEX(b[2]) || !ISHEX(b[3]))
    return (bfd_target*) NULL;

  tekhex_mkobject(abfd);

  pass_over(abfd, first_phase);
  return abfd->xvec;
}


static boolean
DEFUN(move_section_contents,(abfd, section, locationp, offset,count,
			     get),
      
      bfd *abfd AND
      asection *section AND
      PTR locationp AND
      file_ptr offset AND
      bfd_size_type count AND
      boolean get)
{
  bfd_vma addr;
  char *location = (char *)locationp;
  bfd_vma prev_number = 1;	/* Nothing can have this as a high bit*/
  struct data_struct *d = (struct data_struct *)NULL;  
  for (addr = section->vma; count != 0; count --, addr++)
    {

      bfd_vma chunk_number = addr & ~ CHUNK_MASK; /* Get high bits of address */
      bfd_vma low_bits = addr & CHUNK_MASK;
      if (chunk_number != prev_number) 
	{
	  /* Different chunk, so move pointer */
	  d = find_chunk(abfd, chunk_number);
	}

      if (get)    {
	if (d->chunk_init[low_bits]) 
	  {
	    *location = d->chunk_data[low_bits];
	  }
	else
	  {
	    *location = 0;
	  }
      }
      else {
	d->chunk_data[low_bits] =  *location ;
	d->chunk_init[low_bits] = (*location != 0);
      }


      location ++;

    }

}      
static boolean
DEFUN(tekhex_get_section_contents,(abfd, section, locationp, offset, count),
      bfd *abfd AND
      asection *section AND
      PTR locationp AND
      file_ptr offset AND
      bfd_size_type count)
{
  if (section->flags & (SEC_LOAD | SEC_ALLOC))
    {
      move_section_contents(abfd, section, locationp, offset, count, true);
      return true;
    }
  else return false;
}
      


boolean
DEFUN(tekhex_set_arch_mach,(abfd, arch, machine),
      bfd *abfd AND
      enum bfd_architecture arch AND
      unsigned long machine)
{
  return bfd_default_set_arch_mach(abfd, arch, machine);
}


/* we have to save up all the Tekhexords for a splurge before output,
    */

static boolean
DEFUN(tekhex_set_section_contents,(abfd, section, locationp, offset, bytes_to_do),
      bfd *abfd AND
      sec_ptr section AND
      PTR locationp AND
      file_ptr offset AND
      bfd_size_type bytes_to_do)
{

  if (abfd->output_has_begun == false) {
    /* The first time around, allocate enough sections to hold all the chunks */
    asection *s = abfd->sections;
    bfd_vma vma;
    for (s = abfd->sections; s ; s = s->next) {
      if (s->flags & SEC_LOAD) {
	for (vma = s->vma & ~CHUNK_MASK;
	     vma < s->vma + s->_raw_size;
	     vma += CHUNK_MASK)
	  find_chunk(abfd, vma);
      }
    }

  }
  if (section->flags & (SEC_LOAD | SEC_ALLOC))
    {
      move_section_contents(abfd, section, locationp, offset, bytes_to_do, false);
      return true;
    }
  else return false;

}


static void
DEFUN(writevalue,(dst, value),
      char **dst AND
      bfd_vma value)
{
  char *p = *dst;
  int len ;
  int shift;
  for (len = 8, shift = 28; shift  ; shift-=4, len--)
    {
      if ((value>>shift) & 0xf) {
	*p ++ = len + '0';
	while (len) {
	  *p ++ = digs[(value>>shift) &0xf];
	  shift-=4;
	  len --;
	}
	*dst = p;
	return;

      }
    }
  *p++ = '1';
  *p++ = '0';
  *dst = p;
}

static void
DEFUN(writesym,(dst, sym),
      char **dst AND
     CONST char *sym)
{
  char *p = *dst;
  int len = (sym?strlen(sym):0);
  if (len >= 16) {
    *p++ = '0';
    len = 16;
  }

  else {
    if (len == 0) {
      *p++ =  '1';
      sym = "$";
      len=1;
    }
    else
      {
	*p++ = digs[len];
      }
  }

  while (len--) {
    *p++ = *sym++;
  }
  *dst = p;
}

static void 
DEFUN(out,(abfd, type, start, end),
      bfd *abfd AND
      char type AND
      char *start AND
      char *end)
{
  int sum = 0;
  char *s;
  char front[6];
  front[0] = '%';
  TOHEX(front+1, end - start  + 5);
  front[3] = type;

  for (s = start; s < end; s++) {
    sum += sum_block[*s];
  }


  sum += sum_block[front[1]];/*  length */
  sum += sum_block[front[2]];
  sum += sum_block[front[3]];/* type */
  TOHEX(front+4, sum);
  bfd_write(front, 1, 6,abfd);
  end[0] = '\n';
  bfd_write(start, 1,end-start+1,abfd);

}
static boolean
DEFUN(tekhex_write_object_contents,(abfd),
     bfd *abfd)
{
  int bytes_written;
  char buffer[100];
  asymbol **p;
  tdata_type *tdata = abfd->tdata.tekhex_data;
  tekhex_data_list_type *list;
  asection *s;
  struct data_struct *d;
  bytes_written = 0;

  /* And the raw data */
  for (d = abfd->tdata.tekhex_data->data;
       d != (struct data_struct *)NULL;
       d = d->next)
    {
      int low;

      CONST int span=32;
      int addr;
      /* Write it in blocks of 32 bytes */

      for (addr = 0; addr < CHUNK_MASK + 1; addr+=span) 
	{
	  int need = 0;
	  /* Check to see if necessary */
	  for (low = 0; !need && low < span; low++) {
	    if (d->chunk_init[addr + low]) need = 1;
	  }
	  if (need){
	    char * dst = buffer;
	    writevalue(&dst, addr + d->vma);
	    for (low = 0; low <span; low++) {
	      TOHEX(dst, d->chunk_data[addr + low]);
	      dst+=2;
	    }
	    out(abfd, '6', buffer, dst);
	  }
	}
    }
  /* write all the section headers for the sections */
  for (s = abfd->sections ; s != (asection *)NULL ; s = s->next) 
    {
      char *dst = buffer;
      writesym(&dst, s->name);
      *dst++ = '1';
      writevalue(&dst, s->vma);
      writevalue(&dst,  s->vma + s->_raw_size);
      out(abfd, '3',buffer, dst);
    }

  /* And the symbols */
  for (p = abfd->outsymbols; *p; p++) {
    int section_code = bfd_decode_symclass  (*p);
    if (section_code != '?') { /* do not include debug symbols */
	asymbol *s = *p;
	char *dst = buffer;
	writesym(&dst, s->section->name);
  
	switch(section_code) {
	  case 'A':
	    *dst++ = '2';
	    break;
	  case 'a':
	    *dst++ = '6';
	    break;
	  case 'D':
	  case 'B':
	  case 'O':
	    *dst++ = '4';
	    break;
	  case 'd':
	  case 'b':
	  case 'o':
	    *dst++ = '8';
	    break;
	  case 'T':
	    *dst++ = '3';
	    break;
	  case 't':
	    *dst++ = '7';
	    break;
	  case 'C':
	  case 'U':
	    bfd_error=wrong_format;
	    return false;
	}

	writesym(&dst, s->name);
	writevalue(&dst, s->value + s->section->vma);
	out(abfd, '3', buffer, dst);
    }
  }

    
  /* And the terminator */
  bfd_write("%7081010\n", 1,9 , abfd);
return true;
}
    

static int 
DEFUN(tekhex_sizeof_headers,(abfd, exec),
      bfd *abfd AND
      boolean exec)
{
return 0;
}

static asymbol *
DEFUN(tekhex_make_empty_symbol, (abfd),
      bfd*abfd)
{
  tekhex_symbol_type *new=
    (tekhex_symbol_type *)bfd_zalloc (abfd, sizeof (struct tekhex_symbol_struct));
  new->symbol.the_bfd = abfd;
  new->prev = (struct tekhex_symbol_struct *)NULL;
  return &(new->symbol);
}

static void
DEFUN(tekhex_print_symbol,(ignore_abfd, filep, symbol, how),
      bfd            *ignore_abfd AND
      PTR           filep AND
      asymbol        *symbol AND
      bfd_print_symbol_type how)
{
  FILE *file = (FILE *)filep;
  switch (how) {
  case bfd_print_symbol_name:
    fprintf(file, "%s", symbol->name);
    break;
  case bfd_print_symbol_more:
    break;
  case bfd_print_symbol_nm:
    {
      int section_code = bfd_decode_symclass  (symbol);

      if (section_code == 'U')
	fprintf(file, "        ");
      fprintf_vma(file, symbol->value+symbol->section->vma);
      if (section_code == '?')
	{
	fprintf(file," ?");
        }
      else
	fprintf(file," %c", section_code);
      if (symbol->name)
        fprintf(file," %s", symbol->name);
    }
    break;
  case bfd_print_symbol_all:
    {
      CONST char *section_name = symbol->section->name;
      bfd_print_symbol_vandf((PTR) file, symbol);

	
      fprintf(file, " %-5s %s",
	      section_name,
	      symbol->name);
    }	
  }
}

#define FOO PROTO
#define tekhex_new_section_hook (FOO(boolean, (*), (bfd *, asection *)))bfd_true
#define tekhex_get_reloc_upper_bound (FOO(unsigned int, (*),(bfd*, asection *)))bfd_false
#define tekhex_canonicalize_reloc (FOO(unsigned int, (*),(bfd*,asection *, arelent **, asymbol **))) bfd_0


#define tekhex_openr_next_archived_file (FOO(bfd *, (*), (bfd*,bfd*))) bfd_nullvoidptr
#define tekhex_find_nearest_line (FOO(boolean, (*),(bfd*,asection*,asymbol**,bfd_vma, CONST char**, CONST char**, unsigned int *))) bfd_false
#define tekhex_generic_stat_arch_elt  (FOO(int, (*), (bfd *,struct stat *))) bfd_0


#define tekhex_core_file_failing_command (char *(*)())(bfd_nullvoidptr)
#define tekhex_core_file_failing_signal (int (*)())bfd_0
#define tekhex_core_file_matches_executable_p (FOO(boolean, (*),(bfd*, bfd*)))bfd_false
#define tekhex_slurp_armap bfd_true
#define tekhex_slurp_extended_name_table bfd_true
#define tekhex_truncate_arname (void (*)())bfd_nullvoidptr
#define tekhex_write_armap  (FOO( boolean, (*),(bfd *, unsigned int, struct orl *, unsigned int, int))) bfd_nullvoidptr
#define tekhex_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
#define	tekhex_close_and_cleanup	bfd_generic_close_and_cleanup
#define tekhex_bfd_debug_info_start bfd_void
#define tekhex_bfd_debug_info_end bfd_void
#define tekhex_bfd_debug_info_accumulate  (FOO(void, (*), (bfd *,	 asection *))) bfd_void
#define tekhex_bfd_get_relocated_section_contents bfd_generic_get_relocated_section_contents
#define tekhex_bfd_relax_section bfd_generic_relax_section
bfd_target tekhex_vec =
{
    "tekhex",			/* name */
    bfd_target_tekhex_flavour,
    true,			/* target byte order */
    true,			/* target headers byte order */
    ( EXEC_P |	/* object flags */
     HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
    (SEC_CODE|SEC_DATA|SEC_ROM|SEC_HAS_CONTENTS
     |SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* section flags */
    ' ',			/* ar_pad_char */
    16,				/* ar_max_namelen */
    1,				/* minimum alignment */
    _do_getb64, _do_putb64,  _do_getb32,
    _do_putb32, _do_getb16, _do_putb16, /* data */
    _do_getb64, _do_putb64,  _do_getb32,
    _do_putb32, _do_getb16, _do_putb16, /* hdrs */

  {
      _bfd_dummy_target,
      tekhex_object_p,		/* bfd_check_format */
      (struct bfd_target *(*)()) bfd_nullvoidptr,
      (struct bfd_target *(*)())     bfd_nullvoidptr,
  },
  {
      bfd_false,
      tekhex_mkobject,
      _bfd_generic_mkarchive,
      bfd_false,
  },
  {				/* bfd_write_contents */
      bfd_false,
      tekhex_write_object_contents,
      _bfd_write_archive_contents,
      bfd_false,
  },
    JUMP_TABLE(tekhex)
 };