elf2ecoff.c

Linux内核源代码 为压缩文件 是<<Linux内核>>一书中的源代码

    }

  if (must_convert_endian)
	convert_ecoff_filehdr (&efh);
  /* Write the headers... */
  i = write (outfile, &efh, sizeof efh);
  if (i != sizeof efh)
    {
      perror ("efh: write");
      exit (1);

    for (i = 0; i < nosecs; i++)
      {
        printf ("Section %d: %s phys %x  size %x  file offset %x\n", 
	      i, esecs [i].s_name, esecs [i].s_paddr,
	      esecs [i].s_size, esecs [i].s_scnptr);
      }
    }
  fprintf (stderr, "wrote %d byte file header.\n", i);

  if (must_convert_endian)
	convert_ecoff_aouthdr (&eah);
  i = write (outfile, &eah, sizeof eah);
  if (i != sizeof eah)
    {
      perror ("eah: write");
      exit (1);
    }
  fprintf (stderr, "wrote %d byte a.out header.\n", i);

  if (must_convert_endian)
	convert_ecoff_esecs (&esecs[0], nosecs);
  i = write (outfile, &esecs, nosecs * sizeof(struct scnhdr));
  if (i != nosecs * sizeof(struct scnhdr))
    {
      perror ("esecs: write");
      exit (1);
    }
  fprintf (stderr, "wrote %d bytes of section headers.\n", i);

  if (pad = ((sizeof efh + sizeof eah + nosecs * sizeof(struct scnhdr)) & 15))
    {
      pad = 16 - pad;
      i = write (outfile, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0", pad);
      if (i < 0)
	{
	  perror ("ipad: write");
	  exit (1);
	}
      fprintf (stderr, "wrote %d byte pad.\n", i);
    }

  /* Copy the loadable sections.   Zero-fill any gaps less than 64k;
     complain about any zero-filling, and die if we're asked to zero-fill
     more than 64k. */
  for (i = 0; i < ex.e_phnum; i++)
    {
      /* Unprocessable sections were handled above, so just verify that
	 the section can be loaded before copying. */
      if (ph [i].p_type == PT_LOAD && ph [i].p_filesz)
	{
	  if (cur_vma != ph [i].p_vaddr)
	    {
	      unsigned long gap = ph [i].p_vaddr - cur_vma;
	      char obuf [1024];
	      if (gap > 65536)
		{
		  fprintf (stderr, "Intersegment gap (%d bytes) too large.\n",
			   gap);
		  exit (1);
		}
	      fprintf (stderr, "Warning: %d byte intersegment gap.\n", gap);
	      memset (obuf, 0, sizeof obuf);
	      while (gap)
		{
		  int count = write (outfile, obuf, (gap > sizeof obuf
						     ? sizeof obuf : gap));
		  if (count < 0)
		    {
		      fprintf (stderr, "Error writing gap: %s\n",
			       strerror (errno));
		      exit (1);
		    }
		  gap -= count;
		}
	    }
fprintf (stderr, "writing %d bytes...\n", ph [i].p_filesz);
	  copy (outfile, infile, ph [i].p_offset, ph [i].p_filesz);
	  cur_vma = ph [i].p_vaddr + ph [i].p_filesz;
	}
    }

   /*
     * Write a page of padding for boot PROMS that read entire pages.
     * Without this, they may attempt to read past the end of the
     * data section, incur an error, and refuse to boot.
     */
    {
	char obuf[4096];
	memset(obuf, 0, sizeof obuf);
	if (write(outfile, obuf, sizeof(obuf)) != sizeof(obuf)) {
	    fprintf(stderr, "Error writing PROM padding: %s\n",
		    strerror(errno));
	    exit(1);
	}
    }

  /* Looks like we won... */
  exit (0);
}

copy (out, in, offset, size)
     int out, in;
     off_t offset, size;
{
  char ibuf [4096];
  int remaining, cur, count;

  /* Go the the start of the ELF symbol table... */
  if (lseek (in, offset, SEEK_SET) < 0)
    {
      perror ("copy: lseek");
      exit (1);
    }

  remaining = size;
  while (remaining)
    {
      cur = remaining;
      if (cur > sizeof ibuf)
	cur = sizeof ibuf;
      remaining -= cur;
      if ((count = read (in, ibuf, cur)) != cur)
	{
	  fprintf (stderr, "copy: read: %s\n",
		   count ? strerror (errno) : "premature end of file");
	  exit (1);
	}
      if ((count = write (out, ibuf, cur)) != cur)
	{
	  perror ("copy: write");
	  exit (1);
	}
    }
}

/* Combine two segments, which must be contiguous.   If pad is true, it's
   okay for there to be padding between. */
combine (base, new, pad)
     struct sect *base, *new;
     int pad;
{
  if (!base -> len)
    *base = *new;
  else if (new -> len)
    {
      if (base -> vaddr + base -> len != new -> vaddr)
	{
	  if (pad)
	    base -> len = new -> vaddr - base -> vaddr;
	  else
	    {
	      fprintf (stderr,
		       "Non-contiguous data can't be converted.\n");
	      exit (1);
	    }
	}
      base -> len += new -> len;
    }
}

phcmp (h1, h2)
     Elf32_Phdr *h1, *h2;
{
  if (h1 -> p_vaddr > h2 -> p_vaddr)
    return 1;
  else if (h1 -> p_vaddr < h2 -> p_vaddr)
    return -1;
  else
    return 0;
}

