/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*	Copyright (c) 1988 AT&T	*/
/*	Copyright (c) 1989 AT&T	*/
/*	  All Rights Reserved  	*/


#pragma ident	"%Z%%M%	%I%	%E% SMI"

/* UNIX HEADER */
#include <stdio.h>

/* SIZE HEADERS */
#include "defs.h"

/* ELF HEADERS */
#include "gelf.h"


/* SIZE FUNCTIONS CALLED */
extern void	error();


/* FORMAT STRINGS */

static const char *prusect[3] = {
	"%llx",
	"%llo",
	"%lld"
};

static const char *prusum[3] = {
	" = 0x%llx\n",
	" = 0%llo\n",
	" = %lld\n"
};

static const char *format[3] = {
	"%llx + %llx + %llx = 0x%llx\n",
	"%llo + %llo + %llo = 0%llo\n",
	"%lld + %lld + %lld = %lld\n"
};


void
process(Elf * elf)
{
	/* EXTERNAL VARIABLES USED */
	extern int	fflag, /* full format for sections */
			Fflag, /* full format for segments */
			nflag; /* include non-loadable segments or sections */
	extern int	numbase; /* hex, octal, or decimal */
	extern char	*fname;
	extern char	*archive;
	extern int	is_archive;
	extern int	oneflag;

	/* LOCAL VARIABLES */
	GElf_Xword	size, /* total size in non-default case for sections */
			/*
			 * size of first, second, third number and total size
			 * in default case for sections.
			 */
			first,
			second,
			third,
			totsize;
	GElf_Ehdr	ehdr;
	GElf_Shdr	shdr;
	Elf_Scn		*scn;
	unsigned	ndx = 0;
	int		numsect = 0;
	int		notfirst = 0;
	int		i;
	char		*name = 0;
	static void	process_phdr(Elf *elf, GElf_Half num);

/*
 * If there is a program header and the -f flag requesting section infor-
 * mation is not set, then process segments with the process_phdr function.
 * Otherwise, process sections.  For the default case, the first number
 * shall be the size of all sections that are allocatable, nonwritable and
 * not of type NOBITS; the second number shall be the size of all sections
 * that are allocatable, writable, and not of type NOBITS; the third number
 * is the size of all sections that are writable and not of type NOBITS.
 * If -f is set, print the size of each allocatable section, followed by
 * the section name in parentheses.
 * If -n is set, print the size of all sections, followed by the section
 * name in parentheses.
 */

	if (gelf_getehdr(elf, &ehdr) == 0) {
		error(fname, "invalid file type");
		return;
	}
	if ((ehdr.e_phnum != 0) && !(fflag)) {
		process_phdr(elf, ehdr.e_phnum);
		return;
	}

	if (is_archive) {
		(void) printf("%s[%s]: ", archive, fname);
	} else if (!oneflag && !is_archive) {
		(void) printf("%s: ", fname);
	}
	ndx = ehdr.e_shstrndx;
	scn = 0;
	size = 0;
	first = second = third = totsize = 0;
	if (ehdr.e_shnum == 0) {
		error(fname, "no section data");
	}
	numsect = ehdr.e_shnum;
	for (i = 0; i < numsect; i++) {
		if ((scn = elf_nextscn(elf, scn)) == 0) {
			break;
		}
		if (gelf_getshdr(scn, &shdr) == 0) {
			error(fname, "could not get section header");
			break;
		}
		if ((Fflag) && !(fflag)) {
			error(fname, "no segment data");
			return;
		} else if ((!(shdr.sh_flags & SHF_ALLOC)) &&
			fflag && !(nflag)) {
			continue;
		} else if ((!(shdr.sh_flags & SHF_ALLOC)) && !(nflag)) {
			continue;
		} else if ((shdr.sh_flags & SHF_ALLOC) &&
			(!(shdr.sh_flags & SHF_WRITE)) &&
			(!(shdr.sh_type == SHT_NOBITS)) &&
			!(fflag) && !(nflag)) {
			first += shdr.sh_size;
		} else if ((shdr.sh_flags & SHF_ALLOC) &&
			(shdr.sh_flags & SHF_WRITE) &&
			(!(shdr.sh_type == SHT_NOBITS)) &&
			!(fflag) && !(nflag)) {
			second += shdr.sh_size;
		} else if ((shdr.sh_flags & SHF_WRITE) &&
			(shdr.sh_type == SHT_NOBITS) &&
			!(fflag) && !(nflag)) {
			third += shdr.sh_size;
		}
		name = elf_strptr(elf, ndx, (size_t)shdr.sh_name);

		if (fflag || nflag) {
			size += shdr.sh_size;
			if (notfirst) {
				(void) printf(" + ");
			}
			(void) printf(prusect[numbase], shdr.sh_size);
			(void) printf("(%s)", name);
		}
		notfirst++;
	}
	if ((fflag || nflag) && (numsect > 0)) {
		(void) printf(prusum[numbase], size);
	}

	if (!fflag && !nflag) {
		totsize = first + second + third;
		(void) printf(format[numbase],
			first, second, third, totsize);
	}

	if (Fflag) {
		if (ehdr.e_phnum != 0) {
			process_phdr(elf, ehdr.e_phnum);
			return;
		} else {
			error(fname, "no segment data");
			return;
		}
	}
}

