int __acc_cdecl_main main(int argc, char *argv[])
{
        ......
    /* check options */
    ......
    /* start work */
    set_term(stdout);
    do_files(i,argc,argv);
        ......
    return exit_code;
}

void do_files(int i, int argc, char *argv[])
{
    ......
    for ( ; i < argc; i++)
    {
        infoHeader();
 
 
        const char *iname = argv;
        char oname[ACC_FN_PATH_MAX+1];
        oname[0] = 0;
 
 
        try {
            do_one_file(iname,oname);
        }......
    }
        ......
}

Packer *PackMaster::getPacker(InputFile *f)
{
    Packer *pp = visitAllPackers(try_pack, f, opt, f);
    if (!pp)
        throwUnknownExecutableFormat();
    pp->assertPacker();
    return pp;
}

Packer* PackMaster::visitAllPackers(visit_func_t func, InputFile *f, const options_t *o, void *user)
{
    Packer *p = NULL;
......
    // .exe
......
    // atari
......
// linux kernel
...... 
// linux
    if (!o->o_unix.force_execve)
{
           ......       
       if ((p = func(new PackLinuxElf64amd(f), user)) != NULL)
            return p;
        delete p; p = NULL;
        if ((p = func(new PackLinuxElf32armLe(f), user)) != NULL)
            return p;
        delete p; p = NULL;
        if ((p = func(new PackLinuxElf32armBe(f), user)) != NULL)
            return p;
        delete p; p = NULL;
        ......
        }       
    // psone
......
// .sys and .com
    ......
    // Mach (MacOS X PowerPC)
    ......
    return NULL;
}

static Packer* try_pack(Packer *p, void *user)
{
    if (p == NULL)
        return NULL;
    InputFile *f = (InputFile *) user;
    p->assertPacker();
    try {
        p->initPackHeader();
        f->seek(0,SEEK_SET);
        if (p->canPack())
        {
            if (opt->cmd == CMD_COMPRESS)
                p->updatePackHeader();
            f->seek(0,SEEK_SET);
            return p;
        }
    } catch (const IOException&) {
    } catch (...) {
        delete p;
        throw;
    }
    delete p;
    return NULL;
}

union {
     unsigned char buf[sizeof(Elf64_Ehdr) + 14*sizeof(Elf64_Phdr)];
     //struct { Elf64_Ehdr ehdr; Elf64_Phdr phdr; } e;
 } u;
 COMPILE_TIME_ASSERT(sizeof(u) <= 1024)
 
 
 fi->readx(u.buf, sizeof(u.buf));
 fi->seek(0, SEEK_SET);
 Elf64_Ehdr const *const ehdr = (Elf64_Ehdr *) u.buf;
 
 
 // now check the ELF header
 if (checkEhdr(ehdr) != 0)
     return false;
 
 
 // additional requirements for linux/elf386
 if (get_te16(&ehdr->e_ehsize) != sizeof(*ehdr)) {
     throwCantPack("invalid Ehdr e_ehsize; try '--force-execve'");
     return false;
 }
 if (e_phoff != sizeof(*ehdr)) {// Phdrs not contiguous with Ehdr
     throwCantPack("non-contiguous Ehdr/Phdr; try '--force-execve'");
     return false;
 }
 
 
 // The first PT_LOAD64 must cover the beginning of the file (0==p_offset).
 Elf64_Phdr const *phdr = phdri;
 for (unsigned j=0; j < e_phnum; ++phdr, ++j) {
     if (j >= 14)
         return false;
     if (phdr->T_LOAD64 == get_te32(&phdr->p_type)) {
         load_va = get_te64(&phdr->p_vaddr);
         upx_uint64_t file_offset = get_te64(&phdr->p_offset);
         if (~page_mask & file_offset) {
             if ((~page_mask & load_va) == file_offset) {
                 throwCantPack("Go-language PT_LOAD: try hemfix.c, or try '--force-execve'");
                 // Fixing it inside upx fails because packExtent() reads original file.
             }
             else {
                 throwCantPack("invalid Phdr p_offset; try '--force-execve'");
             }
             return false;
         }
         exetype = 1;
         break;
     }
 }

