metasm 1.0.0

data/lib/metasm/exe_format/dol.rb

@@ -0,0 +1,145 @@
+#    This file is part of Metasm, the Ruby assembly manipulation suite
+#    Copyright (C) 2006-2009 Yoann GUILLOT
+#
+#    Licence is LGPL, see LICENCE in the top-level directory
+
+require 'metasm/exe_format/main'
+require 'metasm/encode'
+require 'metasm/decode'
+
+module Metasm
+class Dol < ExeFormat
+	attr_accessor :header, :text, :data
+
+	class Header < SerialStruct
+		7.times  { |i| word "foff_text#{i}".to_sym }
+		11.times { |i| word "foff_data#{i}".to_sym }
+		7.times  { |i| word "addr_text#{i}".to_sym }
+		11.times { |i| word "addr_data#{i}".to_sym }
+		7.times  { |i| word "size_text#{i}".to_sym }
+		11.times { |i| word "size_data#{i}".to_sym }
+		word :addr_bss
+		word :size_bss
+		word :entrypoint
+		mem :pad, 0x100-0xe4
+	end
+
+	def decode_word(edata = @encoded) edata.decode_imm(:u32, @endianness) end
+	def encode_word(w) Expression[w].encode(:u32, @endianness) end
+
+	def initialize(cpu = nil)
+		@endianness = :big
+		@header = Header.new
+		@text = []
+		@data = []
+		super(cpu)
+	end
+
+	def decode_header
+		@encoded.ptr = 0
+		@header.decode(self)
+	end
+
+	def decode
+		decode_header
+
+		7.times { |i|
+			off = @header.send("foff_text#{i}")
+			sz  = @header.send("size_text#{i}")
+			@text << @encoded[off, sz]
+		}
+		11.times { |i|
+			off = @header.send("foff_data#{i}")
+			sz  = @header.send("size_data#{i}")
+			@data << @encoded[off, sz]
+		}
+	end
+
+	def encode(ignored=nil)
+		binding = {}
+		addr = 0	# XXX
+		@encoded = EncodedData.new
+		@text.each_with_index { |s, i|
+			next if not s
+			@header.send("foff_text#{i}=", new_label("foff_text#{i}"))
+			@header.send("size_text#{i}=", new_label("size_text#{i}"))
+			@header.send("addr_text#{i}=", new_label("addr_text#{i}")) if not @header.send("addr_text#{i}")
+		}
+		@data.each_with_index { |s, i|
+			next if not s
+			@header.send("foff_data#{i}=", new_label("foff_data#{i}"))
+			@header.send("size_data#{i}=", new_label("size_data#{i}"))
+			@header.send("addr_data#{i}=", new_label("addr_data#{i}")) if not @header.send("addr_data#{i}")
+		}
+		@encoded << @header.encode(self)
+
+		@text.each_with_index { |s, i|
+			next if not s
+			binding[@header.send("foff_text#{i}")] = @encoded.length
+			binding[@header.send("size_text#{i}")] = s.length
+			binding[@header.send("addr_text#{i}")] = addr if @header.send("addr_text#{i}").kind_of? String
+			binding.update s.binding(addr)
+			@encoded << s
+			addr += s.length
+		}
+		@data.each_with_index { |s, i|
+			next if not s
+			binding[@header.send("foff_data#{i}")] = @encoded.length
+			binding[@header.send("size_data#{i}")] = s.length
+			binding[@header.send("addr_data#{i}")] = addr if @header.send("addr_data#{i}").kind_of? String
+			binding.update s.binding(addr)
+			@encoded << s
+			addr += s.length
+		}
+		@encoded.fixup! binding
+		@encoded.data
+	end
+
+	def parse_init
+		@textsrc ||= []
+		@datasrc ||= []
+		@cursource ||= @textsrc
+		super()
+	end
+
+	def parse_parser_instruction(instr)
+		case instr.raw.downcase
+		when '.text'; @cursource = @textsrc
+		when '.data'; @cursource = @datasrc
+		when '.entrypoint'
+			# ".entrypoint <somelabel/expression>" or ".entrypoint" (here)
+			@lexer.skip_space
+			if tok = @lexer.nexttok and tok.type == :string
+				raise instr if not entrypoint = Expression.parse(@lexer)
+			else
+				entrypoint = new_label('entrypoint')
+				@cursource << Label.new(entrypoint, instr.backtrace.dup)
+			end
+			@header.entrypoint = entrypoint
+		else super(instr)
+		end
+	end
+
+	def assemble(*a)
+		parse(*a) if not a.empty?
+		@text[0] ||= EncodedData.new
+		@text[0] << assemble_sequence(@textsrc, @cpu)
+		@textsrc.clear
+		@data[0] ||= EncodedData.new
+		@data[0] << assemble_sequence(@datasrc, @cpu)
+		@datasrc.clear
+		self
+	end
+
+	def each_section
+		7.times { |i|
+			next if not @text[i]
+			yield @text[i], instance_variable_get("addr_text#{i}")
+		}
+		11.times { |i|
+			next if not @data[i]
+			yield @data[i], instance_variable_get("addr_data#{i}")
+		}
+	end
+end
+end

data/lib/metasm/exe_format/elf.rb

