out.c

ELFkickers是一组elf工具

/* out.c: Output functions for each type of piece.
 *
 * Copyright (C) 1999-2001 by Brian Raiter, under the GNU General
 * Public License. No warranty. See COPYING for details.
 */

#include	<stdio.h>
#include	<string.h>
#include	"gen.h"
#include	"elf.h"
#include	"elftoc.h"
#include	"addr.h"
#include	"pieces.h"
#include	"shdrtab.h"
#include	"dynamic.h"
#include	"outbasic.h"
#include	"outtools.h"
#include	"out.h"


/* The beginning of every successful output.
 */
static char const *cprolog =
	"#include <stddef.h>\n"
	"#include \"elf.h\"\n"
	"\n";

/* All the macro definitions available for use in the output.
 */
#include	"names.h"

/* The output functions that go with each piece type.
 */
static int (*outfunctions[P_COUNT])(pieceinfo const*, void const*);

/* Outputs a section header index.
 */
static void outshdrname(int shndx)
{
    char const *str;

    if ((str = getshdrname(shndx)))
	out(str);
    else
	out(getname(shndx, section));
}

/* The output function for pieces of type P_UNCLAIMED, P_BYTES, or
 * P_SECTION. The contents are output either as a literal string, an
 * array of character values, or an array of hexadecimal byte values.
 * The last will be used if the contents contain an excess of
 * non-graphic, non-ASCII characters. Otherwise, one of the first two
 * representations will be selected based on whether or not the
 * contents appear to be null-terminated.
 */
static int bytesout(pieceinfo const *piece, void const *ptr)
{
    char const *str = ptr;
    char const *s;
    int		i, n, fullsize, size;

    fullsize = piece->size;
    if (!fullsize)
	return TRUE;
    for (size = fullsize ; size > 0 && !str[size - 1] ; --size) ;
    if (!size) {
	out("{ 0 }");
	return TRUE;
    }
    if (fullsize - size < 16)
	size = fullsize;

    n = stringsize(str, size);

    if (n * 2 > size * 3) {
	beginblock(TRUE);
	for (i = 0, s = str ; i < size ; ++i, ++s)
	    outf("0x%02X", (unsigned char)*s);
	if (size < fullsize)
	    outf("/* 0x00 x %d */", fullsize - size);
	endblock();
    } else if (size < fullsize || str[size - 1]) {
	beginblock(TRUE);
	for (i = 0, s = str ; i < size ; ++i, ++s)
	    out(cqchar(*s));
	if (size < fullsize)
	    outf("/* 0x00 x %d */", fullsize - size);
	endblock();
    } else
	outstring(str, size - 1);

    return TRUE;
}

/* The output functions for pieces of type P_HALVES. The contents will
 * be output as an array of hexadecimal or integer values, depending
 * on the range and average of the values.
 */
static int halvesout(pieceinfo const *piece, void const *ptr)
{
    Elf32_Half const   *half;
    char const	       *fmt = NULL;
    unsigned int	sum;
    int			i, fullsize, size;

    fullsize = piece->size / sizeof *half;
    half = ptr;
    for (size = fullsize ; size > 0 && !half[size - 1] ; --size) ;
    if (!size) {
	out("{ 0 }");
	return TRUE;
    }
    if (fullsize - size < 8)
	size = fullsize;

    sum = 0;
    for (i = 0, half = ptr ; i < size ; ++i, ++half) {
	if (*half > 0xFF) {
	    fmt = "0x%04X";
	    break;
	}
	sum += *half;
    }
    if (!fmt)
	fmt = sum / size < 16 ? "%u" : "0x%02X";

    beginblock(TRUE);
    for (i = 0, half = ptr ; i < size ; ++i, ++half)
	outf(fmt, (unsigned int)*half);
    if (size < fullsize) {
	char buf[32];
	sprintf(buf, "/* %s x %%d */", fmt);
	outf(buf, 0, fullsize - size);
    }
    endblock();

    return TRUE;
}

/* The output functions for pieces of type P_WORDS. The contents will
 * be output as an array of hexadecimal or integer values, depending
 * on the range and average of the values.
 */