// We want to compress position-independent executable (gcc -pie)
   // main programs, but compressing a shared library must be avoided
   // because the result is no longer usable.  In theory, there is no way
   // to tell them apart: both are just ET_DYN.  Also in theory,
   // neither the presence nor the absence of any particular symbol name
   // can be used to tell them apart; there are counterexamples.
   // However, we will use the following heuristic suggested by
   // Peter S. Mazinger <[email]ps.m@gmx.net[/email]> September 2005:
   // If a ET_DYN has __libc_start_main as a global undefined symbol,
   // then the file is a position-independent executable main program
   // (that depends on libc.so.6) and is eligible to be compressed.
   // Otherwise (no __libc_start_main as global undefined): skip it.
   // Also allow  __uClibc_main  and  __uClibc_start_main .
 
 
   if (Elf32_Ehdr::ET_DYN==get_te16(&ehdr->e_type)) {
       // The DT_STRTAB has no designated length.  Read the whole file.
       alloc_file_image(file_image, file_size);
       fi->seek(0, SEEK_SET);
       fi->readx(file_image, file_size);
       memcpy(&ehdri, ehdr, sizeof(Elf64_Ehdr));
       phdri= (Elf64_Phdr       *)((size_t)e_phoff + file_image);  // do not free() !!
       shdri= (Elf64_Shdr const *)((size_t)e_shoff + file_image);  // do not free() !!
 
 
       //sec_strndx = &shdri[ehdr->e_shstrndx];
       //shstrtab = (char const *)(sec_strndx->sh_offset + file_image);
       sec_dynsym = elf_find_section_type(Elf64_Shdr::SHT_DYNSYM);
       if (sec_dynsym)
           sec_dynstr = get_te64(&sec_dynsym->sh_link) + shdri;
 
 
       int j= e_phnum;
       phdr= phdri;
       for (; --j>=0; ++phdr)
       if (Elf64_Phdr:T_DYNAMIC==get_te32(&phdr->p_type)) {
           dynseg= (Elf64_Dyn const *)(get_te64(&phdr->p_offset) + file_image);
           break;
       }
       // elf_find_dynamic() returns 0 if 0==dynseg.
       dynstr=          (char const *)elf_find_dynamic(Elf64_Dyn:T_STRTAB);
       dynsym=     (Elf64_Sym const *)elf_find_dynamic(Elf64_Dyn:T_SYMTAB);
 
 
       // Modified 2009-10-10 to detect a ProgramLinkageTable relocation
       // which references the symbol, because DT_GNU_HASH contains only
       // defined symbols, and there might be no DT_HASH.
 
 
       Elf64_Rela const *
       rela= (Elf64_Rela const *)elf_find_dynamic(Elf64_Dyn:T_RELA);
       Elf64_Rela const *
       jmprela= (Elf64_Rela const *)elf_find_dynamic(Elf64_Dyn:T_JMPREL);
       for (   int sz = elf_unsigned_dynamic(Elf64_Dyn:T_PLTRELSZ);
               0 < sz;
               (sz -= sizeof(Elf64_Rela)), ++jmprela
       ) {
           unsigned const symnum = get_te64(&jmprela->r_info) >> 32;
           char const *const symnam = get_te32(&dynsym[symnum].st_name) + dynstr;
           if (0==strcmp(symnam, "__libc_start_main")
           ||  0==strcmp(symnam, "__uClibc_main")
           ||  0==strcmp(symnam, "__uClibc_start_main"))
               goto proceed;
       }
 
 
       // 2016-10-09 DT_JMPREL is no more (binutils-2.26.1)?
       // Check the general case, too.
       for (   int sz = elf_unsigned_dynamic(Elf64_Dyn:T_RELASZ);
               0 < sz;
               (sz -= sizeof(Elf64_Rela)), ++rela
       ) {
           unsigned const symnum = get_te64(&rela->r_info) >> 32;
           char const *const symnam = get_te32(&dynsym[symnum].st_name) + dynstr;
           if (0==strcmp(symnam, "__libc_start_main")
           ||  0==strcmp(symnam, "__uClibc_main")
           ||  0==strcmp(symnam, "__uClibc_start_main"))
               goto proceed;
       }

             // Heuristic HACK for shared libraries (compare Darwin (MacOS) Dylib.)
        // If there is an existing DT_INIT, and if everything that the dynamic
        // linker ld-linux needs to perform relocations before calling DT_INIT
        // resides below the first SHT_EXECINSTR Section in one PT_LOAD, then
        // compress from the first executable Section to the end of that PT_LOAD.
        // We must not alter anything that ld-linux might touch before it calls
        // the DT_INIT function.
        //
        // Obviously this hack requires that the linker script put pieces
        // into good positions when building the original shared library,
        // and also requires ld-linux to behave.
 
        if (elf_find_dynamic(Elf64_Dyn:T_INIT)) {
            if (elf_has_dynamic(Elf64_Dyn:T_TEXTREL)) {
                throwCantPack("DT_TEXTREL found; re-compile with -fPIC");
                goto abandon;
            }
            Elf64_Shdr const *shdr = shdri;
            xct_va = ~0ull;
            for (j= e_shnum; --j>=0; ++shdr) {
                if (Elf64_Shdr::SHF_EXECINSTR & get_te32(&shdr->sh_flags)) {
                    xct_va = umin64(xct_va, get_te64(&shdr->sh_addr));
                }
            }
            // Rely on 0==elf_unsigned_dynamic(tag) if no such tag.
            upx_uint64_t const va_gash = elf_unsigned_dynamic(Elf64_Dyn:T_GNU_HASH);
            upx_uint64_t const va_hash = elf_unsigned_dynamic(Elf64_Dyn:T_HASH);
            if (xct_va < va_gash  ||  (0==va_gash && xct_va < va_hash)
            ||  xct_va < elf_unsigned_dynamic(Elf64_Dyn:T_STRTAB)
            ||  xct_va < elf_unsigned_dynamic(Elf64_Dyn:T_SYMTAB)
            ||  xct_va < elf_unsigned_dynamic(Elf64_Dyn:T_REL)
            ||  xct_va < elf_unsigned_dynamic(Elf64_Dyn:T_RELA)
            ||  xct_va < elf_unsigned_dynamic(Elf64_Dyn:T_JMPREL)
            ||  xct_va < elf_unsigned_dynamic(Elf64_Dyn:T_VERDEF)
            ||  xct_va < elf_unsigned_dynamic(Elf64_Dyn:T_VERSYM)
            ||  xct_va < elf_unsigned_dynamic(Elf64_Dyn:T_VERNEEDED) ) {
                throwCantPack("DT_ tag above stub");
                goto abandon;
            }
            for ((shdr= shdri), (j= e_shnum); --j>=0; ++shdr) {
                upx_uint64_t const sh_addr = get_te64(&shdr->sh_addr);
                if ( sh_addr==va_gash
                ||  (sh_addr==va_hash && 0==va_gash) ) {
                    shdr= &shdri[get_te32(&shdr->sh_link)];  // the associated SHT_SYMTAB
                    hatch_off = (char *)&ehdri.e_ident[11] - (char *)&ehdri;
                    break;
                }
            }
            ACC_UNUSED(shdr);
            xct_off = elf_get_offset_from_address(xct_va);
            goto proceed;  // But proper packing depends on checking xct_va.
        }
abandon:
        return false;
proceed: ;
    }