@@ -0,0 +1,923 @@
+#    This file is part of Metasm, the Ruby assembly manipulation suite
+#    Copyright (C) 2006-2009 Yoann GUILLOT
+#
+#    Licence is LGPL, see LICENCE in the top-level directory
+
+
+require 'metasm/exe_format/main'
+
+module Metasm
+class ELF < ExeFormat
+	MAGIC = "\x7fELF"	# 0x7f454c46
+	CLASS = { 0 => 'NONE', 1 => '32', 2 => '64', 200 => '64_icc' }
+	DATA  = { 0 => 'NONE', 1 => 'LSB', 2 => 'MSB' }
+	VERSION = { 0 => 'INVALID', 1 => 'CURRENT' }
+	ABI = { 0 => 'SYSV', 1 => 'HPUX', 2 => 'NETBSD', 3 => 'LINUX',
+		6 => 'SOLARIS', 7 => 'AIX', 8 => 'IRIX', 9 => 'FREEBSD',
+		10 => 'TRU64', 11 => 'MODESTO', 12 => 'OPENBSD', 97 => 'ARM',
+		255 => 'STANDALONE'}
+	TYPE = { 0 => 'NONE', 1 => 'REL', 2 => 'EXEC', 3 => 'DYN', 4 => 'CORE' }
+	TYPE_LOPROC = 0xff00
+	TYPE_HIPROC = 0xffff
+
+	MACHINE = {
+		 0 => 'NONE',   1 => 'M32',     2 => 'SPARC',   3 => '386',
+		 4 => '68K',    5 => '88K',     6 => '486',     7 => '860',
+		 8 => 'MIPS',   9 => 'S370',   10 => 'MIPS_RS3_LE',
+		15 => 'PARISC',
+		17 => 'VPP500',18 => 'SPARC32PLUS', 19 => '960',
+		20 => 'PPC',   21 => 'PPC64',  22 => 'S390',
+		36 => 'V800',  37 => 'FR20',   38 => 'RH32',   39 => 'MCORE',
+		40 => 'ARM',   41 => 'ALPHA_STD', 42 => 'SH', 43 => 'SPARCV9',
+		44 => 'TRICORE', 45 => 'ARC',  46 => 'H8_300', 47 => 'H8_300H',
+		48 => 'H8S',   49 => 'H8_500', 50 => 'IA_64',  51 => 'MIPS_X',
+		52 => 'COLDFIRE', 53 => '68HC12', 54 => 'MMA', 55 => 'PCP',
+		56 => 'NCPU',  57 => 'NDR1',   58 => 'STARCORE', 59 => 'ME16',
+		60 => 'ST100', 61 => 'TINYJ',  62 => 'X86_64', 63 => 'PDSP',
+		66 => 'FX66',  67 => 'ST9PLUS',
+		68 => 'ST7',   69 => '68HC16', 70 => '68HC11', 71 => '68HC08',
+		72 => '68HC05',73 => 'SVX',    74 => 'ST19',   75 => 'VAX',
+		76 => 'CRIS',  77 => 'JAVELIN',78 => 'FIREPATH', 79 => 'ZSP',
+		80 => 'MMIX',  81 => 'HUANY',  82 => 'PRISM',  83 => 'AVR',
+		84 => 'FR30',  85 => 'D10V',   86 => 'D30V',   87 => 'V850',
+		88 => 'M32R',  89 => 'MN10300',90 => 'MN10200',91 => 'PJ',
+		92 => 'OPENRISC', 93 => 'ARC_A5', 94 => 'XTENSA',
+		99 => 'PJ',
+		0x9026 => 'ALPHA'
+	}
+
+	FLAGS = {
+		'SPARC' => {0x100 => '32PLUS', 0x200 => 'SUN_US1',
+			0x400 => 'HAL_R1', 0x800 => 'SUN_US3',
+			0x8000_0000 => 'LEDATA'},
+		'SPARCV9' => {0 => 'TSO', 1 => 'PSO', 2 => 'RMO'},	# XXX not a flag
+		'MIPS' => {1 => 'NOREORDER', 2 => 'PIC', 4 => 'CPIC',
+			8 => 'XGOT', 16 => '64BIT_WHIRL', 32 => 'ABI2',
+			64 => 'ABI_ON32'}
+	}
+
+	DYNAMIC_TAG = { 0 => 'NULL', 1 => 'NEEDED', 2 => 'PLTRELSZ', 3 =>
+		'PLTGOT', 4 => 'HASH', 5 => 'STRTAB', 6 => 'SYMTAB', 7 => 'RELA',
+		8 => 'RELASZ', 9 => 'RELAENT', 10 => 'STRSZ', 11 => 'SYMENT',
+		12 => 'INIT', 13 => 'FINI', 14 => 'SONAME', 15 => 'RPATH',
+		16 => 'SYMBOLIC', 17 => 'REL', 18 => 'RELSZ', 19 => 'RELENT',
+		20 => 'PLTREL', 21 => 'DEBUG', 22 => 'TEXTREL', 23 => 'JMPREL',
+		24 => 'BIND_NOW',
+		25 => 'INIT_ARRAY', 26 => 'FINI_ARRAY',
+		27 => 'INIT_ARRAYSZ', 28 => 'FINI_ARRAYSZ',
+		29 => 'RUNPATH', 30 => 'FLAGS', 31 => 'ENCODING',
+		32 => 'PREINIT_ARRAY', 33 => 'PREINIT_ARRAYSZ',
+		0x6fff_fdf5 => 'GNU_PRELINKED',
+		0x6fff_fdf6 => 'GNU_CONFLICTSZ', 0x6fff_fdf7 => 'LIBLISTSZ',
+		0x6fff_fdf8 => 'CHECKSUM',       0x6fff_fdf9 => 'PLTPADSZ',
+		0x6fff_fdfa => 'MOVEENT',        0x6fff_fdfb => 'MOVESZ',
+		0x6fff_fdfc => 'FEATURE_1',      0x6fff_fdfd => 'POSFLAG_1',
+		0x6fff_fdfe => 'SYMINSZ',        0x6fff_fdff => 'SYMINENT',
+		0x6fff_fef5 => 'GNU_HASH',
+		0x6fff_fef6 => 'TLSDESC_PLT',    0x6fff_fef7 => 'TLSDESC_GOT',
+		0x6fff_fef8 => 'GNU_CONFLICT',   0x6fff_fef9 => 'GNU_LIBLIST',
+		0x6fff_fefa => 'CONFIG',         0x6fff_fefb => 'DEPAUDIT',
+		0x6fff_fefc => 'AUDIT',          0x6fff_fefd => 'PLTPAD',
+		0x6fff_fefe => 'MOVETAB',        0x6fff_feff => 'SYMINFO',
+		0x6fff_fff0 => 'VERSYM',         0x6fff_fff9 => 'RELACOUNT',
+		0x6fff_fffa => 'RELCOUNT',       0x6fff_fffb => 'FLAGS_1',
+		0x6fff_fffc => 'VERDEF',         0x6fff_fffd => 'VERDEFNUM',
+		0x6fff_fffe => 'VERNEED',        0x6fff_ffff => 'VERNEEDNUM'
+	}
+	DYNAMIC_TAG_LOPROC = 0x7000_0000
+	DYNAMIC_TAG_HIPROC = 0x7fff_ffff
+
+	# for tags between DT_LOPROC and DT_HIPROC, use DT_PROC[header.machine][tag-DT_LOPROC]
+	DYNAMIC_TAG_PROC = {
+		'MIPS' => {
+			1 => 'RLD_VERSION', 2 => 'TIME_STAMP', 3 => 'ICHECKSUM',
+			4 => 'IVERSION', 5 => 'M_FLAGS', 6 => 'BASE_ADDRESS', 7 => 'MSYM',
+			8 => 'CONFLICT', 9 => 'LIBLIST', 0x0a => 'LOCAL_GOTNO',
+			0x0b => 'CONFLICTNO', 0x10 => 'LIBLISTNO', 0x11 => 'SYMTABNO',
+			0x12 => 'UNREFEXTNO', 0x13 => 'GOTSYM', 0x14 => 'HIPAGENO',
+			0x16 => 'RLD_MAP', 0x17 => 'DELTA_CLASS', 0x18 => 'DELTA_CLASS_NO',
+			0x19 => 'DELTA_INSTANCE', 0x1a => 'DELTA_INSTANCE_NO',
+			0x1b => 'DELTA_RELOC', 0x1c => 'DELTA_RELOC_NO', 0x1d => 'DELTA_SYM',
+			0x1e => 'DELTA_SYM_NO', 0x20 => 'DELTA_CLASSSYM', 0x21 => 'DELTA_CLASSSYM_NO',
+			0x22 => 'CXX_FLAGS', 0x23 => 'PIXIE_INIT', 0x24 => 'SYMBOL_LIB',
+			0x25 => 'LOCALPAGE_GOTIDX', 0x26 => 'LOCAL_GOTIDX',
+			0x27 => 'HIDDEN_GOTIDX', 0x28 => 'PROTECTED_GOTIDX',
+			0x29 => 'OPTIONS', 0x2a => 'INTERFACE', 0x2b => 'DYNSTR_ALIGN',
+			0x2c => 'INTERFACE_SIZE', 0x2d => 'RLD_TEXT_RESOLVE_ADDR',
+			0x2e => 'PERF_SUFFIX', 0x2f => 'COMPACT_SIZE',
+			0x30 => 'GP_VALUE', 0x31 => 'AUX_DYNAMIC',
+		}
+	}
+
+
+	DYNAMIC_FLAGS = { 1 => 'ORIGIN', 2 => 'SYMBOLIC', 4 => 'TEXTREL',
+		8 => 'BIND_NOW', 0x10 => 'STATIC_TLS' }
+	DYNAMIC_FLAGS_1 = { 1 => 'NOW', 2 => 'GLOBAL', 4 => 'GROUP',
+		8 => 'NODELETE', 0x10 => 'LOADFLTR', 0x20 => 'INITFIRST',
+		0x40 => 'NOOPEN', 0x80 => 'ORIGIN', 0x100 => 'DIRECT',
+		0x200 => 'TRANS', 0x400 => 'INTERPOSE', 0x800 => 'NODEFLIB',
+		0x1000 => 'NODUMP', 0x2000 => 'CONFALT', 0x4000 => 'ENDFILTEE',
+		0x8000 => 'DISPRELDNE', 0x10000 => 'DISPRELPND' }
+	DYNAMIC_FEATURE_1 = { 1 => 'PARINIT', 2 => 'CONFEXP' }
+	DYNAMIC_POSFLAG_1 = { 1 => 'LAZYLOAD', 2 => 'GROUPPERM' }
+
+	PH_TYPE = { 0 => 'NULL', 1 => 'LOAD', 2 => 'DYNAMIC', 3 => 'INTERP',
+		4 => 'NOTE', 5 => 'SHLIB', 6 => 'PHDR', 7 => 'TLS',
+		0x6474e550 => 'GNU_EH_FRAME', 0x6474e551 => 'GNU_STACK',
+		0x6474e552 => 'GNU_RELRO' }
+	PH_TYPE_LOPROC = 0x7000_0000
+	PH_TYPE_HIPROC = 0x7fff_ffff
+	PH_FLAGS = { 1 => 'X', 2 => 'W', 4 => 'R' }
+
+	SH_TYPE = { 0 => 'NULL', 1 => 'PROGBITS', 2 => 'SYMTAB', 3 => 'STRTAB',
+		4 => 'RELA', 5 => 'HASH', 6 => 'DYNAMIC', 7 => 'NOTE',
+		8 => 'NOBITS', 9 => 'REL', 10 => 'SHLIB', 11 => 'DYNSYM',
+		14 => 'INIT_ARRAY', 15 => 'FINI_ARRAY', 16 => 'PREINIT_ARRAY',
+		17 => 'GROUP', 18 => 'SYMTAB_SHNDX',
+		0x6fff_fff6 => 'GNU_HASH', 0x6fff_fff7 => 'GNU_LIBLIST',
+		0x6fff_fff8 => 'GNU_CHECKSUM',
+		0x6fff_fffd => 'GNU_verdef', 0x6fff_fffe => 'GNU_verneed',
+		0x6fff_ffff => 'GNU_versym' }
+	SH_TYPE_LOOS   = 0x6000_0000
+	SH_TYPE_HIOS   = 0x6fff_ffff
+	SH_TYPE_LOPROC = 0x7000_0000
+	SH_TYPE_HIPROC = 0x7fff_ffff
+	SH_TYPE_LOUSER = 0x8000_0000
+	SH_TYPE_HIUSER = 0xffff_ffff
+
+	SH_FLAGS = { 1 => 'WRITE', 2 => 'ALLOC', 4 => 'EXECINSTR',
+		0x10 => 'MERGE', 0x20 => 'STRINGS', 0x40 => 'INFO_LINK',
+		0x80 => 'LINK_ORDER', 0x100 => 'OS_NONCONFORMING',
+		0x200 => 'GROUP', 0x400 => 'TLS' }
+	SH_FLAGS_MASKPROC = 0xf000_0000
+
+	SH_INDEX = { 0 => 'UNDEF',
+		0xfff1 => 'ABS', 0xfff2 => 'COMMON',
+		0xffff => 'XINDEX', }
+	SH_INDEX_LORESERVE = 0xff00
+	SH_INDEX_LOPROC    = 0xff00
+	SH_INDEX_HIPROC    = 0xff1f
+	SH_INDEX_LOOS      = 0xff20
+	SH_INDEX_HIOS      = 0xff3f
+	SH_INDEX_HIRESERVE = 0xffff
+
+	SYMBOL_BIND = { 0 => 'LOCAL', 1 => 'GLOBAL', 2 => 'WEAK' }
+	SYMBOL_BIND_LOPROC = 13
+	SYMBOL_BIND_HIPROC = 15
+
+	SYMBOL_TYPE = { 0 => 'NOTYPE', 1 => 'OBJECT', 2 => 'FUNC',
+		3 => 'SECTION', 4 => 'FILE', 5 => 'COMMON', 6 => 'TLS' }
+	SYMBOL_TYPE_LOPROC = 13
+	SYMBOL_TYPE_HIPROC = 15
+
+	SYMBOL_VISIBILITY = { 0 => 'DEFAULT', 1 => 'INTERNAL', 2 => 'HIDDEN', 3 => 'PROTECTED' }
+
+	RELOCATION_TYPE = {	# key are in MACHINE.values
+		'386' => { 0 => 'NONE', 1 => '32', 2 => 'PC32', 3 => 'GOT32',
+			4 => 'PLT32', 5 => 'COPY', 6 => 'GLOB_DAT',
+			7 => 'JMP_SLOT', 8 => 'RELATIVE', 9 => 'GOTOFF',
+			10 => 'GOTPC', 11 => '32PLT', 12 => 'TLS_GD_PLT',
+			13 => 'TLS_LDM_PLT', 14 => 'TLS_TPOFF', 15 => 'TLS_IE',
+			16 => 'TLS_GOTIE', 17 => 'TLS_LE', 18 => 'TLS_GD',
+			19 => 'TLS_LDM', 20 => '16', 21 => 'PC16', 22 => '8',
+			23 => 'PC8', 24 => 'TLS_GD_32', 25 => 'TLS_GD_PUSH',
+			26 => 'TLS_GD_CALL', 27 => 'TLS_GD_POP',
+			28 => 'TLS_LDM_32', 29 => 'TLS_LDM_PUSH',
+			30 => 'TLS_LDM_CALL', 31 => 'TLS_LDM_POP',
+			32 => 'TLS_LDO_32', 33 => 'TLS_IE_32',
+			34 => 'TLS_LE_32', 35 => 'TLS_DTPMOD32',
+			36 => 'TLS_DTPOFF32', 37 => 'TLS_TPOFF32' },
+		'ARM' => { 0 => 'NONE', 1 => 'PC24', 2 => 'ABS32', 3 => 'REL32',
+			4 => 'PC13', 5 => 'ABS16', 6 => 'ABS12',
+			7 => 'THM_ABS5', 8 => 'ABS8', 9 => 'SBREL32',
+			10 => 'THM_PC22', 11 => 'THM_PC8', 12 => 'AMP_VCALL9',
+			13 => 'SWI24', 14 => 'THM_SWI8', 15 => 'XPC25',
+			16 => 'THM_XPC22', 20 => 'COPY', 21 => 'GLOB_DAT',
+			22 => 'JUMP_SLOT', 23 => 'RELATIVE', 24 => 'GOTOFF',
+			25 => 'GOTPC', 26 => 'GOT32', 27 => 'PLT32',
+			100 => 'GNU_VTENTRY', 101 => 'GNU_VTINHERIT',
+			250 => 'RSBREL32', 251 => 'THM_RPC22', 252 => 'RREL32',
+			253 => 'RABS32', 254 => 'RPC24', 255 => 'RBASE' },
+		'IA_64' => { 0 => 'NONE',
+			0x21 => 'IMM14', 0x22 => 'IMM22', 0x23 => 'IMM64',
+			0x24 => 'DIR32MSB', 0x25 => 'DIR32LSB',
+			0x26 => 'DIR64MSB', 0x27 => 'DIR64LSB',
+			0x2a => 'GPREL22', 0x2b => 'GPREL64I',
+			0x2c => 'GPREL32MSB', 0x2d => 'GPREL32LSB',
+			0x2e => 'GPREL64MSB', 0x2f => 'GPREL64LSB',
+			0x32 => 'LTOFF22', 0x33 => 'LTOFF64I',
+			0x3a => 'PLTOFF22', 0x3b => 'PLTOFF64I',
+			0x3e => 'PLTOFF64MSB', 0x3f => 'PLTOFF64LSB',
+			0x43 => 'FPTR64I', 0x44 => 'FPTR32MSB',
+			0x45 => 'FPTR32LSB', 0x46 => 'FPTR64MSB',
+			0x47 => 'FPTR64LSB',
+			0x48 => 'PCREL60B', 0x49 => 'PCREL21B',
+			0x4a => 'PCREL21M', 0x4b => 'PCREL21F',
+			0x4c => 'PCREL32MSB', 0x4d => 'PCREL32LSB',
+			0x4e => 'PCREL64MSB', 0x4f => 'PCREL64LSB',
+			0x52 => 'LTOFF_FPTR22', 0x53 => 'LTOFF_FPTR64I',
+			0x54 => 'LTOFF_FPTR32MSB', 0x55 => 'LTOFF_FPTR32LSB',
+			0x56 => 'LTOFF_FPTR64MSB', 0x57 => 'LTOFF_FPTR64LSB',
+			0x5c => 'SEGREL32MSB', 0x5d => 'SEGREL32LSB',
+			0x5e => 'SEGREL64MSB', 0x5f => 'SEGREL64LSB',
+			0x64 => 'SECREL32MSB', 0x65 => 'SECREL32LSB',
+			0x66 => 'SECREL64MSB', 0x67 => 'SECREL64LSB',
+			0x6c => 'REL32MSB', 0x6d => 'REL32LSB',
+			0x6e => 'REL64MSB', 0x6f => 'REL64LSB',
+			0x74 => 'LTV32MSB', 0x75 => 'LTV32LSB',
+			0x76 => 'LTV64MSB', 0x77 => 'LTV64LSB',
+			0x79 => 'PCREL21BI', 0x7a => 'PCREL22',
+			0x7b => 'PCREL64I', 0x80 => 'IPLTMSB',
+			0x81 => 'IPLTLSB', 0x85 => 'SUB',
+			0x86 => 'LTOFF22X', 0x87 => 'LDXMOV',
+			0x91 => 'TPREL14', 0x92 => 'TPREL22',
+			0x93 => 'TPREL64I', 0x96 => 'TPREL64MSB',
+			0x97 => 'TPREL64LSB', 0x9a => 'LTOFF_TPREL22',
+			0xa6 => 'DTPMOD64MSB', 0xa7 => 'DTPMOD64LSB',
+			0xaa => 'LTOFF_DTPMOD22', 0xb1 => 'DTPREL14',
+			0xb2 => 'DTPREL22', 0xb3 => 'DTPREL64I',
+			0xb4 => 'DTPREL32MSB', 0xb5 => 'DTPREL32LSB',
+			0xb6 => 'DTPREL64MSB', 0xb7 => 'DTPREL64LSB',
+			0xba => 'LTOFF_DTPREL22' },
+		'M32' => { 0 => 'NONE', 1 => '32', 2 => '32_S', 3 => 'PC32_S',
+			4 => 'GOT32_S', 5 => 'PLT32_S', 6 => 'COPY',
+			7 => 'GLOB_DAT', 8 => 'JMP_SLOT', 9 => 'RELATIVE',
+			10 => 'RELATIVE_S' },
+		'MIPS' => {
+			0 => 'NONE', 1 => '16', 2 => '32', 3 => 'REL32',
+			4 => '26', 5 => 'HI16', 6 => 'LO16', 7 => 'GPREL16',
+			8 => 'LITERAL', 9 => 'GOT16', 10 => 'PC16',
+			11 => 'CALL16', 12 => 'GPREL32',
+			16 => 'SHIFT5', 17 => 'SHIFT6', 18 => '64',
+			19 => 'GOT_DISP', 20 => 'GOT_PAGE', 21 => 'GOT_OFST',
+			22 => 'GOT_HI16', 23 => 'GOT_LO16', 24 => 'SUB',
+			25 => 'INSERT_A', 26 => 'INSERT_B', 27 => 'DELETE',
+			28 => 'HIGHER', 29 => 'HIGHEST', 30 => 'CALL_HI16',
+			31 => 'CALL_LO16', 32 => 'SCN_DISP', 33 => 'REL16',
+			34 => 'ADD_IMMEDIATE', 35 => 'PJUMP', 36 => 'RELGOT',
+			37 => 'JALR', 38 => 'TLS_DTPMOD32', 39 => 'TLS_DTPREL32',
+			40 => 'TLS_DTPMOD64', 41 => 'TLS_DTPREL64',
+			42 => 'TLS_GD', 43 => 'TLS_LDM', 44 => 'TLS_DTPREL_HI16',
+			45 => 'TLS_DTPREL_LO16', 46 => 'TLS_GOTTPREL',
+			47 => 'TLS_TPREL32', 48 => 'TLS_TPREL64',
+			49 => 'TLS_TPREL_HI16', 50 => 'TLS_TPREL_LO16',
+			51 => 'GLOB_DAT', 52 => 'NUM' },
+		'PPC' => { 0 => 'NONE',
+			1 => 'ADDR32', 2 => 'ADDR24', 3 => 'ADDR16',
+			4 => 'ADDR16_LO', 5 => 'ADDR16_HI', 6 => 'ADDR16_HA',
+			7 => 'ADDR14', 8 => 'ADDR14_BRTAKEN', 9 => 'ADDR14_BRNTAKEN',
+			10 => 'REL24', 11 => 'REL14',
+			12 => 'REL14_BRTAKEN', 13 => 'REL14_BRNTAKEN',
+			14 => 'GOT16', 15 => 'GOT16_LO',
+			16 => 'GOT16_HI', 17 => 'GOT16_HA',
+			18 => 'PLTREL24', 19 => 'COPY',
+			20 => 'GLOB_DAT', 21 => 'JMP_SLOT',
+			22 => 'RELATIVE', 23 => 'LOCAL24PC',
+			24 => 'UADDR32', 25 => 'UADDR16',
+			26 => 'REL32', 27 => 'PLT32',
+			28 => 'PLTREL32', 29 => 'PLT16_LO',
+			30 => 'PLT16_HI', 31 => 'PLT16_HA',
+			32 => 'SDAREL16', 33 => 'SECTOFF',
+			34 => 'SECTOFF_LO', 35 => 'SECTOFF_HI',
+			36 => 'SECTOFF_HA', 67 => 'TLS',
+			68 => 'DTPMOD32', 69 => 'TPREL16',
+			70 => 'TPREL16_LO', 71 => 'TPREL16_HI',
+			72 => 'TPREL16_HA', 73 => 'TPREL32',
+			74 => 'DTPREL16', 75 => 'DTPREL16_LO',
+			76 => 'DTPREL16_HI', 77 => 'DTPREL16_HA',
+			78 => 'DTPREL32', 79 => 'GOT_TLSGD16',
+			80 => 'GOT_TLSGD16_LO', 81 => 'GOT_TLSGD16_HI',
+			82 => 'GOT_TLSGD16_HA', 83 => 'GOT_TLSLD16',
+			84 => 'GOT_TLSLD16_LO', 85 => 'GOT_TLSLD16_HI',
+			86 => 'GOT_TLSLD16_HA', 87 => 'GOT_TPREL16',
+			88 => 'GOT_TPREL16_LO', 89 => 'GOT_TPREL16_HI',
+			90 => 'GOT_TPREL16_HA', 101 => 'EMB_NADDR32',
+			102 => 'EMB_NADDR16', 103 => 'EMB_NADDR16_LO',
+			104 => 'EMB_NADDR16_HI', 105 => 'EMB_NADDR16_HA',
+			106 => 'EMB_SDAI16', 107 => 'EMB_SDA2I16',
+			108 => 'EMB_SDA2REL', 109 => 'EMB_SDA21',
+			110 => 'EMB_MRKREF', 111 => 'EMB_RELSEC16',
+			112 => 'EMB_RELST_LO', 113 => 'EMB_RELST_HI',
+			114 => 'EMB_RELST_HA', 115 => 'EMB_BIT_FLD',
+			116 => 'EMB_RELSDA' },
+		'SPARC' => { 0 => 'NONE', 1 => '8', 2 => '16', 3 => '32',
+			4 => 'DISP8', 5 => 'DISP16', 6 => 'DISP32',
+			7 => 'WDISP30', 8 => 'WDISP22', 9 => 'HI22',
+			10 => '22', 11 => '13', 12 => 'LO10', 13 => 'GOT10',
+			14 => 'GOT13', 15 => 'GOT22', 16 => 'PC10',
+			17 => 'PC22', 18 => 'WPLT30', 19 => 'COPY',
+			20 => 'GLOB_DAT', 21 => 'JMP_SLOT', 22 => 'RELATIVE',
+			23 => 'UA32', 24 => 'PLT32', 25 => 'HIPLT22',
+			26 => 'LOPLT10', 27 => 'PCPLT32', 28 => 'PCPLT22',
+			29 => 'PCPLT10', 30 => '10', 31 => '11', 32 => '64',
+			33 => 'OLO10', 34 => 'HH22', 35 => 'HM10', 36 => 'LM22',
+			37 => 'PC_HH22', 38 => 'PC_HM10', 39 => 'PC_LM22',
+			40 => 'WDISP16', 41 => 'WDISP19', 42 => 'GLOB_JMP',
+			43 => '7', 44 => '5', 45 => '6', 46 => 'DISP64',
+			47 => 'PLT64', 48 => 'HIX22', 49 => 'LOX10', 50 => 'H44',
+			51 => 'M44', 52 => 'L44', 53 => 'REGISTER', 54 => 'UA64',
+			55 => 'UA16', 56 => 'TLS_GD_HI22', 57 => 'TLS_GD_LO10',
+			58 => 'TLS_GD_ADD', 59 => 'TLS_GD_CALL',
+			60 => 'TLS_LDM_HI22', 61 => 'TLS_LDM_LO10',
+			62 => 'TLS_LDM_ADD', 63 => 'TLS_LDM_CALL',
+			64 => 'TLS_LDO_HIX22', 65 => 'TLS_LDO_LOX10',
+			66 => 'TLS_LDO_ADD', 67 => 'TLS_IE_HI22',
+			68 => 'TLS_IE_LO10', 69 => 'TLS_IE_LD',
+			70 => 'TLS_IE_LDX', 71 => 'TLS_IE_ADD',
+			72 => 'TLS_LE_HIX22', 73 => 'TLS_LE_LOX10',
+			74 => 'TLS_DTPMOD32', 75 => 'TLS_DTPMOD64',
+			76 => 'TLS_DTPOFF32', 77 => 'TLS_DTPOFF64',
+			78 => 'TLS_TPOFF32', 79 => 'TLS_TPOFF64' },
+		'X86_64' => { 0 => 'NONE',
+			1 => '64', 2 => 'PC32', 3 => 'GOT32', 4 => 'PLT32',
+			5 => 'COPY', 6 => 'GLOB_DAT', 7 => 'JMP_SLOT',
+			8 => 'RELATIVE', 9 => 'GOTPCREL', 10 => '32',
+			11 => '32S', 12 => '16', 13 => 'PC16', 14 => '8',
+			15 => 'PC8', 16 => 'DTPMOD64', 17 => 'DTPOFF64',
+			18 => 'TPOFF64', 19 => 'TLSGD', 20 => 'TLSLD',
+			21 => 'DTPOFF32', 22 => 'GOTTPOFF', 23 => 'TPOFF32' }
+	}
+
+	DEFAULT_INTERP = '/lib/ld-linux.so.2'
+	DEFAULT_INTERP64 = '/lib64/ld-linux-x86-64.so.2'
+
+	class SerialStruct < Metasm::SerialStruct
+		new_int_field :addr, :off, :xword, :sword, :sxword
+	end
+
+	class Header < SerialStruct
+		mem :magic, 4, MAGIC
+		byte :e_class, 0, CLASS
+		byte :data, 0, DATA
+		byte :i_version, 'CURRENT', VERSION
+		byte :abi, 0, ABI
+		byte :abi_version
+		mem :ident_unk, 7
+		half :type, 0, TYPE
+		half :machine, 0, MACHINE
+		word :version, 'CURRENT', VERSION
+		addr :entry
+		off :phoff
+		off :shoff
+		word :flags
+		fld_bits(:flags) { |elf, hdr| FLAGS[hdr.machine] || {} }
+		halfs :ehsize, :phentsize, :phnum, :shentsize, :shnum, :shstrndx
+
+		def self.size elf
+			x = elf.bitsize >> 3
+			40 + 3*x
+		end
+	end
+
+	class Segment < SerialStruct
+		attr_accessor :type, :offset, :vaddr, :paddr, :filesz, :memsz, :flags, :align
+		attr_accessor :encoded
+
+		def struct_specialized(elf)
+			return Segment32 if not elf
+			case elf.bitsize
+			when 32; Segment32
+			else Segment64
+			end
+		end
+
+		def self.size elf
+			x = elf.bitsize >> 3
+			8 + 6*x
+		end
+	end
+
+	class Segment32 < Segment
+		word :type, 0, PH_TYPE
+		off :offset
+		addr :vaddr
+		addr :paddr
+		xword :filesz
+		xword :memsz
+		word :flags ; fld_bits :flags, PH_FLAGS
+		xword :align
+	end
+	class Segment64 < Segment
+		word :type, 0, PH_TYPE
+		word :flags ; fld_bits :flags, PH_FLAGS
+		off :offset
+		addr :vaddr
+		addr :paddr
+		xword :filesz
+		xword :memsz
+		xword :align
+	end
+
+	class Section < SerialStruct
+		word :name_p
+		word :type, 0, SH_TYPE
+		xword :flags ; fld_bits :flags, SH_FLAGS
+		addr :addr
+		off :offset
+		xword :size
+		word :link
+		word :info
+		xword :addralign
+		xword :entsize
+
+		attr_accessor :name, :encoded
+
+		def self.size elf
+			x = elf.bitsize >> 3
+			16 + 6*x
+		end
+	end
+
+	class Symbol < SerialStruct
+		def struct_specialized(elf)
+			return Symbol32 if not elf
+			case elf.bitsize
+			when 32; Symbol32
+			else Symbol64
+			end
+		end
+
+		attr_accessor :name_p, :value, :size, :bind, :type, :other, :shndx
+		attr_accessor :name, :thunk
+
+		def self.size elf
+			x = elf.bitsize >> 3
+			8 + 2*x
+		end
+	end
+
+	class Symbol32 < Symbol
+		word :name_p
+		addr :value
+		xword :size
+		bitfield :byte, 0 => :type, 4 => :bind
+		fld_enum :type, SYMBOL_TYPE
+		fld_enum :bind, SYMBOL_BIND
+		byte :other
+		half :shndx, 0, SH_INDEX
+	end
+	class Symbol64 < Symbol
+		word :name_p
+		bitfield :byte, 0 => :type, 4 => :bind
+		fld_enum :type, SYMBOL_TYPE
+		fld_enum :bind, SYMBOL_BIND
+		byte :other
+		half :shndx, 0, SH_INDEX
+		addr :value
+		xword :size
+	end
+
+	class Relocation < SerialStruct
+		attr_accessor :offset, :type, :symbol
+		def struct_specialized(elf)
+			return Relocation32 if not elf
+			case elf.bitsize
+			when 32; Relocation32
+			else Relocation64
+			end
+		end
+
+		def addend ; end
+
+		def self.size elf
+			x = elf.bitsize >> 3
+			2*x
+		end
+
+	end
+	class Relocation32 < Relocation
+		addr :offset
+		bitfield :xword, 0 => :type, 8 => :symbol
+		fld_enum(:type) { |elf, rel| RELOCATION_TYPE[elf.header.machine] || {} }
+		fld_enum(:symbol) { |elf, rel| elf.symbols }
+	end
+	class Relocation64 < Relocation
+		addr :offset
+		bitfield :xword, 0 => :type, 32 => :symbol
+		fld_enum(:type) { |elf, rel| RELOCATION_TYPE[elf.header.machine] || {} }
+		fld_enum(:symbol) { |elf, rel| elf.symbols }
+	end
+	class RelocationAddend < Relocation
+		attr_accessor :addend
+		def struct_specialized(elf)
+			return RelocationAddend32 if not elf
+			case elf.bitsize
+			when 32; RelocationAddend32
+			else RelocationAddend64
+			end
+		end
+		def self.size elf
+			x = elf.bitsize >> 3
+			3*x
+		end
+
+	end
+	class RelocationAddend32 < RelocationAddend
+		addr :offset
+		bitfield :xword, 0 => :type, 8 => :symbol
+		fld_enum(:type) { |elf, rel| RELOCATION_TYPE[elf.header.machine] || {} }
+		fld_enum(:symbol) { |elf, rel| elf.symbols }
+		sxword :addend
+	end
+	class RelocationAddend64 < RelocationAddend
+		addr :offset
+		bitfield :xword, 0 => :type, 32 => :symbol
+		fld_enum(:type) { |elf, rel| RELOCATION_TYPE[elf.header.machine] || {} }
+		fld_enum(:symbol) { |elf, rel| elf.symbols }
+		sxword :addend
+	end
+
+	class SerialStruct
+		new_int_field :leb
+	end
+
+	# libdwarf/dwarf.h
+	DWARF_TAG = {
+		0x01 => 'ARRAY_TYPE', 0x02 => 'CLASS_TYPE', 0x03 => 'ENTRY_POINT',
+		0x04 => 'ENUMERATION_TYPE', 0x05 => 'FORMAL_PARAMETER',
+		0x08 => 'IMPORTED_DECLARATION', 0x0a => 'LABEL', 0x0b => 'LEXICAL_BLOCK',
+		0x0d => 'MEMBER', 0x0f => 'POINTER_TYPE',
+		0x10 => 'REFERENCE_TYPE', 0x11 => 'COMPILE_UNIT', 0x12 => 'STRING_TYPE', 0x13 => 'STRUCTURE_TYPE',
+		0x15 => 'SUBROUTINE_TYPE', 0x16 => 'TYPEDEF', 0x17 => 'UNION_TYPE',
+		0x18 => 'UNSPECIFIED_PARAMETERS', 0x19 => 'VARIANT', 0x1a => 'COMMON_BLOCK', 0x1b => 'COMMON_INCLUSION',
+		0x1c => 'INHERITANCE', 0x1d => 'INLINED_SUBROUTINE', 0x1e => 'MODULE', 0x1f => 'PTR_TO_MEMBER_TYPE',
+		0x20 => 'SET_TYPE', 0x21 => 'SUBRANGE_TYPE', 0x22 => 'WITH_STMT', 0x23 => 'ACCESS_DECLARATION',
+		0x24 => 'BASE_TYPE', 0x25 => 'CATCH_BLOCK', 0x26 => 'CONST_TYPE', 0x27 => 'CONSTANT',
+		0x28 => 'ENUMERATOR', 0x29 => 'FILE_TYPE', 0x2a => 'FRIEND', 0x2b => 'NAMELIST',
+		0x2c => 'NAMELIST_ITEM', 0x2d => 'PACKED_TYPE', 0x2e => 'SUBPROGRAM', 0x2f => 'TEMPLATE_TYPE_PARAM',
+		0x30 => 'TEMPLATE_VALUE_PARAM', 0x31 => 'THROWN_TYPE', 0x32 => 'TRY_BLOCK', 0x33 => 'VARIANT_PART',
+		0x34 => 'VARIABLE', 0x35 => 'VOLATILE_TYPE',
+	}
+	DWARF_FORM = {
+		0x01 => 'ADDR', 0x03 => 'BLOCK2',
+		0x04 => 'BLOCK4', 0x05 => 'DATA2', 0x06 => 'DATA4', 0x07 => 'DATA8',
+		0x08 => 'STRING', 0x09 => 'BLOCK', 0x0a => 'BLOCK1', 0x0b => 'DATA1',
+		0x0c => 'FLAG', 0x0d => 'SDATA', 0x0e => 'STRP', 0x0f => 'UDATA',
+		0x10 => 'REF_ADDR', 0x11 => 'REF1', 0x12 => 'REF2', 0x13 => 'REF4',
+		0x14 => 'REF8', 0x15 => 'REF_UDATA', 0x16 => 'INDIRECT',
+	}
+	DWARF_AT = {
+		0x01 => 'SIBLING', 0x02 => 'LOCATION', 0x03 => 'NAME',
+		0x09 => 'ORDERING', 0x0a => 'SUBSCR_DATA', 0x0b => 'BYTE_SIZE',
+		0x0c => 'BIT_OFFSET', 0x0d => 'BIT_SIZE', 0x0f => 'ELEMENT_LIST',
+		0x10 => 'STMT_LIST', 0x11 => 'LOW_PC', 0x12 => 'HIGH_PC', 0x13 => 'LANGUAGE',
+		0x14 => 'MEMBER', 0x15 => 'DISCR', 0x16 => 'DISCR_VALUE', 0x17 => 'VISIBILITY',
+		0x18 => 'IMPORT', 0x19 => 'STRING_LENGTH', 0x1a => 'COMMON_REFERENCE', 0x1b => 'COMP_DIR',
+		0x1c => 'CONST_VALUE', 0x1d => 'CONTAINING_TYPE', 0x1e => 'DEFAULT_VALUE',
+		0x20 => 'INLINE', 0x21 => 'IS_OPTIONAL', 0x22 => 'LOWER_BOUND',
+		0x25 => 'PRODUCER', 0x27 => 'PROTOTYPED',
+		0x2a => 'RETURN_ADDR',
+		0x2c => 'START_SCOPE', 0x2e => 'STRIDE_SIZE', 0x2f => 'UPPER_BOUND',
+		0x31 => 'ABSTRACT_ORIGIN', 0x32 => 'ACCESSIBILITY', 0x33 => 'ADDRESS_CLASS',
+		0x34 => 'ARTIFICIAL', 0x35 => 'BASE_TYPES', 0x36 => 'CALLING_CONVENTION', 0x37 => 'COUNT',
+		0x38 => 'DATA_MEMBER_LOCATION', 0x39 => 'DECL_COLUMN', 0x3a => 'DECL_FILE', 0x3b => 'DECL_LINE',
+		0x3c => 'DECLARATION', 0x3d => 'DISCR_LIST', 0x3e => 'ENCODING', 0x3f => 'EXTERNAL',
+		0x40 => 'FRAME_BASE', 0x41 => 'FRIEND', 0x42 => 'IDENTIFIER_CASE', 0x43 => 'MACRO_INFO',
+		0x44 => 'NAMELIST_ITEM', 0x45 => 'PRIORITY', 0x46 => 'SEGMENT', 0x47 => 'SPECIFICATION',
+		0x48 => 'STATIC_LINK', 0x49 => 'TYPE', 0x4a => 'USE_LOCATION', 0x4b => 'VARIABLE_PARAMETER',
+		0x4c => 'VIRTUALITY', 0x4d => 'VTABLE_ELEM_LOCATION',
+	}
+
+	class DwarfDebug < SerialStruct
+		class Node < SerialStruct
+			leb :index
+			leb :tag, 0, DWARF_TAG
+			byte :has_child
+			attr_accessor :parent, :children, :attributes
+			class Attribute < SerialStruct
+				leb :attr, 0, DWARF_AT
+				leb :form, 0, DWARF_FORM
+				attr_accessor :data
+				def to_s(a); "#{@attr}=(#@form)#{dump(@data, a)}" end
+			end
+		end
+
+		word :cu_len
+		half :version, 2
+		word :abbrev_off
+		byte :ptr_sz
+		attr_accessor :tree	# ary of root siblings (Node)
+	end
+
+	def self.hash_symbol_name(name)
+		name.unpack('C*').inject(0) { |hash, char|
+			break hash if char == 0
+			hash <<= 4
+			hash += char
+			hash ^= (hash >> 24) & 0xf0
+			hash &= 0x0fff_ffff
+		}
+	end
+
+	def self.gnu_hash_symbol_name(name)
+		name.unpack('C*').inject(5381) { |hash, char|
+			break hash if char == 0
+			(hash*33 + char) & 0xffff_ffff
+		}
+	end
+
+	attr_accessor :header, :segments, :sections, :tag, :symbols, :relocations, :endianness, :bitsize, :debug
+	def initialize(cpu=nil)
+		@header = Header.new
+		@tag = {}
+		@symbols = [Symbol32.new]
+		 @symbols.first.shndx = 'UNDEF'
+		@relocations = []
+		@sections = [Section.new]
+		 @sections.first.type = 'NULL'
+		@segments = []
+		if cpu
+			@endianness = cpu.endianness
+			@bitsize = cpu.size
+		else
+			@endianness = :little
+			@bitsize = 32
+		end
+		super(cpu)
+	end
+
+	def shortname; 'elf'; end
+end
+
+class LoadedELF < ELF
+	attr_accessor :load_address
+	def addr_to_off(addr)
+		@load_address ||= 0
+		addr >= @load_address ? addr - @load_address : addr if addr
+	end
+end
+
+class FatELF < ExeFormat
+	MAGIC = "\xfa\x70\x0e\x1f"	# 0xfat..elf
+
+	class SerialStruct < Metasm::SerialStruct
+		new_int_field :qword
+	end
+
+	class Header < SerialStruct
+		mem :magic, 4, MAGIC
+		word :version, 1
+		byte :nfat_arch
+		byte :reserved
+
+		def decode(fe)
+			super(fe)
+			raise InvalidExeFormat, "Invalid FatELF signature #{@magic.unpack('H*').first.inspect}" if @magic != MAGIC
+		end
+
+		def set_default_values(fe)
+			@nfat_arch ||= fe.list.length
+			super(fe)
+		end
+	end
+	class FatArch < SerialStruct
+		word :machine
+		bytes :abi, :abi_version, :e_class, :data, :res1, :res2
+		qwords :offset, :size
+
+		fld_enum :machine, ELF::MACHINE
+		fld_enum :abi, ELF::ABI
+		fld_enum :e_class, ELF::CLASS
+		fld_enum :data, ELF::DATA
+
+		attr_accessor :encoded
+	end
+
+	def encode_byte(val)         Expression[val].encode(:u8,  @endianness) end
+	def encode_word(val)         Expression[val].encode(:u16, @endianness) end
+	def encode_qword(val)        Expression[val].encode(:u64, @endianness) end
+	def decode_byte(edata = @encoded)  edata.decode_imm(:u8,  @endianness) end
+	def decode_word(edata = @encoded)  edata.decode_imm(:u16, @endianness) end
+	def decode_qword(edata = @encoded) edata.decode_imm(:u64, @endianness) end
+
+	attr_accessor :header, :list
+	def initialize
+		@endianness = :little
+		@list = []
+		super()
+	end
+
+	def decode
+		@header = Header.decode(self)
+		@list = []
+		@header.nfat_arch.times { @list << FatArch.decode(self) }
+		@list.each { |e|
+			e.encoded = @encoded[e.offset, e.size] || EncodedData.new
+		}
+	end
+
+	def encode
+		@header ||= Header.new
+		@encoded = @header.encode(self)
+		@list.map! { |f|
+			if f.kind_of? ExeFormat
+				e = f
+				f = FatArch.new
+				f.encoded = e.encode_string
+				h = e.header
+				f.machine, f.abi, f.abi_version, f.e_class, f.data =
+			 	h.machine, h.abi, h.abi_version, h.e_class, h.data
+			end
+			f.offset = new_label('fat_off')
+			f.size = f.encoded.size
+			@encoded << f.encode(self)
+			f
+		}
+		bd = {}
+		@list.each { |f|
+			@encoded.align 4096
+			bd[f.offset] = @encoded.length if f.offset.kind_of? String
+			@encoded << f.encoded
+		}
+		@encoded.fixup! bd
+	end
+
+	def [](i) AutoExe.decode(@list[i].encoded) if @list[i] end
+	def <<(exe) @list << exe ; self end
+
+	def self.autoexe_load(*a)
+		fe = super(*a)
+		fe.decode
+		# TODO have a global callback or whatever to prompt the user
+		# which file he wants to load in the dasm
+		puts "FatELF: using 1st archive member" if $VERBOSE
+		fe[0]
+	end
+
+	def shortname; 'fatelf'; end
+end
+end
+
+require 'metasm/exe_format/elf_encode'
+require 'metasm/exe_format/elf_decode'
+
+# TODO symbol version info
+__END__
+/*
+ * Version structures.  There are three types of version structure:
+ *
+ *  o	A definition of the versions within the image itself.
+ *	Each version definition is assigned a unique index (starting from
+ *	VER_NDX_BGNDEF)	which is used to cross-reference symbols associated to
+ *	the version.  Each version can have one or more dependencies on other
+ *	version definitions within the image.  The version name, and any
+ *	dependency names, are specified in the version definition auxiliary
+ *	array.  Version definition entries require a version symbol index table.
+ *
+ *  o	A version requirement on a needed dependency.  Each needed entry
+ *	specifies the shared object dependency (as specified in DT_NEEDED).
+ *	One or more versions required from this dependency are specified in the
+ *	version needed auxiliary array.
+ *
+ *  o	A version symbol index table.  Each symbol indexes into this array
+ *	to determine its version index.  Index values of VER_NDX_BGNDEF or
+ *	greater indicate the version definition to which a symbol is associated.
+ *	(the size of a symbol index entry is recorded in the sh_info field).
+ */
+#ifndef	_ASM
+
+typedef struct {			/* Version Definition Structure. */
+	Elf32_Half	vd_version;	/* this structures version revision */
+	Elf32_Half	vd_flags;	/* version information */
+	Elf32_Half	vd_ndx;		/* version index */
+	Elf32_Half	vd_cnt;		/* no. of associated aux entries */
+	Elf32_Word	vd_hash;	/* version name hash value */
+	Elf32_Word	vd_aux;		/* no. of bytes from start of this */
+					/*	verdef to verdaux array */
+	Elf32_Word	vd_next;	/* no. of bytes from start of this */
+} Elf32_Verdef;				/*	verdef to next verdef entry */
+
+typedef struct {			/* Verdef Auxiliary Structure. */
+	Elf32_Word	vda_name;	/* first element defines the version */
+					/*	name. Additional entries */
+					/*	define dependency names. */
+	Elf32_Word	vda_next;	/* no. of bytes from start of this */
+} Elf32_Verdaux;			/*	verdaux to next verdaux entry */
+
+
+typedef	struct {			/* Version Requirement Structure. */
+	Elf32_Half	vn_version;	/* this structures version revision */
+	Elf32_Half	vn_cnt;		/* no. of associated aux entries */
+	Elf32_Word	vn_file;	/* name of needed dependency (file) */
+	Elf32_Word	vn_aux;		/* no. of bytes from start of this */
+					/*	verneed to vernaux array */
+	Elf32_Word	vn_next;	/* no. of bytes from start of this */
+} Elf32_Verneed;			/*	verneed to next verneed entry */
+
+typedef struct {			/* Verneed Auxiliary Structure. */
+	Elf32_Word	vna_hash;	/* version name hash value */
+	Elf32_Half	vna_flags;	/* version information */
+	Elf32_Half	vna_other;
+	Elf32_Word	vna_name;	/* version name */
+	Elf32_Word	vna_next;	/* no. of bytes from start of this */
+} Elf32_Vernaux;			/*	vernaux to next vernaux entry */
+
+typedef	Elf32_Half 	Elf32_Versym;	/* Version symbol index array */
+
+typedef struct {
+	Elf32_Half	si_boundto;	/* direct bindings - symbol bound to */
+	Elf32_Half	si_flags;	/* per symbol flags */
+} Elf32_Syminfo;
+
+
+#if (defined(_LP64) || ((__STDC__ - 0 == 0) && (!defined(_NO_LONGLONG))))
+typedef struct {
+	Elf64_Half	vd_version;	/* this structures version revision */
+	Elf64_Half	vd_flags;	/* version information */
+	Elf64_Half	vd_ndx;		/* version index */
+	Elf64_Half	vd_cnt;		/* no. of associated aux entries */
+	Elf64_Word	vd_hash;	/* version name hash value */
+	Elf64_Word	vd_aux;		/* no. of bytes from start of this */
+					/*	verdef to verdaux array */
+	Elf64_Word	vd_next;	/* no. of bytes from start of this */
+} Elf64_Verdef;				/*	verdef to next verdef entry */
+
+typedef struct {
+	Elf64_Word	vda_name;	/* first element defines the version */
+					/*	name. Additional entries */
+					/*	define dependency names. */
+	Elf64_Word	vda_next;	/* no. of bytes from start of this */
+} Elf64_Verdaux;			/*	verdaux to next verdaux entry */
+
+typedef struct {
+	Elf64_Half	vn_version;	/* this structures version revision */
+	Elf64_Half	vn_cnt;		/* no. of associated aux entries */
+	Elf64_Word	vn_file;	/* name of needed dependency (file) */
+	Elf64_Word	vn_aux;		/* no. of bytes from start of this */
+					/*	verneed to vernaux array */
+	Elf64_Word	vn_next;	/* no. of bytes from start of this */
+} Elf64_Verneed;			/*	verneed to next verneed entry */
+
+typedef struct {
+	Elf64_Word	vna_hash;	/* version name hash value */
+	Elf64_Half	vna_flags;	/* version information */
+	Elf64_Half	vna_other;
+	Elf64_Word	vna_name;	/* version name */
+	Elf64_Word	vna_next;	/* no. of bytes from start of this */
+} Elf64_Vernaux;			/*	vernaux to next vernaux entry */
+
+typedef	Elf64_Half	Elf64_Versym;
+
+typedef struct {
+	Elf64_Half	si_boundto;	/* direct bindings - symbol bound to */
+	Elf64_Half	si_flags;	/* per symbol flags */
+} Elf64_Syminfo;
+#endif	/* (defined(_LP64) || ((__STDC__ - 0 == 0) ... */
+
+#endif
+
+/*
+ * Versym symbol index values.  Values greater than VER_NDX_GLOBAL
+ * and less then VER_NDX_LORESERVE associate symbols with user
+ * specified version descriptors.
+ */
+#define	VER_NDX_LOCAL		0	/* symbol is local */
+#define	VER_NDX_GLOBAL		1	/* symbol is global and assigned to */
+					/*	the base version */
+#define	VER_NDX_LORESERVE	0xff00	/* beginning of RESERVED entries */
+#define	VER_NDX_ELIMINATE	0xff01	/* symbol is to be eliminated */
+
+/*
+ * Verdef and Verneed (via Veraux) flags values.
+ */
+#define	VER_FLG_BASE		0x1	/* version definition of file itself */
+#define	VER_FLG_WEAK		0x2	/* weak version identifier */
+
+/*
+ * Verdef version values.
+ */
+#define	VER_DEF_NONE		0	/* Ver_def version */
+#define	VER_DEF_CURRENT		1
+#define	VER_DEF_NUM		2
+
+/*
+ * Verneed version values.
+ */
+#define	VER_NEED_NONE		0	/* Ver_need version */
+#define	VER_NEED_CURRENT	1
+#define	VER_NEED_NUM		2
+
+
+/*
+ * Syminfo flag values
+ */
+#define	SYMINFO_FLG_DIRECT	0x0001	/* direct bound symbol */
+#define	SYMINFO_FLG_PASSTHRU	0x0002	/* pass-thru symbol for translator */
+#define	SYMINFO_FLG_COPY	0x0004	/* symbol is a copy-reloc */
+#define	SYMINFO_FLG_LAZYLOAD	0x0008	/* symbol bound to object to be lazy */
+					/*	loaded */
+
+/*
+ * key values for Syminfo.si_boundto
+ */
+#define	SYMINFO_BT_SELF		0xffff	/* symbol bound to self */
+#define	SYMINFO_BT_PARENT	0xfffe	/* symbol bound to parent */
+#define	SYMINFO_BT_LOWRESERVE	0xff00	/* beginning of reserved entries */
+
+/*
+ * Syminfo version values.
+ */
+#define	SYMINFO_NONE		0	/* Syminfo version */
+#define	SYMINFO_CURRENT		1
+#define	SYMINFO_NUM		2
+