/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*      Copyright (c) 1988 AT&T */
/*      Copyright (c) 1989 AT&T */
/*        All Rights Reserved   */


/* 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"
};

static void     process_phdr(Elf *elf, GElf_Half num);

void
process(Elf * elf)
{
        /* EXTERNAL VARIABLES USED */
        extern int      fflag; /* full format for sections */
        extern int      Fflag; /* full format for segments */
        extern int      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.
         */
        GElf_Xword      first;
        GElf_Xword      second;
        GElf_Xword      third;
        GElf_Xword      totsize;
        GElf_Ehdr       ehdr;
        GElf_Shdr       shdr;
        Elf_Scn         *scn;
        size_t          ndx = 0, shnum = 0;
        int             numsect = 0;
        int             notfirst = 0;
        int             i;
        char            *name = 0;


/*
 * 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);
        }
        if (elf_getshdrstrndx(elf, &ndx) == -1)
                error(fname, "no string table");
        scn = 0;
        size = 0;
        first = second = third = totsize = 0;

        if (elf_getshdrnum(elf, &shnum) == -1)
                error(fname, "can't get number of sections");

        if (shnum == 0)
                error(fname, "no section data");

        numsect = 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;
        GElf_Xword      total;
        GElf_Xword      First;
        GElf_Xword      Second;
        GElf_Xword      Third;
        GElf_Xword      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);
        }
}