/**
* 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 static jogamp.common.os.elf.IOUtils.toHexString;
import static jogamp.common.os.elf.IOUtils.readUInt32;
import static jogamp.common.os.elf.IOUtils.getString;
import java.util.ArrayList;
import java.util.List;
import com.jogamp.common.util.Bitstream;
/**
* ARM EABI attributes within section header {@link SectionHeader#SHT_ARM_ATTRIBUTES}.
* <p>
* References:
* <ul>
* <li>http://infocenter.arm.com/
* <ul>
* <li>ARM IHI 0044E, current through ABI release 2.09</li>
* <li>ARM IHI 0045D, current through ABI release 2.09</li>
* </ul></li>
* </ul>
* </p>
*/
public class SectionArmAttributes extends Section {
public static final byte FORMAT_VERSION_A = 0x41; // 'A';
public static enum Type {
/** No Value */
None,
/** A Sub-Section - following the 4 byte sub section total size (tag + size + content) - byte order of the ELF file */
SubSection,
/** Null Terminated Byte-String */
NTBS,
ULEB128,
}
/** ULEB128 Value for {@link Tag#ABI_VFP_args}: FP parameter/result passing conforms to AAPCS, BASE variant. */
public static final byte ABI_VFP_ARGS_IS_BASE_VARIANT = 0;
/** ULEB128 Value for {@link Tag#ABI_VFP_args}: FP parameter/result passing conforms to AAPCS, VFP variant. */
public static final byte ABI_VFP_ARGS_IS_VFP_VARIANT = 1;
/** ULEB128 Value for {@link Tag#ABI_VFP_args}: FP parameter/result passing conforms to custom toolchain. */
public static final byte ABI_VFP_ARGS_IS_CUSTOM_VARIANT = 2;
/** ULEB128 Value for {@link Tag#ABI_VFP_args}: FP parameter/result passing conforms to both , BASE and VFP variant. */
public static final byte ABI_VFP_ARGS_IS_BOTH_BASE_AND_VFP_VARIANT = 3;
/**
* Returns true if value is either {@link #ABI_VFP_ARGS_IS_VFP_VARIANT} or {@link #ABI_VFP_ARGS_IS_BOTH_BASE_AND_VFP_VARIANT}
* @param v ULEB128 Value from {@link Tag#ABI_VFP_args} attribute
*/
public static final boolean abiVFPArgsAcceptsVFPVariant(final byte v) {
return ABI_VFP_ARGS_IS_VFP_VARIANT == v || ABI_VFP_ARGS_IS_BOTH_BASE_AND_VFP_VARIANT == v;
}
public static enum Tag {
None(0, Type.None),
File(1, Type.SubSection), Section(2, Type.SubSection), Symbol(3, Type.SubSection),
CPU_raw_name( 4, Type.NTBS ),
CPU_name( 5, Type.NTBS ),
CPU_arch( 6, Type.ULEB128 ),
CPU_arch_profile( 7, Type.ULEB128 ),
ARM_ISA_use( 8, Type.ULEB128 ),
THUMB_ISA_use( 9, Type.ULEB128 ),
FP_arch( 10, Type.ULEB128 ),
WMMX_arch( 11, Type.ULEB128 ),
Advanced_SIMD_arch( 12, Type.ULEB128 ),
PCS_config( 13, Type.ULEB128 ),
ABI_PCS_R9_use ( 14, Type.ULEB128 ),
ABI_PCS_RW_data( 15, Type.ULEB128 ),
ABI_PCS_RO_data( 16, Type.ULEB128 ),
ABI_PCS_GOT_use( 17, Type.ULEB128 ),
ABI_PCS_wchar_t( 18, Type.ULEB128 ),
ABI_FP_rounding( 19, Type.ULEB128 ),
ABI_FP_denormal( 20, Type.ULEB128 ),
ABI_FP_exceptions( 21, Type.ULEB128 ),
ABI_FP_user_exceptions( 22, Type.ULEB128 ),
ABI_FP_number_model( 23, Type.ULEB128 ),
ABI_align_needed( 24, Type.ULEB128 ),
ABI_align_preserved( 25, Type.ULEB128 ),
ABI_enum_size( 26, Type.ULEB128 ),
ABI_HardFP_use( 27, Type.ULEB128 ),
ABI_VFP_args( 28, Type.ULEB128 ),
ABI_WMMX_args( 29, Type.ULEB128 ),
ABI_optimization_goals( 30, Type.ULEB128 ),
ABI_FP_optimization_goals( 31, Type.ULEB128 ),
compatibility ( 32, Type.NTBS ), /** with each byte interpreted as an ULEB128 with closing EOS */
CPU_unaligned_access( 34, Type.ULEB128 ),
FP_HP_extension( 36, Type.ULEB128 ),
ABI_FP_16bit_format( 38, Type.ULEB128 ),
MPextension_use( 42, Type.ULEB128 ),
DIV_use( 44, Type.ULEB128 ),
nodefaults( 64, Type.ULEB128 ), /* value ignored */
also_compatible_with( 65, Type.ULEB128 ),
T2EE_use( 66, Type.ULEB128 ),
conformance( 67, Type.NTBS ),
Virtualization_use( 68, Type.ULEB128 ),
undefined69( 69, Type.None ),
MPextension_use_legacy( 70, Type.ULEB128 )
;
public final int id;
public final Type type;
/** Slow O(n) transition of a native tag value to a Tag. */
public static Tag get(final int id) {
final Tag[] tags = Tag.values();
final int tag_count = tags.length;
for(int i=0; i < tag_count; i++) {
if( tags[i].id == id ) {
return tags[i];
}
}
return null;
}
Tag(final int id, final Type type){
this.id = id;
this.type = type;
}
}
public static class Attribute {
public final Tag tag;
private final Object value;
Attribute(final Tag tag, final Object value) {
this.tag = tag;
this.value = value;
}
public final boolean isNTBS() {
return Type.NTBS == tag.type;
}
public final String getNTBS() {
if( Type.NTBS == tag.type ) {
return (String) value;
}
throw new IllegalArgumentException("Not NTBS but "+tag.type);
}
public final boolean isULEB128() {
return Type.ULEB128 == tag.type;
}
public final byte getULEB128() {
if( Type.ULEB128== tag.type ) {
return ((Byte) value).byteValue();
}
throw new IllegalArgumentException("Not ULEB128 but "+tag.type);
}
@Override
public String toString() {
return tag+" = "+value;
}
}
public static class VendorAttributes {
public final String vendor;
public final List<Attribute> attributes;
VendorAttributes(final String vendor, final List<Attribute> attributes) {
this.vendor = vendor;
this.attributes = attributes;
}
@Override
public String toString() {
return vendor + attributes.toString();
}
}
public final List<VendorAttributes> vendorAttributesList;
SectionArmAttributes(final SectionHeader sh, final byte[] data, final int offset, final int length) throws IndexOutOfBoundsException, IllegalArgumentException {
super(sh, data, offset, length);
this.vendorAttributesList = parse(sh, data, offset, length);
}
@Override
public String toString() {
return "SectionArmAttributes["+super.toSubString()+", "+vendorAttributesList.toString()+"]";
}
public final Attribute get(final Tag tag) {
for(int i=0; i<vendorAttributesList.size(); i++) {
final List<Attribute> attributes = vendorAttributesList.get(i).attributes;
for(int j=0; j<attributes.size(); j++) {
final Attribute a = attributes.get(j);
if( a.tag == tag ) {
return a;
}
}
}
return null;
}
public final List<Attribute> get(final String vendor) {
return get(vendorAttributesList, vendor);
}
static final List<Attribute> get(final List<VendorAttributes> vendorAttributesList, final String vendor) {
for(int i=0; i<vendorAttributesList.size(); i++) {
final VendorAttributes vas = vendorAttributesList.get(i);
if( vas.vendor.equals(vendor) ) {
return vas.attributes;
}
}
return null;
}
/**
* @param sh TODO
* @param in byte source buffer to parse
* @param offset offset within byte source buffer to start parsing
* @param remaining remaining numbers of bytes to parse beginning w/ <code>sb_off</code>,
* which shall not exceed <code>sb.length - offset</code>.
* @throws IndexOutOfBoundsException if <code>offset + remaining > sb.length</code>.
* @throws IllegalArgumentException if section parsing failed, i.e. incompatible version or data.
*/
static List<VendorAttributes> parse(final SectionHeader sh, final byte[] in, final int offset, final int remaining) throws IndexOutOfBoundsException, IllegalArgumentException {
Bitstream.checkBounds(in, offset, remaining);
int i = offset;
if( FORMAT_VERSION_A != in[ i ] ) {
throw new IllegalArgumentException("ShArmAttr: Not version A, but: "+toHexString(in[i]));
}
i++;
final List<VendorAttributes> vendorAttributesList = new ArrayList<VendorAttributes>();
final boolean isBigEndian = sh.eh2.eh1.isBigEndian();
while(i < remaining) {
final int i_pre = i;
final int secLen = readUInt32(isBigEndian, in, i); /* total section size: 4 + string + content, i.e. offset to next section */
i+=4;
final String vendor;
{
final int[] i_post = new int[] { 0 };
vendor = getString(in, i, secLen - 4, i_post);
i = i_post[0];
}
final List<Attribute> attributes = new ArrayList<Attribute>();
while(i < secLen) {
final int[] i_post = new int[] { 0 };
parseSub(isBigEndian, in, i, secLen - i, i_post, attributes);
i = i_post[0];
}
if( i_pre + secLen != i ) {
throw new IllegalArgumentException("ShArmAttr: Section length count mismatch, expected "+(i_pre + secLen)+", has "+i);
}
final List<Attribute> mergeAttribs = get(vendorAttributesList, vendor);
if( null != mergeAttribs ) {
mergeAttribs.addAll(attributes);
} else {
vendorAttributesList.add(new VendorAttributes(vendor, attributes));
}
}
return vendorAttributesList;
}
/**
* @param isBigEndian TODO
* @param in byte source buffer to parse
* @param offset offset within byte source buffer to start parsing
* @param remaining remaining numbers of bytes to parse beginning w/ <code>sb_off</code>,
* which shall not exceed <code>sb.length - offset</code>.
* @throws IndexOutOfBoundsException if <code>offset + remaining > sb.length</code>.
* @throws IllegalArgumentException if section parsing failed, i.e. incompatible version or data.
*/
private static void parseSub(final boolean isBigEndian, final byte[] in, final int offset, final int remaining,
final int[] offset_post, final List<Attribute> attributes)
throws IndexOutOfBoundsException, IllegalArgumentException
{
Bitstream.checkBounds(in, offset, remaining);
// Starts w/ sub-section Tag
int i = offset;
final int i_sTag = in[i++];
final Tag sTag = Tag.get(i_sTag);
if( null == sTag ) {
throw new IllegalArgumentException("ShArmAttr: Invalid Sub-Section tag (NaT): "+i_sTag);
}
final int subSecLen; // sub section total size (tag + size + content)
switch(sTag) {
case File:
case Section:
case Symbol:
subSecLen = readUInt32(isBigEndian, in, i);
i+=4;
break;
default:
throw new IllegalArgumentException("ShArmAttr: Invalid Sub-Section tag: "+sTag);
}
if( Tag.File == sTag ) {
while( i < offset + subSecLen ) {
final int i_tag = in[i++];
final Tag tag = Tag.get(i_tag);
if( null == tag ) {
throw new IllegalArgumentException("ShArmAttr: Invalid Attribute tag (NaT): "+i_tag);
}
switch(tag.type) {
case NTBS:
{
final int[] i_post = new int[] { 0 };
final String value = getString(in, i, subSecLen + offset - i, i_post);
attributes.add(new Attribute(tag, value));
i = i_post[0];
}
break;
case ULEB128:
{
final byte value = in[i++];
attributes.add(new Attribute(tag, new Byte(value)));
}
break;
default:
throw new IllegalArgumentException("ShArmAttr: Invalid Attribute tag: "+tag);
}
}
}
offset_post[0] = offset + subSecLen;
}
}