/*
 * If there is a program exection header, process segments. In the default
 * case, the first number is the file size of all nonwritable segments
 * of type PT_LOAD; the second number is the file size of all writable
 * segments whose type is PT_LOAD; the third number is the memory size
 * minus the file size of all writable segments of type PT_LOAD.
 * If the -F flag is set, size will print the memory size of each loadable
 * segment, followed by its permission flags.
 * If -n is set, size will print the memory size of all loadable segments
 * and the file size of all non-loadable segments, followed by their
 * permission flags.
 */

static void
process_phdr(Elf * elf, GElf_Half num)
{
	int		i;
	int		notfirst = 0;
	GElf_Phdr	p;
	GElf_Xword	memsize,
			total,
			First,
			Second,
			Third,
			Totsize;
		extern int Fflag;
		extern int nflag;
		extern int numbase;
		extern char *fname;
		extern char *archive;
		extern int is_archive;
		extern int oneflag;

	memsize = total = 0;
	First = Second = Third = Totsize = 0;

	if (is_archive) {
		(void) printf("%s[%s]: ", archive, fname);
	} else if (!oneflag && !is_archive) {
		(void) printf("%s: ", fname);
	}

	for (i = 0; i < (int)num; i++) {
		if (gelf_getphdr(elf, i, &p) == NULL) {
			error(fname, "no segment data");
			return;
		}
		if ((!(p.p_flags & PF_W)) &&
		    (p.p_type == PT_LOAD) && !(Fflag)) {
			First += p.p_filesz;
		} else if ((p.p_flags & PF_W) &&
		    (p.p_type == PT_LOAD) && !(Fflag)) {
			Second += p.p_filesz;
			Third += p.p_memsz;
		}
		memsize += p.p_memsz;
		if ((p.p_type == PT_LOAD) && nflag) {
			if (notfirst) {
				(void) printf(" + ");
			}
			(void) printf(prusect[numbase], p.p_memsz);
			total += p.p_memsz;
			notfirst++;
		}
		if (!(p.p_type == PT_LOAD) && nflag) {
			if (notfirst) {
				(void) printf(" + ");
			}
			(void) printf(prusect[numbase], p.p_filesz);
			total += p.p_filesz;
			notfirst++;
		}
		if ((p.p_type == PT_LOAD) && Fflag && !nflag) {
			if (notfirst) {
				(void) printf(" + ");
			}
			(void) printf(prusect[numbase], p.p_memsz);
			notfirst++;
		}
		if ((Fflag) && !(nflag) && (!(p.p_type == PT_LOAD))) {
			continue;
		}
		if (Fflag || nflag) {
			switch (p.p_flags) {
			case 0: (void) printf("(---)"); break;
			case PF_X: (void) printf("(--x)"); break;
			case PF_W: (void) printf("(-w-)"); break;
			case PF_W+PF_X: (void) printf("(-wx)"); break;
			case PF_R: (void) printf("(r--)"); break;
			case PF_R+PF_X: (void) printf("(r-x)"); break;
			case PF_R+PF_W: (void) printf("(rw-)"); break;
			case PF_R+PF_W+PF_X: (void) printf("(rwx)"); break;
			default: (void) printf("flags(%#x)", p.p_flags);
			}
		}
	}
	if (nflag) {
		(void) printf(prusum[numbase], total);
	}
	if (Fflag && !nflag) {
		(void) printf(prusum[numbase], memsize);
	}
	if (!Fflag && !nflag) {
		Totsize = First + Second + (Third - Second);
		(void) printf(format[numbase],
			First, Second, Third - Second, Totsize);
	}
}