static int wordsout(pieceinfo const *piece, void const *ptr)
{
    Elf32_Word const   *word;
    char const	       *fmt = NULL;
    unsigned int	sum;
    int			i, fullsize, size;

    fullsize = piece->size / sizeof *word;
    word = ptr;
    for (size = fullsize ; size > 0 && !word[size - 1] ; --size) ;
    if (!size) {
	out("{ 0 }");
	return TRUE;
    }
    if (fullsize - size < 8)
	size = fullsize;

    sum = 0;
    for (i = 0, word = ptr ; i < size ; ++i, ++word) {
	if (*word > 0xFFFF) {
	    fmt = "0x%08lX";
	    break;
	}
	sum += *word;
    }
    if (!fmt)
	fmt = sum / size < 256 ? "%lu" : "0x%04lX";

    beginblock(TRUE);
    for (i = 0, word = ptr ; i < size ; ++i, ++word)
	outf(fmt, (unsigned long)*word);
    if (size < fullsize) {
	char buf[32];
	sprintf(buf, "/* %s x %%d */", fmt);
	outf(buf, 0, fullsize - size);
    }
    endblock();

    return TRUE;
}

/* The output function for pieces of type P_NOTE. Most of the note
 * section is mainly free-form in nature, the only constraint being
 * alignment. It is displayed as an array of values, with line breaks
 * to indicate the beginning of a note header.
 */
static int noteout(pieceinfo const *piece, void const *ptr)
{
    Elf32_Word const   *word = ptr;
    int			i, n;

    beginblock(TRUE);
    i = 0;
    while (i < piece->size / 4) {
	n = (word[i] + word[i + 1] + 3) / 4;
	linebreak();
	outint(word[i++]);
	outint(word[i++]);
	outword(word[i++]);
	while (n-- && i < piece->size / 4)
	    outf("0x%08lX", (unsigned long)word[i++]);
    }
    endblock();
    return TRUE;
}

/* The output function for pieces of type P_HASH. The hash section is
 * simply displayed as an array of integers, with line breaks
 * indicating the starts of the bucket and chain arrays.
 */
static int hashout(pieceinfo const *piece, void const *ptr)
{
    Elf32_Word const   *word = ptr;
    Elf32_Shdr const   *shdr;
    int			i, n;

    beginblock(TRUE);
    n = piece->size / sizeof *word;
    if (n < 2 || (int)(word[0] + word[1] + 2) != n) {
	for (i = 0 ; i < n ; ++i, ++word)
	    outint(*word);
    } else {
	outint(word[0]);
	i = piecenum;
	if (word[1] && piece->shndx && (shdr = getshdr(piece->shndx))
				    && shdr->sh_link) {
	    for (i = 0 ; i < piecenum ; ++i)
		if (pieces[i].shndx == (int)(shdr->sh_link))
		    break;
	}
	if (i < piecenum
		&& word[1] * sizeof(Elf32_Sym) == (size_t)pieces[i].size)
	    outf("sizeof %s.%s / sizeof(Elf32_Sym)", varname, pieces[i].name);
	else
	    outint(word[1]);
	linebreak();
	for (i = 0 ; i < (int)word[0] ; ++i)
	    outint(word[i + 2]);
	linebreak();
	for (i = 0 ; i < (int)word[1] ; ++i)
	    outint(word[i + word[0] + 2]);
    }
    endblock();
    return TRUE;
}

/* The output functions for pieces of type P_SYMTAB. The contents are
 * interpreted as an array of Elf32_Sym structures.
 */
static int symsout(pieceinfo const *piece, void const *ptr)
{
    Elf32_Sym const    *sym;
    unsigned int	i;

    beginblock(TRUE);
    for (i = 0, sym = ptr ; i < piece->size / sizeof *sym ; ++i, ++sym) {
	beginblock(FALSE);
	outint(sym->st_name);
	out(getaddrstr(sym->st_value, NULL));
	outint(sym->st_size);
	outf("ELF32_ST_INFO(%s, %s)",
		getname(ELF32_ST_BIND(sym->st_info), symbind),
		getname(ELF32_ST_TYPE(sym->st_info), symtype));
	outint(sym->st_other);
	outshdrname(sym->st_shndx);
	endblock();
    }
    endblock();
    return TRUE;
}

/* The output function for pieces of type P_DYNAMIC. The contents are
 * displayed as an array of Elf32_Dyn structures. A first pass is used
 * to make connections between entries that have related information.
 */