void PackUnix::pack(OutputFile *fo)
{
......
    // set options
......
    // init compression buffers
......
    fi->seek(0, SEEK_SET);
    pack1(fo, ft);  // generate Elf header, etc.
......

void PackLinuxElf64amd::pack1(OutputFile *fo, Filter &ft)
{
    super::pack1(fo, ft);
    if (0!=xct_off)  // shared library
        return;
    generateElfHdr(fo, stub_amd64_linux_elf_fold, getbrk(phdri, e_phnum) );
}

void PackLinuxElf64::pack1(OutputFile *fo, Filter & /*ft*/)
{
    ......
    page_size =  1u  <<lg2_page;
    page_mask = ~0ull<<lg2_page;
 
 
    progid = 0;  // getRandomId();  not useful, so do not clutter
    if (0!=xct_off) {  // shared library
        fi->seek(0, SEEK_SET);
        fi->readx(ibuf, xct_off);
 
 
        sz_elf_hdrs = xct_off;
        fo->write(ibuf, xct_off);
        memset(&linfo, 0, sizeof(linfo));
        fo->write(&linfo, sizeof(linfo));
}
......

struct l_info       // 12-byte trailer in header for loader (offset 116)
{
    uint32_t l_checksum;
    uint32_t l_magic;
    uint16_t l_lsize;
    uint8_t  l_version;
    uint8_t  l_format;
};

      ......
    // only execute if option present
    if (opt->o_unix.preserve_build_id) {
        ......
        if (buildid) {
            unsigned char *data = New(unsigned char, buildid->sh_size);
            memset(data,0,buildid->sh_size);
            fi->seek(0,SEEK_SET);
            fi->seek(buildid->sh_offset,SEEK_SET);
            fi->readx(data,buildid->sh_size);
 
            buildid_data  = data;
 
            o_elf_shnum = 3;
            memset(&shdrout,0,sizeof(shdrout));
 
            //setup the build-id
            memcpy(&shdrout.shdr[1],buildid, sizeof(shdrout.shdr[1]));
            shdrout.shdr[1].sh_name = 1;
 
            //setup the shstrtab
            memcpy(&shdrout.shdr[2],sec_strndx, sizeof(shdrout.shdr[2]));
            shdrout.shdr[2].sh_name = 20;
            shdrout.shdr[2].sh_size = 29; //size of our static shstrtab
        }
        ......
}

struct p_info       // 12-byte packed program header follows stub loader
{
    uint32_t p_progid;
    uint32_t p_filesize;
    uint32_t p_blocksize;
};

// append the compressed body
   if (pack2(fo, ft)) {
       // write block end marker (uncompressed size 0)
       b_info hdr; memset(&hdr, 0, sizeof(hdr));
       set_le32(&hdr.sz_cpr, UPX_MAGIC_LE32);
       fo->write(&hdr, sizeof(hdr));
   }
       ......

int PackLinuxElf64::pack2(OutputFile *fo, Filter &ft)
{
    Extent x;
    unsigned k;
    bool const is_shlib = (0!=xct_off);
......
// compress extents
    unsigned hdr_u_len = sizeof(Elf64_Ehdr) + sz_phdrs;
 
    unsigned total_in = xct_off - (is_shlib ? hdr_u_len : 0);
    unsigned total_out = xct_off;
 
    uip->ui_pass = 0;
ft.addvalue = 0;
......

   ......
int nx = 0;
for (k = 0; k < e_phnum; ++k) if (PT_LOAD64==get_te32(&phdri[k].p_type)) {
......
    if (0==nx || !is_shlib)
    packExtent(x, total_in, total_out,
        ((0==nx && (Elf64_Phdr:F_X & get_te64(&phdri[k].p_flags)))
            ? &ft : 0 ), fo, hdr_u_len);
    else
        total_in += x.size;
    hdr_u_len = 0;
    ++nx;
}
......

     sz_pack2a = fpad4(fo);  // MATCH01
        ......
    // Accounting only; ::pack3 will do the compression and output
    for (k = 0; k < e_phnum; ++k) { //
        total_in += find_LOAD_gap(phdri, k, e_phnum);
    }
 
    if ((off_t)total_in != file_size)
        throwEOFException();
 
    return 0;  // omit end-of-compression bhdr for now
}

void PackUnix::packExtent(
    const Extent &x,
    unsigned &total_in,
    unsigned &total_out,
    Filter *ft,
    OutputFile *fo,
    unsigned hdr_u_len
)
{
    ......
    if (hdr_u_len) {
        hdr_ibuf.alloc(hdr_u_len);
        fi->seek(0, SEEK_SET);
        int l = fi->readx(hdr_ibuf, hdr_u_len);
        (void)l;
    }
fi->seek(x.offset, SEEK_SET);
                ......

......
        for (off_t rest = x.size; 0 != rest; ) {
        int const filter_strategy = ft ? getStrategy(*ft) : 0;
        int l = fi->readx(ibuf, UPX_MIN(rest, (off_t)blocksize));
        if (l == 0) {
            break;
        }
        rest -= l;
 
        // Note: compression for a block can fail if the
        //       file is e.g. blocksize + 1 bytes long
 
        // compress
        ph.c_len = ph.u_len = l;
        ph.overlap_overhead = 0;
        unsigned end_u_adler = 0;
                ......

        ......
if (ft) {
    // compressWithFilters() updates u_adler _inside_ compress();
    // that is, AFTER filtering.  We want BEFORE filtering,
    // so that decompression checks the end-to-end checksum.
    end_u_adler = upx_adler32(ibuf, ph.u_len, ph.u_adler);
    ft->buf_len = l;
 
 
        // compressWithFilters() requirements?
    ph.filter = 0;
    ph.filter_cto = 0;
    ft->id = 0;
    ft->cto = 0;
 
    compressWithFilters(ft, OVERHEAD, NULL_cconf, filter_strategy,
                        0, 0, 0, hdr_ibuf, hdr_u_len);
}
else {
    (void) compress(ibuf, ph.u_len, obuf);    // ignore return value
}
......

   ......
if (ph.c_len < ph.u_len) {
    const upx_bytep tbuf = NULL;
    if (ft == NULL || ft->id == 0) tbuf = ibuf;
    ph.overlap_overhead = OVERHEAD;
    if (!testOverlappingDecompression(obuf, tbuf, ph.overlap_overhead)) {
        // not in-place compressible
        ph.c_len = ph.u_len;
    }
}
if (ph.c_len >= ph.u_len) {
    // block is not compressible
    ph.c_len = ph.u_len;
    memcpy(obuf, ibuf, ph.c_len);
    // must update checksum of compressed data
    ph.c_adler = upx_adler32(ibuf, ph.u_len, ph.saved_c_adler);
}
        ......

              ......
        // write block sizes
        b_info tmp;
        if (hdr_u_len) {
            unsigned hdr_c_len = 0;
            MemBuffer hdr_obuf;
            hdr_obuf.allocForCompression(hdr_u_len);
            int r = upx_compress(hdr_ibuf, hdr_u_len, hdr_obuf, &hdr_c_len, 0,
                ph.method, 10, NULL, NULL);
            if (r != UPX_E_OK)
                throwInternalError("header compression failed");
            if (hdr_c_len >= hdr_u_len)
                throwInternalError("header compression size increase");
            ph.saved_u_adler = upx_adler32(hdr_ibuf, hdr_u_len, init_u_adler);
            ph.saved_c_adler = upx_adler32(hdr_obuf, hdr_c_len, init_c_adler);
            ph.u_adler = upx_adler32(ibuf, ph.u_len, ph.saved_u_adler);
            ph.c_adler = upx_adler32(obuf, ph.c_len, ph.saved_c_adler);
            end_u_adler = ph.u_adler;
            memset(&tmp, 0, sizeof(tmp));
            set_te32(&tmp.sz_unc, hdr_u_len);
            set_te32(&tmp.sz_cpr, hdr_c_len);
            tmp.b_method = (unsigned char) ph.method;
            fo->write(&tmp, sizeof(tmp));
            b_len += sizeof(b_info);
            fo->write(hdr_obuf, hdr_c_len);
            total_out += hdr_c_len;
            total_in  += hdr_u_len;
            hdr_u_len = 0;  // compress hdr one time only
        }
        memset(&tmp, 0, sizeof(tmp));
        set_te32(&tmp.sz_unc, ph.u_len);
        set_te32(&tmp.sz_cpr, ph.c_len);
        if (ph.c_len < ph.u_len) {
            tmp.b_method = (unsigned char) ph.method;
            if (ft) {
                tmp.b_ftid = (unsigned char) ft->id;
                tmp.b_cto8 = ft->cto;
            }
        }
        fo->write(&tmp, sizeof(tmp));
        b_len += sizeof(b_info);
 
 
        if (ft) {
            ph.u_adler = end_u_adler;
        }
        // write compressed data
        if (ph.c_len < ph.u_len) {
            fo->write(obuf, ph.c_len);
            // Checks ph.u_adler after decompression, after unfiltering
            verifyOverlappingDecompression(ft);
        }
        else {
            fo->write(ibuf, ph.u_len);
        }
 
        total_in += ph.u_len;
        total_out += ph.c_len;
    }
}

struct b_info {     // 12-byte header before each compressed block
    uint32_t sz_unc;            // uncompressed_size
    uint32_t sz_cpr;            // compressed_size
    unsigned char b_method;     // compression algorithm
    unsigned char b_ftid;       // filter id
    unsigned char b_cto8;       // filter parameter
    unsigned char b_unused;
};

super::pack3(fo, ft);  // loader follows compressed PT_LOADs
   // Then compressed gaps (including debuginfo.)
   unsigned total_in = 0, total_out = 0;
   for (unsigned k = 0; k < e_phnum; ++k) {
       Extent x;
       x.size = find_LOAD_gap(phdri, k, e_phnum);
       if (x.size) {
           x.offset = get_te64(&phdri[k].p_offset) +
                      get_te64(&phdri[k].p_filesz);
           packExtent(x, total_in, total_out, 0, fo);
       }
   }
   // write block end marker (uncompressed size 0)
   b_info hdr; memset(&hdr, 0, sizeof(hdr));
   set_le32(&hdr.sz_cpr, UPX_MAGIC_LE32);
   fo->write(&hdr, sizeof(hdr));
   fpad4(fo);

   if (0!=xct_off) {  // shared library
        Elf64_Phdr *phdr = phdri;
        unsigned off = fo->st_size();
        unsigned off_init = 0;  // where in file
        upx_uint64_t va_init = sz_pack2;   // virtual address
        upx_uint64_t rel = 0;
        upx_uint64_t old_dtinit = 0;
        for (int j = e_phnum; --j>=0; ++phdr) {
            upx_uint64_t const len  = get_te64(&phdr->p_filesz);
            upx_uint64_t const ioff = get_te64(&phdr->p_offset);
            upx_uint64_t       align= get_te64(&phdr->p_align);
            unsigned const type = get_te32(&phdr->p_type);
            if (phdr->T_INTERP==type) {
                // Rotate to highest position, so it can be lopped
                // by decrementing e_phnum.
                memcpy((unsigned char *)ibuf, phdr, sizeof(*phdr));
                memmove(phdr, 1+phdr, j * sizeof(*phdr));  // overlapping
                memcpy(&phdr[j], (unsigned char *)ibuf, sizeof(*phdr));
                --phdr;
                set_te16(&ehdri.e_phnum, --e_phnum);
                continue;
            }
            if (phdr->T_LOAD==type) {
                if (xct_off < ioff) {  // Slide up non-first PT_LOAD.
                    // AMD64 chip supports page sizes of 4KiB, 2MiB, and 1GiB;
                    // the operating system chooses one.  .p_align typically
                    // is a forward-looking 2MiB.  In 2009 Linux chooses 4KiB.
                    // We choose 4KiB to waste less space.  If Linux chooses
                    // 2MiB later, then our output will not run.
                    if ((1u<<12) < align) {
                        align = 1u<<12;
                        set_te64(&phdr->p_align, align);
                    }
                    off += (align-1) & (ioff - off);
                    fi->seek(ioff, SEEK_SET); fi->readx(ibuf, len);
                    fo->seek( off, SEEK_SET); fo->write(ibuf, len);
                    rel = off - ioff;
                    set_te64(&phdr->p_offset, rel + ioff);
                }
                else {  // Change length of first PT_LOAD.
                    va_init += get_te64(&phdr->p_vaddr);
                    set_te64(&phdr->p_filesz, sz_pack2 + lsize);
                    set_te64(&phdr->p_memsz,  sz_pack2 + lsize);
                }
                continue;  // all done with this PT_LOAD
            }
            // Compute new offset of &DT_INIT.d_val.
            if (phdr->T_DYNAMIC==type) {
                off_init = rel + ioff;
                fi->seek(ioff, SEEK_SET);
                fi->read(ibuf, len);
                Elf64_Dyn *dyn = (Elf64_Dyn *)(void *)ibuf;
                for (int j2 = len; j2 > 0; ++dyn, j2 -= sizeof(*dyn)) {
                    if (dyn->DT_INIT==get_te64(&dyn->d_tag)) {
                        old_dtinit = dyn->d_val;  // copy ONLY, never examined
                        unsigned const t = (unsigned char *)&dyn->d_val -
                                           (unsigned char *)ibuf;
                        off_init += t;
                        break;
                    }
                }
                // fall through to relocate .p_offset
            }
            if (xct_off < ioff)
                set_te64(&phdr->p_offset, rel + ioff);
        }
        if (off_init) {  // change DT_INIT.d_val
            fo->seek(off_init, SEEK_SET);
            upx_uint64_t word; set_te64(&word, va_init);
            fo->rewrite(&word, sizeof(word));
            fo->seek(0, SEEK_END);
        }
        ehdri.e_shnum = 0;
        ehdri.e_shoff = old_dtinit;  // easy to find for unpacking
    }
}

void PackLinuxElf::pack3(OutputFile *fo, Filter &ft)
{
    unsigned disp;
    unsigned const zero = 0;
    unsigned len = sz_pack2a;  // after headers and all PT_LOAD
 
 
    unsigned const t = (4 & len) ^ ((!!xct_off)<<2);  // 0 or 4
    fo->write(&zero, t);
    len += t;

set_te32(&disp, 2*sizeof(disp) + len - (sz_elf_hdrs + sizeof(p_info) + sizeof(l_info)));
  fo->write(&disp, sizeof(disp));  // .e_entry - &first_b_info
  len += sizeof(disp);
  set_te32(&disp, len);  // distance back to beginning (detect dynamic reloc)
  fo->write(&disp, sizeof(disp));
  len += sizeof(disp);

if (xct_off) {  // is_shlib
       upx_uint64_t const firstpc_va = (jni_onload_va
           ? jni_onload_va
           : elf_unsigned_dynamic(Elf32_Dyn:T_INIT) );
       set_te32(&disp, firstpc_va - load_va);
       fo->write(&disp, sizeof(disp));
       len += sizeof(disp);
 
       set_te32(&disp, hatch_off);
       fo->write(&disp, sizeof(disp));
       len += sizeof(disp);
 
       set_te32(&disp, xct_off);
       fo->write(&disp, sizeof(disp));
       len += sizeof(disp);
   }
   sz_pack2 = len;  // 0 mod 8

super::pack3(fo, ft);  // append the decompressor
    set_te16(&linfo.l_lsize, up4(  // MATCH03: up4
    get_te16(&linfo.l_lsize) + len - sz_pack2a));
 
    len = fpad4(fo);  // MATCH03
    ACC_UNUSED(len);
}

void PackUnix::pack3(OutputFile *fo, Filter &/*ft*/)
{
    upx_byte *p = getLoader();
    lsize = getLoaderSize();
    updateLoader(fo);
    patchLoaderChecksum();
    fo->write(p, lsize);
}

void PackLinuxElf64::updateLoader(OutputFile * /*fo*/)
{
    set_te64(&elfout.ehdr.e_entry, sz_pack2 +
        get_te64(&elfout.phdr[0].p_vaddr));
}

void PackUnix::patchLoaderChecksum()
{
    unsigned char *const ptr = getLoader();
    l_info *const lp = &linfo;
    // checksum for loader; also some PackHeader info
    lp->l_magic = UPX_MAGIC_LE32;  // LE32 always
    set_te16(&lp->l_lsize, (upx_uint16_t) lsize);
    lp->l_version = (unsigned char) ph.version;
    lp->l_format  = (unsigned char) ph.format;
    // INFO: lp->l_checksum is currently unused
    set_te32(&lp->l_checksum, upx_adler32(ptr, lsize));
}

   ......
        pack4(fo, ft);  // append PackHeader and overlay_offset; update Elf header
 
 
    // finally check the compression ratio
    if (!checkFinalCompressionRatio(fo))
        throwNotCompressible();
}

    if (opt->o_unix.preserve_build_id) {
        // calc e_shoff here and write shdrout, then o_shstrtab
        //NOTE: these are pushed last to ensure nothing is stepped on
        //for the UPX structure.
        unsigned const len = fpad4(fo);
        set_te64(&elfout.ehdr.e_shoff,len);
 
        int const ssize = sizeof(shdrout);
 
        shdrout.shdr[2].sh_offset = len+ssize;
        shdrout.shdr[1].sh_offset = shdrout.shdr[2].sh_offset+shdrout.shdr[2].sh_size;
 
        fo->write(&shdrout, ssize);
 
        fo->write(o_shstrtab,shdrout.shdr[2].sh_size);
        fo->write(buildid_data,shdrout.shdr[1].sh_size);
}
......

      ......
        // Cannot pre-round .p_memsz.  If .p_filesz < .p_memsz, then kernel
    // tries to make .bss, which requires PF_W.
    // But strict SELinux (or PaX, grSecurity) disallows PF_W with PF_X.
    set_te64(&elfout.phdr[0].p_filesz, sz_pack2 + lsize);
              elfout.phdr[0].p_memsz = elfout.phdr[0].p_filesz;
super::pack4(fo, ft);  // write PackHeader and overlay_offset
......