Bug 1125 - Make ELF Reader 'jogamp.common.os.elf' Stateless

ELF Reader 'jogamp.common.os.elf' currently uses
Platform's pre-determined OS_TYPE and CPUType.

It also uses the host platforms MachineDescription,
hence can not read ELF files from other machines.

This also forbids Platform to determine CPUType etc
w/o having a valid 'os.arch' property.

+++

ElfHeader should be split in
  - ElfHeaderPart1 (CPUType independent)
  - ElfHeaderPart2 (CPUType dependent)

Fix shall make the ELF Reader self containing
by only using ELF CPUType data, etc.

This requires customization of struct parsing,
where MachineDescription.Static index shall be
  - defined in ElfHeaderPart1 using e_Ident's CPUType.
  - used in ElfHeaderPart2 and all its struct types.

1 files changed, 374 insertions, 0 deletions

diff --git a/src/java/jogamp/common/os/elf/ElfHeaderPart2.java b/src/java/jogamp/common/os/elf/ElfHeaderPart2.java
new file mode 100644
index 0000000..320b8b4
--- /dev/null
+++ b/src/java/jogamp/common/os/elf/ElfHeaderPart2.java
@@ -0,0 +1,374 @@
+/**
+ * Copyright 2013 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+package jogamp.common.os.elf;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+
+import com.jogamp.common.os.Platform.ABIType;
+import com.jogamp.common.os.Platform.CPUFamily;
+import com.jogamp.common.os.Platform.CPUType;
+
+import static jogamp.common.os.elf.IOUtils.readBytes;
+import static jogamp.common.os.elf.IOUtils.seek;
+import static jogamp.common.os.elf.IOUtils.shortToInt;
+import static jogamp.common.os.elf.IOUtils.toHexString;
+
+/**
+ * ELF ABI Header Part-2
+ * <p>
+ * Part-2 can only be read w/ knowledge of CPUType!
+ * </p>
+ * <p>
+ * References:
+ * <ul>
+ *   <li>http://linux.die.net/man/5/elf</li>
+ *   <li>http://www.sco.com/developers/gabi/latest/contents.html</li>
+ *   <li>http://infocenter.arm.com/
+ *   <ul>
+ *      <li>ARM IHI 0044E, current through ABI release 2.09</li>
+ *      <li>ARM IHI 0056B: Elf for ARM 64-bit Architecture</li>
+ *   </ul></li>
+ * </ul>
+ * </p>
+ */
+public class ElfHeaderPart2 {
+    /**
+     * This masks an 8-bit version number, the version of the ABI to which this
+     * ELF file conforms. This ABI is version 5. A value of 0 denotes unknown conformance.
+     * {@value}
+     */
+    public static final int EF_ARM_ABIMASK  = 0xFF000000;
+    public static final int EF_ARM_ABISHIFT  = 24;
+
+    /**
+     * ARM ABI version 5.
+     * {@value}
+     */
+    public static final int EF_ARM_ABI5  = 0x05000000;
+
+    /**
+     * The ELF file contains BE-8 code, suitable for execution on an ARM
+     * Architecture v6 processor. This flag must only be set on an executable file.
+     * {@value}
+     */
+    public static final int EF_ARM_BE8      = 0x00800000;
+
+    /**
+     * Legacy code (ABI version 4 and earlier) generated by gcc-arm-xxx might
+     * use these bits.
+     * {@value}
+     */
+    public static final int EF_ARM_GCCMASK  = 0x00400FFF;
+
+    /**
+     * Set in executable file headers (e_type = ET_EXEC or ET_DYN) to note that
+     * the executable file was built to conform to the hardware floating-point
+     * procedure-call standard.
+     * <p>
+     * Compatible with legacy (pre version 5) gcc use as EF_ARM_VFP_FLOAT.
+     * </p>
+     * <p>
+     * Note: This is not used (anymore)
+     * </p>
+     * {@value}
+     */
+    public static final int EF_ARM_ABI_FLOAT_HARD  = 0x00000400;
+
+    /**
+     * Set in executable file headers (e_type = ET_EXEC or ET_DYN) to note
+     * explicitly that the executable file was built to conform to the software
+     * floating-point procedure-call standard (the base standard). If both
+     * {@link #EF_ARM_ABI_FLOAT_HARD} and {@link #EF_ARM_ABI_FLOAT_SOFT} are clear,
+     * conformance to the base procedure-call standard is implied.
+     * <p>
+     * Compatible with legacy (pre version 5) gcc use as EF_ARM_SOFT_FLOAT.
+     * </p>
+     * <p>
+     * Note: This is not used (anymore)
+     * </p>
+     * {@value}
+     */
+    public static final int EF_ARM_ABI_FLOAT_SOFT  = 0x00000200;
+
+    /** Public access to the elf header part-1 (CPU/ABI independent read) */
+    public final ElfHeaderPart1 eh1;
+
+    /** Public access to the raw elf header part-2 (CPU/ABI dependent read) */
+    public final Ehdr_p2 raw;
+
+    /** Lower case CPUType name */
+    public final String cpuName;
+    public final CPUType cpuType;
+    public final ABIType abiType;
+
+    /** Public access to the {@link SectionHeader} */
+    public final SectionHeader[] sht;
+
+    /**
+     * Note: The input stream shall stay untouch to be able to read sections!
+     *
+     * @param in input stream of a binary file at position zero
+     * @return
+     * @throws IOException if reading from the given input stream fails or less then ELF Header size bytes
+     * @throws IllegalArgumentException if the given input stream does not represent an ELF Header
+     */
+    public static ElfHeaderPart2 read(final ElfHeaderPart1 eh1, final RandomAccessFile in) throws IOException, IllegalArgumentException {
+        return new ElfHeaderPart2(eh1, in);
+    }
+
+    /**
+     * @param buf ELF Header bytes
+     * @throws IllegalArgumentException if the given buffer does not represent an ELF Header
+     * @throws IOException
+     */
+    ElfHeaderPart2(final ElfHeaderPart1 eh1, final RandomAccessFile in) throws IllegalArgumentException, IOException {
+        this.eh1 = eh1;
+        //
+        // Part-2
+        //
+        {
+            final byte[] buf = new byte[Ehdr_p2.size(eh1.machDesc.ordinal())];
+            readBytes (in, buf, 0, buf.length);
+            final ByteBuffer eh2Bytes = ByteBuffer.wrap(buf, 0, buf.length);
+            raw = Ehdr_p2.create(eh1.machDesc.ordinal(), eh2Bytes);
+        }
+        sht = readSectionHeaderTable(in);
+
+        if( CPUFamily.ARM == eh1.cpuType.family && eh1.cpuType.is32Bit ) {
+            // AArch64, has no SHT_ARM_ATTRIBUTES or SHT_AARCH64_ATTRIBUTES SectionHeader defined in our builds!
+            String armCpuName = null;
+            String armCpuRawName = null;
+            boolean abiVFPArgsAcceptsVFPVariant = false;
+            final SectionHeader sh = getSectionHeader(SectionHeader.SHT_ARM_ATTRIBUTES);
+            if(ElfHeaderPart1.DEBUG) {
+                System.err.println("ELF-2: Got ARM Attribs Section Header: "+sh);
+            }
+            if( null != sh ) {
+                final SectionArmAttributes sArmAttrs = (SectionArmAttributes) sh.readSection(in);
+                if(ElfHeaderPart1.DEBUG) {
+                    System.err.println("ELF-2: Got ARM Attribs Section Block : "+sArmAttrs);
+                }
+                final SectionArmAttributes.Attribute cpuNameArgsAttr = sArmAttrs.get(SectionArmAttributes.Tag.CPU_name);
+                if( null != cpuNameArgsAttr && cpuNameArgsAttr.isNTBS() ) {
+                    armCpuName = cpuNameArgsAttr.getNTBS();
+                }
+                final SectionArmAttributes.Attribute cpuRawNameArgsAttr = sArmAttrs.get(SectionArmAttributes.Tag.CPU_raw_name);
+                if( null != cpuRawNameArgsAttr && cpuRawNameArgsAttr.isNTBS() ) {
+                    armCpuRawName = cpuRawNameArgsAttr.getNTBS();
+                }
+                final SectionArmAttributes.Attribute abiVFPArgsAttr = sArmAttrs.get(SectionArmAttributes.Tag.ABI_VFP_args);
+                if( null != abiVFPArgsAttr ) {
+                    abiVFPArgsAcceptsVFPVariant = SectionArmAttributes.abiVFPArgsAcceptsVFPVariant(abiVFPArgsAttr.getULEB128());
+                }
+            }
+            {
+                String _cpuName;
+                if( null != armCpuName && armCpuName.length() > 0 ) {
+                    _cpuName = armCpuName.toLowerCase().replace(' ', '-');
+                } else if( null != armCpuRawName && armCpuRawName.length() > 0 ) {
+                    _cpuName = armCpuRawName.toLowerCase().replace(' ', '-');
+                } else {
+                    _cpuName = eh1.cpuName;
+                }
+
+                // 1st-try: native name
+                CPUType _cpuType = queryCPUTypeSafe(_cpuName);
+                if( null == _cpuType ) {
+                    // 2nd-try: "arm-" + native name
+                    _cpuName = "arm-"+_cpuName;
+                    _cpuType = queryCPUTypeSafe(_cpuName);
+                    if( null == _cpuType ) {
+                        // finally: Use ELF-1
+                        _cpuName = eh1.cpuName;
+                        _cpuType = queryCPUTypeSafe(_cpuName);
+                        if( null == _cpuType ) {
+                            throw new InternalError("XXX: "+_cpuName+", "+eh1); // shall not happen
+                        }
+                    }
+                }
+                cpuName = _cpuName;
+                cpuType = _cpuType;
+                if(ElfHeaderPart1.DEBUG) {
+                    System.err.println("ELF-2: abiARM cpuName "+_cpuName+"[armCpuName "+armCpuName+", armCpuRawName "+armCpuRawName+"] -> "+cpuName+" -> "+cpuType+", abiVFPArgsAcceptsVFPVariant "+abiVFPArgsAcceptsVFPVariant);
+                }
+            }
+            if( cpuType.is32Bit ) { // always true, see above!
+                abiType = abiVFPArgsAcceptsVFPVariant ? ABIType.EABI_GNU_ARMHF : ABIType.EABI_GNU_ARMEL;
+            } else {
+                abiType = eh1.abiType;
+            }
+        } else {
+            cpuName = eh1.cpuName;
+            cpuType = eh1.cpuType;
+            abiType = eh1.abiType;
+        }
+        if(ElfHeaderPart1.DEBUG) {
+            System.err.println("ELF-2: cpuName "+cpuName+" -> "+cpuType+", "+abiType);
+        }
+    }
+    private static CPUType queryCPUTypeSafe(final String cpuName) {
+        CPUType res = null;
+        try {
+            res = CPUType.query(cpuName);
+        } catch (final Throwable t) {
+            if(ElfHeaderPart1.DEBUG) {
+                System.err.println("ELF-2: queryCPUTypeSafe("+cpuName+"): "+t.getMessage());
+            }
+        }
+        return res;
+    }
+
+    public final short getSize() { return raw.getE_ehsize(); }
+
+    /** Returns the processor-specific flags associated with the file. */
+    public final int getFlags() {
+        return raw.getE_flags();
+    }
+
+    /** Returns the ARM EABI version from {@link #getFlags() flags}, maybe 0 if not an ARM EABI. */
+    public byte getArmABI() {
+        return (byte) ( ( ( EF_ARM_ABIMASK & raw.getE_flags() ) >> EF_ARM_ABISHIFT ) & 0xff );
+    }
+
+    /** Returns the ARM EABI legacy GCC {@link #getFlags() flags}, maybe 0 if not an ARM EABI or not having legacy GCC flags. */
+    public int getArmLegacyGCCFlags() {
+        final int f = raw.getE_flags();
+        return 0 != ( EF_ARM_ABIMASK & f ) ? ( EF_ARM_GCCMASK & f ) : 0;
+    }
+
+    /**
+     * Returns the ARM EABI float mode from {@link #getFlags() flags},
+     * i.e. 1 for {@link #EF_ARM_ABI_FLOAT_SOFT}, 2 for {@link #EF_ARM_ABI_FLOAT_HARD}
+     * or 0 for none.
+     * <p>
+     * Note: This is not used (anymore)
+     * </p>
+     */
+    public byte getArmFloatMode() {
+        final int f = raw.getE_flags();
+        if( 0 != ( EF_ARM_ABIMASK & f ) ) {
+            if( ( EF_ARM_ABI_FLOAT_HARD & f ) != 0 ) {
+                return 2;
+            }
+            if( ( EF_ARM_ABI_FLOAT_SOFT & f ) != 0 ) {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    /** Returns the 1st occurence of matching SectionHeader {@link SectionHeader#getType() type}, or null if not exists. */
+    public final SectionHeader getSectionHeader(final int type) {
+        for(int i=0; i<sht.length; i++) {
+            final SectionHeader sh = sht[i];
+            if( sh.getType() == type ) {
+                return sh;
+            }
+        }
+        return null;
+    }
+
+    /** Returns the 1st occurence of matching SectionHeader {@link SectionHeader#getName() name}, or null if not exists. */
+    public final SectionHeader getSectionHeader(final String name) {
+        for(int i=0; i<sht.length; i++) {
+            final SectionHeader sh = sht[i];
+            if( sh.getName().equals(name) ) {
+                return sh;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public final String toString() {
+        final int armABI = getArmABI();
+        final String armFlagsS;
+        if( 0 != armABI ) {
+            armFlagsS=", arm[abi "+armABI+", lGCC "+getArmLegacyGCCFlags()+", float "+getArmFloatMode()+"]";
+        } else {
+            armFlagsS="";
+        }
+        return "ELF-2["+cpuType+", "+abiType+", flags["+toHexString(getFlags())+armFlagsS+"], sh-num "+sht.length+"]";
+    }
+
+    final SectionHeader[] readSectionHeaderTable(final RandomAccessFile in) throws IOException, IllegalArgumentException {
+        // positioning
+        {
+            final long off = raw.getE_shoff(); // absolute offset
+            if( 0 == off ) {
+                return new SectionHeader[0];
+            }
+            seek(in, off);
+        }
+        final SectionHeader[] sht;
+        final int strndx = raw.getE_shstrndx();
+        final int size = raw.getE_shentsize();
+        final int num;
+        int i;
+        if( 0 == raw.getE_shnum() ) {
+            // Read 1st table 1st and use it's sh_size
+            final byte[] buf0 = new byte[size];
+            readBytes(in, buf0, 0, size);
+            final SectionHeader sh0 = new SectionHeader(this, buf0, 0, size, 0);
+            num = (int) sh0.raw.getSh_size();
+            if( 0 >= num ) {
+                throw new IllegalArgumentException("EHdr sh_num == 0 and 1st SHdr size == 0");
+            }
+            sht = new SectionHeader[num];
+            sht[0] = sh0;
+            i=1;
+        } else {
+            num = raw.getE_shnum();
+            sht = new SectionHeader[num];
+            i=0;
+        }
+        for(; i<num; i++) {
+            final byte[] buf = new byte[size];
+            readBytes(in, buf, 0, size);
+            sht[i] = new SectionHeader(this, buf, 0, size, i);
+        }
+        if( SectionHeader.SHN_UNDEF != strndx ) {
+            // has section name string table
+            if( shortToInt(SectionHeader.SHN_LORESERVE) <= strndx ) {
+                throw new InternalError("TODO strndx: "+SectionHeader.SHN_LORESERVE+" < "+strndx);
+            }
+            final SectionHeader strShdr = sht[strndx];
+            if( SectionHeader.SHT_STRTAB != strShdr.getType() ) {
+                throw new IllegalArgumentException("Ref. string Shdr["+strndx+"] is of type "+strShdr.raw.getSh_type());
+            }
+            final Section strS = strShdr.readSection(in);
+            for(i=0; i<num; i++) {
+                sht[i].initName(strS, sht[i].raw.getSh_name());
+            }
+        }
+
+        return sht;
+    }
+}