char *saveRead (int file, off_t offset, off_t len, char *name)
{
  char *tmp;
  int count;
  off_t off;
  if ((off = lseek (file, offset, SEEK_SET)) < 0)
    {
      fprintf (stderr, "%s: fseek: %s\n", name, strerror (errno));
      exit (1);
    }
  if (!(tmp = (char *)malloc (len)))
    {
      fprintf (stderr, "%s: Can't allocate %d bytes.\n", name, len);
      exit (1);
    }
  count = read (file, tmp, len);
  if (count != len)
    {
      fprintf (stderr, "%s: read: %s.\n",
	       name, count ? strerror (errno) : "End of file reached");
      exit (1);
    }
  return tmp;
}

#define swab16(x) \
	((unsigned short)( \
		(((unsigned short)(x) & (unsigned short)0x00ffU) << 8) | \
		(((unsigned short)(x) & (unsigned short)0xff00U) >> 8) ))

#define swab32(x) \
	((unsigned int)( \
		(((unsigned int)(x) & (unsigned int)0x000000ffUL) << 24) | \
		(((unsigned int)(x) & (unsigned int)0x0000ff00UL) <<  8) | \
		(((unsigned int)(x) & (unsigned int)0x00ff0000UL) >>  8) | \
		(((unsigned int)(x) & (unsigned int)0xff000000UL) >> 24) ))

void convert_elf_hdr (Elf32_Ehdr *e)
{
	e->e_type      = swab16(e->e_type);
	e->e_machine   = swab16(e->e_machine);
	e->e_version   = swab32(e->e_version);
	e->e_entry     = swab32(e->e_entry);
	e->e_phoff     = swab32(e->e_phoff);
	e->e_shoff     = swab32(e->e_shoff);
	e->e_flags     = swab32(e->e_flags);
	e->e_ehsize    = swab16(e->e_ehsize);
	e->e_phentsize = swab16(e->e_phentsize);
	e->e_phnum     = swab16(e->e_phnum);
	e->e_shentsize = swab16(e->e_shentsize);
	e->e_shnum     = swab16(e->e_shnum);
	e->e_shstrndx  = swab16(e->e_shstrndx);
}

void convert_elf_phdrs (Elf32_Phdr *p, int num)
{
	int i;

	for (i = 0; i < num; i++,p++) {
		p->p_type   = swab32(p->p_type);
		p->p_offset = swab32(p->p_offset);
		p->p_vaddr  = swab32(p->p_vaddr);
		p->p_paddr  = swab32(p->p_paddr);
		p->p_filesz = swab32(p->p_filesz);
		p->p_memsz  = swab32(p->p_memsz);
		p->p_flags  = swab32(p->p_flags);
		p->p_align  = swab32(p->p_align);
	}

}

void convert_elf_shdrs (Elf32_Shdr *s, int num)
{
	int i;

	for (i = 0; i < num; i++,s++) {
		s->sh_name      = swab32(s->sh_name);
		s->sh_type      = swab32(s->sh_type);
		s->sh_flags     = swab32(s->sh_flags);
		s->sh_addr      = swab32(s->sh_addr);
		s->sh_offset    = swab32(s->sh_offset);
		s->sh_size      = swab32(s->sh_size);
		s->sh_link      = swab32(s->sh_link);
		s->sh_info      = swab32(s->sh_info);
		s->sh_addralign = swab32(s->sh_addralign);
		s->sh_entsize   = swab32(s->sh_entsize);
	}
}

void convert_ecoff_filehdr(struct filehdr *f)
{
	f->f_magic  = swab16(f->f_magic);
	f->f_nscns  = swab16(f->f_nscns);
	f->f_timdat = swab32(f->f_timdat);
	f->f_symptr = swab32(f->f_symptr);
	f->f_nsyms  = swab32(f->f_nsyms);
	f->f_opthdr = swab16(f->f_opthdr);
	f->f_flags  = swab16(f->f_flags);
}

void convert_ecoff_aouthdr(struct aouthdr *a)
{
	a->magic      = swab16(a->magic);
	a->vstamp     = swab16(a->vstamp);
	a->tsize      = swab32(a->tsize);
	a->dsize      = swab32(a->dsize);
	a->bsize      = swab32(a->bsize);
	a->entry      = swab32(a->entry);
	a->text_start = swab32(a->text_start);
	a->data_start = swab32(a->data_start);
	a->bss_start  = swab32(a->bss_start);
	a->gprmask    = swab32(a->gprmask);
	a->cprmask[0] = swab32(a->cprmask[0]);
	a->cprmask[1] = swab32(a->cprmask[1]);
	a->cprmask[2] = swab32(a->cprmask[2]);
	a->cprmask[3] = swab32(a->cprmask[3]);
	a->gp_value   = swab32(a->gp_value);
}

void convert_ecoff_esecs(struct scnhdr *s, int num)
{
	int i;

	for (i = 0; i < num; i++, s++) {
		s->s_paddr   = swab32(s->s_paddr);
		s->s_vaddr   = swab32(s->s_vaddr);
		s->s_size    = swab32(s->s_size);
		s->s_scnptr  = swab32(s->s_scnptr);
		s->s_relptr  = swab32(s->s_relptr);
		s->s_lnnoptr = swab32(s->s_lnnoptr);
		s->s_nreloc  = swab16(s->s_nreloc);
		s->s_nlnno   = swab16(s->s_nlnno);
		s->s_flags   = swab32(s->s_flags);
	}
}