static int dynout(pieceinfo const *piece, void const *ptr)
{
    char		addrs[N_DT_COUNT][128];
    int			shndx[N_DT_COUNT];
    Elf32_Dyn const    *dyn;
    unsigned int	i;
    int			n, done;

    memset(addrs, 0, sizeof addrs);
    memset(shndx, 0, sizeof shndx);

    for (i = 0, dyn = ptr ; i < piece->size / sizeof *dyn ; ++i, ++dyn) {
	switch (dyn->d_tag) {
	  case DT_STRTAB:
	    strcpy(addrs[N_DT_STRTAB],
		   getaddrstr(dyn->d_un.d_ptr, &shndx[N_DT_STRSZ]));
	    break;
	  case DT_REL:
	    strcpy(addrs[N_DT_REL],
		   getaddrstr(dyn->d_un.d_ptr, &shndx[N_DT_RELSZ]));
	    break;
	  case DT_RELA:
	    strcpy(addrs[N_DT_RELA],
		   getaddrstr(dyn->d_un.d_ptr, &shndx[N_DT_RELASZ]));
	    break;
	  case DT_JMPREL:
	    strcpy(addrs[N_DT_JMPREL],
		   getaddrstr(dyn->d_un.d_ptr, &shndx[N_DT_PLTRELSZ]));
	    break;
	  case DT_SYMINFO:
	    strcpy(addrs[N_DT_SYMINFO],
		   getaddrstr(dyn->d_un.d_ptr, &shndx[N_DT_SYMINSZ]));
	    break;
	  case DT_INIT_ARRAY:
	    strcpy(addrs[N_DT_INIT_ARRAY],
		   getaddrstr(dyn->d_un.d_ptr, &shndx[N_DT_INIT_ARRAYSZ]));
	    break;
	  case DT_FINI_ARRAY:
	    strcpy(addrs[N_DT_FINI_ARRAY],
		   getaddrstr(dyn->d_un.d_ptr, &shndx[N_DT_FINI_ARRAYSZ]));
	    break;
	  case DT_PREINIT_ARRAY:
	    strcpy(addrs[N_DT_PREINIT_ARRAY],
		   getaddrstr(dyn->d_un.d_ptr, &shndx[N_DT_PREINIT_ARRAYSZ]));
	    break;
	}
    }

    beginblock(TRUE);
    for (i = 0, dyn = ptr ; i < piece->size / sizeof *dyn ; ++i, ++dyn) {
	done = FALSE;
	beginblock(FALSE);
	out(getname(dyn->d_tag, dyntag));
	n = getdyntagid(dyn->d_tag);
	if (n <= 0) {
	    outf("{ %ld }", dyn->d_un.d_val);
	    done = TRUE;
	} else if (*addrs[n]) {
	    outf("{ %s }", addrs[n]);
	    done = TRUE;
	} else if (shndx[n]) {
	    outf("{ %s }", getsizestr(dyn->d_un.d_val, shndx[n]));
	    done = TRUE;
	} else {
	    switch (n) {
	      case N_DT_FLAGS:
		outf("{ %s }", getflags(dyn->d_un.d_val, dynflag));
		done = TRUE;
		break;
	      case N_DT_FLAGS_1:
		outf("{ %s }", getflags(dyn->d_un.d_val, dynflag1));
		done = TRUE;
		break;
	      case N_DT_FEATURE_1:
		outf("{ %s }", getflags(dyn->d_un.d_val, dynftrf1));
		done = TRUE;
		break;
	      case N_DT_POSFLAG_1:
		outf("{ %s }", getflags(dyn->d_un.d_val, dynposf1));
		done = TRUE;
		break;
	      case N_DT_RELAENT:
		if (dyn->d_un.d_val == sizeof(Elf32_Rela)) {
		    out("{ sizeof(Elf32_Rela) }");
		    done = TRUE;
		}
		break;
	      case N_DT_RELENT:
		if (dyn->d_un.d_val == sizeof(Elf32_Rel)) {
		    out("{ sizeof(Elf32_Rel) }");
		    done = TRUE;
		}
		break;
	      case N_DT_SYMENT:
		if (dyn->d_un.d_val == sizeof(Elf32_Sym)) {
		    out("{ sizeof(Elf32_Sym) }");
		    done = TRUE;
		}
		break;
	      case N_DT_SYMINENT: