metasm 1.0.0 → 1.0.5

data/{lib/metasm → metasm}/exe_format/elf_decode.rb

@@ -18,19 +18,19 @@ class ELF
 			case hdr.e_class
 			when '32'; elf.bitsize = 32
 			when '64', '64_icc'; elf.bitsize = 64
-			else raise InvalidExeFormat, "E: ELF: unsupported class #{hdr.e_class}"
+			else puts "W: ELF: unsupported class #{hdr.e_class}, assuming 32bit"; elf.bitsize = 32
 			end
 
 			case hdr.data
 			when 'LSB'; elf.endianness = :little
 			when 'MSB'; elf.endianness = :big
-			else raise InvalidExeFormat, "E: ELF: unsupported endianness #{hdr.data}"
+			else puts "W: ELF: unsupported endianness #{hdr.data}, assuming littleendian"; elf.endianness = :little
 			end
 
 			if hdr.i_version != 'CURRENT'
-				raise InvalidExeFormat, "E: ELF: unsupported ELF version #{hdr.i_version}"
+				puts ":: ELF: unsupported ELF version #{hdr.i_version}"
 			end
-	       	}
+		}
 	end
 
 	class Symbol
@@ -66,7 +66,7 @@ class ELF
 	# handles relocated LoadedELF
 	def addr_to_fileoff(addr)
 		la = module_address
-	       	la = (la == 0 ? (@load_address ||= 0) : 0)
+		la = (la == 0 ? (@load_address ||= 0) : 0)
 		addr_to_off(addr - la)
 	end
 
@@ -75,7 +75,7 @@ class ELF
 	def fileoff_to_addr(foff)
 		if s = @segments.find { |s_| s_.type == 'LOAD' and s_.offset <= foff and s_.offset + s_.filesz > foff }
 			la = module_address
-	       		la = (la == 0 ? (@load_address ||= 0) : 0)
+			la = (la == 0 ? (@load_address ||= 0) : 0)
 			s.vaddr + la + foff - s.offset
 		end
 	end
@@ -106,7 +106,7 @@ class ELF
 	def decode_header(off = 0, decode_phdr=true, decode_shdr=true)
 		@encoded.ptr = off
 		@header.decode self
-		raise InvalidExeFormat, "Invalid elf header size: #{@header.ehsize}" if Header.size(self) != @header.ehsize
+		raise InvalidExeFormat, "Invalid elf header size: #{@header.ehsize}" if Header.sizeof(self) != @header.ehsize
 		if decode_phdr and @header.phoff != 0
 			decode_program_header(@header.phoff+off)
 		end
@@ -118,7 +118,7 @@ class ELF
 	# decodes the section header
 	# section names are read from shstrndx if possible
 	def decode_section_header(off = @header.shoff)
-		raise InvalidExeFormat, "Invalid elf section header size: #{@header.shentsize}" if Section.size(self) != @header.shentsize
+		raise InvalidExeFormat, "Invalid elf section header size: #{@header.shentsize}" if Section.sizeof(self) != @header.shentsize
 		@encoded.add_export new_label('section_header'), off
 		@encoded.ptr = off
 		@sections = []
@@ -137,7 +137,7 @@ class ELF
 	# decodes the program header table
 	# marks the elf entrypoint as an export of +self.encoded+
 	def decode_program_header(off = @header.phoff)
-		raise InvalidExeFormat, "Invalid elf program header size: #{@header.phentsize}" if Segment.size(self) != @header.phentsize
+		raise InvalidExeFormat, "Invalid elf program header size: #{@header.phentsize}" if Segment.sizeof(self) != @header.phentsize
 		@encoded.add_export new_label('program_header'), off
 		@encoded.ptr = off
 		@segments = []
@@ -224,7 +224,40 @@ class ELF
 		# (gnu_hash(sym[N].name) & ~1) | (N == dynsymcount-1 || (gnu_hash(sym[N].name) % nbucket) != (gnu_hash(sym[N+1].name) % nbucket))
 		# that's the hash, with its lower bit replaced by the bool [1 if i am the last sym having my hash as hash]
 
-		return hsymcount+symndx if just_get_count
+		# we're going to decode the symbol table, and we just want to get the nr of symbols to read
+		if just_get_count
+			# index of highest hashed (exported) symbols
+			ns = hsymcount+symndx
+
+			# no way to get the number of non-exported symbols from what we have here
+			# so we'll decode all relocs and use the largest index we see..
+			rels = []
+			if @encoded.ptr = @tag['REL'] and @tag['RELENT'] == Relocation.sizeof(self)
+				p_end = @encoded.ptr + @tag['RELSZ']
+				while @encoded.ptr < p_end
+					rels << Relocation.decode(self)
+				end
+			end
+			if @encoded.ptr = @tag['RELA'] and @tag['RELAENT'] == RelocationAddend.sizeof(self)
+				p_end = @encoded.ptr + @tag['RELASZ']
+				while @encoded.ptr < p_end
+					rels << RelocationAddend.decode(self)
+				end
+			end
+			if @encoded.ptr = @tag['JMPREL'] and relcls = case @tag['PLTREL']
+					when 'REL';  Relocation
+					when 'RELA'; RelocationAddend
+					end
+				p_end = @encoded.ptr + @tag['PLTRELSZ']
+				while @encoded.ptr < p_end
+					rels << relcls.decode(self)
+				end
+			end
+			maxr = rels.map { |rel| rel.symbol }.grep(::Integer).max || -1
+
+			return [ns, maxr+1].max
+		end
+
 
 		# TODO
 	end
@@ -332,8 +365,7 @@ class ELF
 	# marks a symbol as @encoded.export (from s.value, using segments or sections)
 	def decode_symbol_export(s)
 		if s.name and s.shndx != 'UNDEF' and %w[NOTYPE OBJECT FUNC].include?(s.type)
-			if @header.type == 'REL'
-				sec = @sections[s.shndx]
+			if @header.type == 'REL' and s.shndx.kind_of?(::Integer) and sec = @sections[s.shndx]
 				o = sec.offset + s.value
 			elsif not o = addr_to_off(s.value)
 				# allow to point to end of segment
@@ -359,7 +391,7 @@ class ELF
 	def decode_segments_symbols
 		return unless @tag['STRTAB'] and @tag['STRSZ'] and @tag['SYMTAB'] and (@tag['HASH'] or @tag['GNU_HASH'])
 
-		raise "E: ELF: unsupported symbol entry size: #{@tag['SYMENT']}" if @tag['SYMENT'] != Symbol.size(self)
+		raise "E: ELF: unsupported symbol entry size: #{@tag['SYMENT']}" if @tag['SYMENT'] != Symbol.sizeof(self)
 
 		# find number of symbols
 		if @tag['HASH']
@@ -394,14 +426,16 @@ class ELF
 			@encoded.ptr = sec.offset
 			syms = []
 			raise 'Invalid symbol table' if sec.size > @encoded.length
-			(sec.size / Symbol.size(self)).times { syms << Symbol.decode(self, strtab) }
+			(sec.size / Symbol.sizeof(self)).times { syms << Symbol.decode(self, strtab) }
 			alreadysegs = true if @header.type == 'DYN' or @header.type == 'EXEC'
+			alreadysyms = @symbols.inject({}) { |h, s| h.update s.name => true } if alreadysegs
 			syms.each { |s|
 				if alreadysegs
 					# if we already decoded the symbols from the DYNAMIC segment,
 					# ignore dups and imports from this section
 					next if s.shndx == 'UNDEF'
-					next if @symbols.find { |ss| ss.name == s.name }
+					next if alreadysyms[s.name]
+					alreadysyms[s.name] = true
 				end
 				@symbols << s
 				decode_symbol_export(s)
@@ -445,7 +479,7 @@ class ELF
 	def decode_segments_relocs
 		@relocations.clear
 		if @encoded.ptr = @tag['REL']
-			raise "E: ELF: unsupported rel entry size #{@tag['RELENT']}" if @tag['RELENT'] != Relocation.size(self)
+			raise "E: ELF: unsupported rel entry size #{@tag['RELENT']}" if @tag['RELENT'] != Relocation.sizeof(self)
 			p_end = @encoded.ptr + @tag['RELSZ']
 			while @encoded.ptr < p_end
 				@relocations << Relocation.decode(self)
@@ -453,7 +487,7 @@ class ELF
 		end
 
 		if @encoded.ptr = @tag['RELA']
-			raise "E: ELF: unsupported rela entry size #{@tag['RELAENT'].inspect}" if @tag['RELAENT'] != RelocationAddend.size(self)
+			raise "E: ELF: unsupported rela entry size #{@tag['RELAENT'].inspect}" if @tag['RELAENT'] != RelocationAddend.sizeof(self)
 			p_end = @encoded.ptr + @tag['RELASZ']
 			while @encoded.ptr < p_end
 				@relocations << RelocationAddend.decode(self)
@@ -509,10 +543,28 @@ class ELF
 		end
 	end
 
+	# returns the target of a relocation using reloc.symbol
+	# may create new labels if the relocation targets a section
+	def reloc_target(reloc)
+		target = 0
+		if reloc.symbol.kind_of?(Symbol)
+			if reloc.symbol.type == 'SECTION'
+				s = @sections[reloc.symbol.shndx]
+				if not target = @encoded.inv_export[s.offset]
+					target = new_label(s.name)
+					@encoded.add_export(target, s.offset)
+				end
+			elsif reloc.symbol.name
+				target = reloc.symbol.name
+			end
+		end
+		target
+	end
+
 	# returns the Metasm::Relocation that should be applied for reloc
 	# self.encoded.ptr must point to the location that will be relocated (for implicit addends)
 	def arch_decode_segments_reloc_386(reloc)
-		if reloc.symbol and n = reloc.symbol.name and reloc.symbol.shndx == 'UNDEF' and @sections and
+		if reloc.symbol.kind_of?(Symbol) and n = reloc.symbol.name and reloc.symbol.shndx == 'UNDEF' and @sections and
 			s = @sections.find { |s_| s_.name and s_.offset <= @encoded.ptr and s_.offset + s_.size > @encoded.ptr }
 			@encoded.add_export(new_label("#{s.name}_#{n}"), @encoded.ptr, true)
 		end
@@ -541,15 +593,14 @@ class ELF
 		when 'GLOB_DAT', 'JMP_SLOT', '32', 'PC32', 'TLS_TPOFF', 'TLS_TPOFF32'
 			# XXX use versionned version
 			# lazy jmp_slot ?
-			target = 0
-			target = reloc.symbol.name if reloc.symbol.kind_of?(Symbol) and reloc.symbol.name
+			target = reloc_target(reloc)
 			target = Expression[target, :-, reloc.offset] if reloc.type == 'PC32'
 			target = Expression[target, :+, addend] if addend and addend != 0
 			target = Expression[target, :+, 'tlsoffset'] if reloc.type == 'TLS_TPOFF'
 			target = Expression[:-, [target, :+, 'tlsoffset']] if reloc.type == 'TLS_TPOFF32'
 		when 'COPY'
 			# mark the address pointed as a copy of the relocation target
-			if not reloc.symbol or not name = reloc.symbol.name
+			if not reloc.symbol.kind_of?(Symbol) or not name = reloc.symbol.name
 				puts "W: Elf: symbol to COPY has no name: #{reloc.inspect}" if $VERBOSE
 				name = ''
 			end
@@ -567,24 +618,40 @@ class ELF
 	# returns the Metasm::Relocation that should be applied for reloc
 	# self.encoded.ptr must point to the location that will be relocated (for implicit addends)
 	def arch_decode_segments_reloc_mips(reloc)
-		if reloc.symbol and n = reloc.symbol.name and reloc.symbol.shndx == 'UNDEF' and @sections and
+		if reloc.symbol.kind_of?(Symbol) and n = reloc.symbol.name and reloc.symbol.shndx == 'UNDEF' and @sections and
 			s = @sections.find { |s_| s_.name and s_.offset <= @encoded.ptr and s_.offset + s_.size > @encoded.ptr }
 			@encoded.add_export(new_label("#{s.name}_#{n}"), @encoded.ptr, true)
 		end
 
+		original_word = decode_word
+
 		# decode addend if needed
 		case reloc.type
 		when 'NONE' # no addend
-		else addend = reloc.addend || decode_sword
+		else addend = reloc.addend || Expression.make_signed(original_word, 32)
 		end
 
 		case reloc.type
 		when 'NONE'
 		when '32', 'REL32'
-			target = 0
-			target = reloc.symbol.name if reloc.symbol.kind_of?(Symbol) and reloc.symbol.name
+			target = reloc_target(reloc)
 			target = Expression[target, :-, reloc.offset] if reloc.type == 'REL32'
 			target = Expression[target, :+, addend] if addend and addend != 0
+		when '26'
+			target = reloc_target(reloc)
+			addend &= 0x3ff_ffff
+			target = Expression[target, :+, [addend, :<<, 2]] if addend and addend != 0
+			target = Expression[[original_word, :&, 0xfc0_0000], :|, [[target, :&, 0x3ff_ffff], :>>, 2]]
+		when 'HI16'
+			target = reloc_target(reloc)
+			addend &= 0xffff
+			target = Expression[target, :+, [addend, :<<, 16]] if addend and addend != 0
+			target = Expression[[original_word, :&, 0xffff_0000], :|, [[target, :>>, 16], :&, 0xffff]]
+		when 'LO16'
+			target = reloc_target(reloc)
+			addend &= 0xffff
+			target = Expression[target, :+, addend] if addend and addend != 0
+			target = Expression[[original_word, :&, 0xffff_0000], :|, [target, :&, 0xffff]]
 		else
 			puts "W: Elf: unhandled MIPS reloc #{reloc.inspect}" if $VERBOSE
 			target = nil
@@ -596,7 +663,7 @@ class ELF
 	# returns the Metasm::Relocation that should be applied for reloc
 	# self.encoded.ptr must point to the location that will be relocated (for implicit addends)
 	def arch_decode_segments_reloc_x86_64(reloc)
-		if reloc.symbol and n = reloc.symbol.name and reloc.symbol.shndx == 'UNDEF' and @sections and
+		if reloc.symbol.kind_of?(Symbol) and n = reloc.symbol.name and reloc.symbol.shndx == 'UNDEF' and @sections and
 			s = @sections.find { |s_| s_.name and s_.offset <= @encoded.ptr and s_.offset + s_.size > @encoded.ptr }
 			@encoded.add_export(new_label("#{s.name}_#{n}"), @encoded.ptr, true)
 		end
@@ -627,14 +694,13 @@ class ELF
 		when 'GLOB_DAT', 'JMP_SLOT', '64', 'PC64', '32', 'PC32'
 			# XXX use versionned version
 			# lazy jmp_slot ?
-			target = 0
-			target = reloc.symbol.name if reloc.symbol.kind_of?(Symbol) and reloc.symbol.name
+			target = reloc_target(reloc)
 			target = Expression[target, :-, reloc.offset] if reloc.type == 'PC64' or reloc.type == 'PC32'
 			target = Expression[target, :+, addend] if addend and addend != 0
 			sz = :u32 if reloc.type == '32' or reloc.type == 'PC32'
 		when 'COPY'
 			# mark the address pointed as a copy of the relocation target
-			if not reloc.symbol or not name = reloc.symbol.name
+			if not reloc.symbol.kind_of?(Symbol) or not name = reloc.symbol.name
 				puts "W: Elf: symbol to COPY has no name: #{reloc.inspect}" if $VERBOSE
 				name = ''
 			end
@@ -649,6 +715,79 @@ class ELF
 		Metasm::Relocation.new(Expression[target], sz, @endianness) if target
 	end
 
+	def arch_decode_segments_reloc_sh(reloc)
+		if reloc.symbol.kind_of?(Symbol) and n = reloc.symbol.name and reloc.symbol.shndx == 'UNDEF' and @sections and
+			s = @sections.find { |s_| s_.name and s_.offset <= @encoded.ptr and s_.offset + s_.size > @encoded.ptr }
+			@encoded.add_export(new_label("#{s.name}_#{n}"), @encoded.ptr, true)
+		end
+
+		original_word = decode_word
+
+		# decode addend if needed
+		case reloc.type
+		when 'NONE' # no addend
+		else addend = reloc.addend || Expression.make_signed(original_word, 32)
+		end
+
+		case reloc.type
+		when 'NONE'
+		when 'GLOB_DAT', 'JMP_SLOT'
+			target = reloc_target(reloc)
+			target = Expression[target, :+, addend] if addend and addend != 0
+		else
+			puts "W: Elf: unhandled SH reloc #{reloc.inspect}" if $VERBOSE
+			target = nil
+		end
+
+		Metasm::Relocation.new(Expression[target], :u32, @endianness) if target
+	end
+
+	def arch_decode_segments_reloc_openrisc(reloc)
+		if reloc.symbol.kind_of?(Symbol) and n = reloc.symbol.name and reloc.symbol.shndx == 'UNDEF' and @sections and
+			s = @sections.find { |s_| s_.name and s_.offset <= @encoded.ptr and s_.offset + s_.size > @encoded.ptr }
+			@encoded.add_export(new_label("#{s.name}_#{n}"), @encoded.ptr, true)
+		end
+
+		original_word = decode_word
+
+		# decode addend if needed
+		case reloc.type
+		when 'NONE' # no addend
+		else addend = reloc.addend || Expression.make_signed(original_word, 32)
+		end
+
+		case reloc.type
+		when 'NONE'
+		when '32', '32_PCREL'
+			target = reloc_target(reloc)
+			target = Expression[target, :-, reloc.offset] if reloc.type == '32_PCREL'
+			target = Expression[target, :+, addend] if addend and addend != 0
+		when 'INSN_REL_26'
+			target = reloc_target(reloc)
+			addend &= 0x3ff_ffff
+			target = Expression[target, :+, [addend, :<<, 2]] if addend and addend != 0
+			target = Expression[[original_word, :&, 0xfc0_0000], :|, [[target, :&, 0x3ff_ffff], :>>, 2]]
+		when 'HI_16_IN_INSN'
+			target = reloc_target(reloc)
+			addend &= 0xffff
+			target = Expression[target, :+, [addend, :<<, 16]] if addend and addend != 0
+			target = Expression[[original_word, :&, 0xffff_0000], :|, [[target, :>>, 16], :&, 0xffff]]
+		when 'LO_16_IN_INSN'
+			target = reloc_target(reloc)
+			addend &= 0xffff
+			target = Expression[target, :+, addend] if addend and addend != 0
+			target = Expression[[original_word, :&, 0xffff_0000], :|, [target, :&, 0xffff]]
+		when 'JMP_SLOT'
+			target = reloc_target(reloc)
+			target = Expression[target, :+, addend] if addend and addend != 0
+		else
+			puts "W: Elf: unhandled MIPS reloc #{reloc.inspect}" if $VERBOSE
+			target = nil
+		end
+
+		Metasm::Relocation.new(Expression[target], :u32, @endianness) if target
+	end
+
 	class DwarfDebug
 		# decode a DWARF2 'compilation unit'
 		def decode(elf, info, abbrev, str)
@@ -749,12 +888,13 @@ class ELF
 	end
 
 	# decodes the ELF dynamic tags, interpret them, and decodes symbols and relocs
-	def decode_segments_dynamic
+	def decode_segments_dynamic(decode_relocs=true)
 		return if not dynamic = @segments.find { |s| s.type == 'DYNAMIC' }
 		@encoded.ptr = add_label('dynamic_tags', dynamic.vaddr)
 		decode_tags
 		decode_segments_tags_interpret
 		decode_segments_symbols
+		return if not decode_relocs
 		decode_segments_relocs
 		decode_segments_relocs_interpret
 	end
@@ -783,6 +923,7 @@ class ELF
 
 	# decodes sections, interprets symbols/relocs, fills sections.encoded
 	def decode_sections
+		@symbols.clear	# the NULL symbol is explicit in the symbol table
 		decode_sections_symbols
 		decode_sections_relocs
 		@sections.each { |s|
@@ -804,7 +945,7 @@ class ELF
 	end
 
 	def decode_exports
-		decode_segments_dynamic
+		decode_segments_dynamic(false)
 	end
 
 	# decodes the elf header, and depending on the elf type, decode segments or sections
@@ -819,12 +960,14 @@ class ELF
 
 	def each_section
 		@segments.each { |s| yield s.encoded, s.vaddr if s.type == 'LOAD' }
-	       	return if @header.type != 'REL'
+		return if @header.type != 'REL'
 		@sections.each { |s|
 			next if not s.encoded
-			l = new_label(s.name)
-			s.encoded.add_export l, 0
-		       	yield s.encoded, l
+			if not l = s.encoded.inv_export[0] or l != s.name.tr('^a-zA-Z0-9_', '_')
+				l = new_label(s.name)
+				s.encoded.add_export l, 0
+			end
+			yield s.encoded, l
 		}
 	end
 
@@ -833,9 +976,14 @@ class ELF
 		case @header.machine
 		when 'X86_64'; X86_64.new
 		when '386'; Ia32.new
-		when 'MIPS'; MIPS.new @endianness
+		when 'MIPS'; (@header.flags.include?('32BITMODE') ? MIPS64 : MIPS).new(@endianness)
 		when 'PPC'; PPC.new
 		when 'ARM'; ARM.new
+		when 'AARCH64'; AArch64.new
+		when 'SH'; Sh4.new
+		when 'ARC_COMPACT'; ARC.new
+		when 'MSP430'; MSP430.new
+		when 'OPENRISC'; OpenRisc.new(:latest, @endianness, (@header.flags.include?('NODELAY') ? 0 : 1))
 		else raise "unsupported cpu #{@header.machine}"
 		end
 	end
@@ -912,6 +1060,24 @@ EOC
 				(d.address_binding[s.value] ||= {})[:$t9] ||= Expression[s.value]
 			}
 			d.function[:default] = @cpu.disassembler_default_func
+		when 'sh4'
+			noret = DecodedFunction.new
+			noret.noreturn = true
+			%w[__stack_chk_fail abort exit].each { |fn|
+				d.function[Expression[fn]] = noret
+			}
+			d.function[:default] = @cpu.disassembler_default_func
+		when 'openrisc'
+			old_cp = d.c_parser
+			d.c_parser = nil
+			d.parse_c <<EOC
+void __libc_start_main(void(*)(), int, char**, void(*)(), void(*)()) __attribute__((noreturn));
+void __attribute__((noreturn)) exit(int);
+EOC
+			d.function[Expression['__libc_start_main']] = @cpu.decode_c_function_prototype(d.c_parser, '__libc_start_main')
+			d.function[Expression['exit']] = @cpu.decode_c_function_prototype(d.c_parser, 'exit')
+			d.c_parser = old_cp
+			d.function[:default] = @cpu.disassembler_default_func
 		end
 		d
 	end

data/{lib/metasm → metasm}/exe_format/elf_encode.rb

@@ -11,7 +11,7 @@ module Metasm
 class ELF
 	class Header
 		def set_default_values elf
-			@magic     ||= "\x7fELF"
+			@magic     ||= ELF::MAGIC
 			@e_class   ||= elf.bitsize.to_s
 			@data      ||= (elf.endianness == :big ? 'MSB' : 'LSB')
 			@version   ||= 'CURRENT'
@@ -20,10 +20,10 @@ class ELF
 			@phoff     ||= elf.segments.empty? ? 0 : elf.new_label('phdr')
 			@shoff     ||= elf.sections.length <= 1 ? 0 : elf.new_label('shdr')
 			@flags     ||= []
-			@ehsize    ||= Header.size(elf)
-			@phentsize ||= Segment.size(elf)
+			@ehsize    ||= Header.sizeof(elf)
+			@phentsize ||= Segment.sizeof(elf)
 			@phnum     ||= elf.segments.length
-			@shentsize ||= Section.size(elf)
+			@shentsize ||= Section.sizeof(elf)
 			@shnum     ||= elf.sections.length
 
 			super(elf)
@@ -47,8 +47,8 @@ class ELF
 		# defines the @name_p field from @name and elf.section[elf.header.shstrndx]
 		# creates .shstrtab if needed
 		def make_name_p elf
-			return 0 if not name or @name == ''
-			if elf.header.shstrndx.to_i == 0
+			return 0 if not name or @name == '' or elf.header.shnum == 0
+			if elf.header.shstrndx.to_i == 0 or not elf.sections[elf.header.shstrndx]
 				sn = Section.new
 				sn.name = '.shstrtab'
 				sn.type = 'STRTAB'
@@ -62,6 +62,7 @@ class ELF
 			return if name_p and sne.data[@name_p, @name.length+1] == @name+0.chr
 			return if @name_p = sne.data.index(@name+0.chr)
 			@name_p = sne.virtsize
+			@name.force_encoding('BINARY') if name.respond_to?(:force_encoding)
 			sne << @name << 0
 		end
 	end
@@ -92,6 +93,7 @@ class ELF
 			return if name_p and s[@name_p, @name.length+1] == @name+0.chr
 			return if @name_p = s.index(@name+0.chr)
 			@name_p = strtab.length
+			@name.force_encoding('BINARY') if name.respond_to?(:force_encoding)
 			strtab << @name << 0
 		end
 	end
@@ -140,6 +142,9 @@ class ELF
 		srank = rank[s]
 		nexts = @sections.find { |sec| rank[sec] > srank }	# find section with rank superior
 		nexts = nexts ? @sections.index(nexts) : -1		# if none, last
+		if @header.shstrndx.to_i != 0 and nexts != -1 and @header.shstrndx >= nexts
+			@header.shstrndx += 1
+		end
 		@sections.insert(nexts, s)				# insert section
 	end
 
@@ -196,6 +201,8 @@ class ELF
 
 	# encodes the symbol dynamic hash table in the .hash section, updates the HASH tag
 	def encode_hash
+		return if @symbols.length <= 1
+
 		if not hash = @sections.find { |s| s.type == 'HASH' }
 			hash = Section.new
 			hash.name = '.hash'
@@ -236,11 +243,13 @@ class ELF
 	# encodes the symbol table
 	# should have a stable self.sections array (only append allowed after this step)
 	def encode_segments_symbols(strtab)
+		return if @symbols.length <= 1
+
 		if not dynsym = @sections.find { |s| s.type == 'DYNSYM' }
 			dynsym = Section.new
 			dynsym.name = '.dynsym'
 			dynsym.type = 'DYNSYM'
-			dynsym.entsize = Symbol.size(self)
+			dynsym.entsize = Symbol.sizeof(self)
 			dynsym.addralign = 4
 			dynsym.flags = ['ALLOC']
 			dynsym.info = @symbols[1..-1].find_all { |s| s.bind == 'LOCAL' }.length + 1
@@ -251,7 +260,7 @@ class ELF
 		@symbols.each { |s| dynsym.encoded << s.encode(self, strtab.encoded) }	# needs all section indexes, as will be in the final section header
 
 		@tag['SYMTAB'] = label_at(dynsym.encoded, 0)
-		@tag['SYMENT'] = Symbol.size(self)
+		@tag['SYMENT'] = Symbol.sizeof(self)
 
 		encode_check_section_size dynsym
 
@@ -261,7 +270,7 @@ class ELF
 	# encodes the relocation tables
 	# needs a complete self.symbols array
 	def encode_segments_relocs
-		return if not @relocations
+		return if not @relocations or @relocations.empty?
 
 		arch_preencode_reloc_func = "arch_#{@header.machine.downcase}_preencode_reloc"
 		send arch_preencode_reloc_func if respond_to? arch_preencode_reloc_func
@@ -287,7 +296,7 @@ class ELF
 			@tag['JMPREL'] = label_at(relplt.encoded, 0)
 			@tag['PLTRELSZ'] = relplt.encoded.virtsize
 			@tag['PLTREL'] = relplt.type = stype
-			@tag[stype + 'ENT']  = relplt.entsize = relplt.addralign = (stype == 'REL' ? Relocation.size(self) : RelocationAddend.size(self))
+			@tag[stype + 'ENT']  = relplt.entsize = relplt.addralign = (stype == 'REL' ? Relocation.sizeof(self) : RelocationAddend.sizeof(self))
 			encode_check_section_size relplt
 		end
 
@@ -305,13 +314,13 @@ class ELF
 				rel.name = '.rel.dyn'
 				rel.type = 'REL'
 				rel.flags = ['ALLOC']
-				rel.entsize = rel.addralign = Relocation.size(self)
+				rel.entsize = rel.addralign = Relocation.sizeof(self)
 				encode_add_section rel
 			end
 			rel.encoded = EncodedData.new
 			list.each { |r| rel.encoded << r.encode(self) }
 			@tag['REL'] = label_at(rel.encoded, 0)
-			@tag['RELENT'] = Relocation.size(self)
+			@tag['RELENT'] = Relocation.sizeof(self)
 			@tag['RELSZ'] = rel.encoded.virtsize
 			encode_check_section_size rel
 		end
@@ -323,13 +332,13 @@ class ELF
 				rela.name = '.rela.dyn'
 				rela.type = 'RELA'
 				rela.flags = ['ALLOC']
-				rela.entsize = rela.addralign = RelocationAddend.size(self)
+				rela.entsize = rela.addralign = RelocationAddend.sizeof(self)
 				encode_add_section rela
 			end
 			rela.encoded = EncodedData.new
 			list.each { |r| rela.encoded << r.encode(self) }
 			@tag['RELA'] = label_at(rela.encoded, 0)
-			@tag['RELAENT'] = RelocationAddend.size(self)
+			@tag['RELAENT'] = RelocationAddend.sizeof(self)
 			@tag['RELASZ'] = rela.encoded.virtsize
 			encode_check_section_size rela
 		end
@@ -337,6 +346,8 @@ class ELF
 
 	# creates the .plt/.got from the @relocations
 	def arch_386_preencode_reloc
+		return if @relocations.empty?
+
 		# if .got.plt does not exist, the dynamic loader segfaults
 		if not gotplt = @sections.find { |s| s.type == 'PROGBITS' and s.name == '.got.plt' }
 			gotplt = Section.new
@@ -358,7 +369,7 @@ class ELF
 			when 'PC32'
 				next if not r.symbol
 
-			       	if r.symbol.type != 'FUNC'
+				if r.symbol.type != 'FUNC'
 					# external data xref: generate a GOT entry
 					# XXX reuse .got.plt ?
 					if not got ||= @sections.find { |s| s.type == 'PROGBITS' and s.name == '.got' }
@@ -385,7 +396,7 @@ class ELF
 					else
 						@relocations.delete r
 					end
-		
+
 					# prevoffset is label_section_start + int_section_offset
 					target_s = @sections.find { |s| s.encoded and s.encoded.export[prevoffset.lexpr] == 0 }
 					rel = target_s.encoded.reloc[prevoffset.rexpr]
@@ -411,12 +422,12 @@ class ELF
 				#
 				# [.got.plt header]
 				# dd _DYNAMIC
-				# dd 0 				# rewritten to GOTPLT? by ld-linux
+				# dd 0				# rewritten to GOTPLT? by ld-linux
 				# dd 0				# rewritten to dlresolve_inplace by ld-linux
 				#
 				# [.got.plt + func_got_offset]
 				# dd some_func_got_default	# lazily rewritten to the real addr of some_func by jmp dlresolve_inplace
-				# 				# base_relocated ?
+				#				# base_relocated ?
 
 				# in the PIC case, _dlresolve imposes us to use the ebx register (which may not be saved by the calling function..)
 				# also geteip trashes eax, which may interfere with regparm(3)
@@ -448,7 +459,7 @@ class ELF
 					plt.encoded << shellcode["jmp [#{base} + #{gotplt.encoded.length}]"]
 					plt.encoded.add_export r.symbol.name+'_plt_default', plt.encoded.length
 					reloffset = @relocations.find_all { |rr| rr.type == 'JMP_SLOT' }.length
-					reloffset *= Relocation.size(self) if @bitsize == 32
+					reloffset *= Relocation.sizeof(self) if @bitsize == 32
 					plt.encoded << shellcode["push #{reloffset}\njmp metasm_plt_start"]
 
 					# transform the reloc PC32 => JMP_SLOT
@@ -510,6 +521,7 @@ class ELF
 		add_str = lambda { |n|
 			if n and n != '' and not ret = strtab.encoded.data.index(n + 0.chr)
 				ret = strtab.encoded.virtsize
+				n.force_encoding('BINARY') if n.respond_to?(:force_encoding)
 				strtab.encoded << n << 0
 			end
 			ret || 0
@@ -531,7 +543,7 @@ class ELF
 
 				# fill these later, but create the base relocs now
 				arch_create_reloc_func = "arch_#{@header.machine.downcase}_create_reloc"
-				next if not respond_to?(arch_create_reloc_func) 
+				next if not respond_to?(arch_create_reloc_func)
 				curaddr = label_at(@encoded, 0, 'elf_start')
 				fkbind = {}
 				@sections.each { |s|
@@ -557,6 +569,9 @@ class ELF
 
 		encode_check_section_size strtab
 
+		# rm unused tag (shrink .nointerp binaries by allowing to skip the section entirely)
+		@tag.delete('STRTAB') if strtab.encoded.length == 1
+
 		# XXX any order needed ?
 		@tag.keys.each { |k|
 			case k
@@ -581,7 +596,7 @@ class ELF
 				encode_tag[k, @tag[k]]
 			end
 		}
-		encode_tag['NULL', @tag['NULL'] || 0]
+		encode_tag['NULL', @tag['NULL'] || 0] unless @tag.empty?
 
 		encode_check_section_size dynamic
 	end
@@ -598,17 +613,13 @@ class ELF
 		@sections.each { |s|
 			next if not s.encoded
 			s.encoded.reloc.each_value { |r|
-				t = Expression[r.target.reduce]
-				if t.op == :+ and t.rexpr.kind_of? Expression and t.rexpr.op == :- and not t.rexpr.lexpr and
-						t.rexpr.rexpr.kind_of?(::String) and t.lexpr.kind_of?(::String)
-					symname = t.lexpr
-				else
-					symname = t.reduce_rec
-				end
-				next if not dll = autoexports[symname]
+				et = r.target.externals
+				extern = et.find_all { |name| autoexports[name] }
+				next if extern.length != 1
+				symname = extern.first
 				if not @symbols.find { |sym| sym.name == symname }
 					@tag['NEEDED'] ||= []
-					@tag['NEEDED'] |= [dll]
+					@tag['NEEDED'] |= [autoexports[symname]]
 					sym = Symbol.new
 					sym.shndx = 'UNDEF'
 					sym.type = 'FUNC'
@@ -737,6 +748,55 @@ class ELF
 		@relocations << r
 	end
 
+	def arch_mips_create_reloc(section, off, binding, rel=nil)
+		rel ||= section.encoded.reloc[off]
+		startaddr = label_at(@encoded, 0)
+		r = Relocation.new
+		r.offset = Expression[label_at(section.encoded, 0, 'sect_start'), :+, off]
+		if Expression[rel.target, :-, startaddr].bind(binding).reduce.kind_of?(::Integer)
+			# this location is relative to the base load address of the ELF
+			r.type = 'REL32'
+		else
+			et = rel.target.externals
+			extern = et.find_all { |name| not binding[name] }
+			if extern.length != 1
+				puts "ELF: mips_create_reloc: ignoring reloc #{rel.target} in #{section.name}: #{extern.inspect} unknown" if $VERBOSE
+				return
+			end
+			if not sym = @symbols.find { |s| s.name == extern.first }
+				puts "ELF: mips_create_reloc: ignoring reloc #{rel.target} in #{section.name}: undefined symbol #{extern.first}" if $VERBOSE
+				return
+			end
+			r.symbol = sym
+			if Expression[rel.target, :-, sym.name].bind(binding).reduce.kind_of?(::Integer)
+				rel.target = Expression[rel.target, :-, sym.name]
+				r.type = '32'
+			elsif Expression[rel.target, :&, 0xffff0000].reduce.kind_of?(::Integer)
+				lo = Expression[rel.target, :&, 0xffff].reduce
+				lo = lo.lexpr if lo.kind_of?(Expression) and lo.op == :& and lo.rexpr == 0xffff
+				if lo.kind_of?(Expression) and lo.op == :>> and lo.rexpr == 16
+					r.type = 'HI16'
+					rel.target = Expression[rel.target, :&, 0xffff0000]
+					# XXX offset ?
+				elsif lo.kind_of?(String) or (lo.kind_of(Expression) and lo.op == :+)
+					r.type = 'LO16'
+					rel.target = Expression[rel.target, :&, 0xffff0000]
+					# XXX offset ?
+				else
+					puts "ELF: mips_create_reloc: ignoring reloc #{lo}: cannot find matching 16 reloc type" if $VERBOSE
+					return
+				end
+			#elsif Expression[rel.target, :+, label_at(section.encoded, 0)].bind(section.encoded.binding).reduce.kind_of? ::Integer
+			#	rel.target = Expression[[rel.target, :+, label_at(section.encoded, 0)], :+, off]
+			#	r.type = 'PC32'
+			else
+				puts "ELF: mips_create_reloc: ignoring reloc #{sym.name} + #{rel.target}: cannot find matching standard reloc type" if $VERBOSE
+				return
+			end
+		end
+		@relocations << r
+	end
+
 	# resets the fields of the elf headers that should be recalculated, eg phdr offset
 	def invalidate_header
 		@header.shoff = @header.shnum = nil
@@ -817,9 +877,13 @@ class ELF
 				end
 
 		if @header.type == 'REL'
-			raise 'ET_REL encoding not supported atm, come back later'
+			encode_rel
+		else
+			encode_elf
 		end
+	end
 
+	def encode_elf
 		@encoded = EncodedData.new
 		if @header.type != 'EXEC' or @segments.find { |i| i.type == 'INTERP' }
 			# create a .dynamic section unless we are an ET_EXEC with .nointerp
@@ -870,7 +934,7 @@ class ELF
 		end
 
 		# add dynamic segment
-		if ds = @sections.find { |sec| sec.type == 'DYNAMIC' }
+		if ds = @sections.find { |sec| sec.type == 'DYNAMIC' } and ds.encoded.length > 1
 			ds.set_default_values self
 			seg = Segment.new
 			seg.type = 'DYNAMIC'
@@ -979,6 +1043,36 @@ class ELF
 		@encoded.data
 	end
 
+	def encode_rel
+		@encoded = EncodedData.new
+		automagic_symbols
+		create_relocations
+
+		@header.phoff = @header.phnum = @header.phentsize = 0
+		@header.entry = 0
+		@sections.each { |sec| sec.addr = 0 }
+		st = @sections.inject(EncodedData.new) { |edata, sec| edata << sec.encode(self) }
+
+		binding = {}
+		@encoded << @header.encode(self)
+		@encoded.align 8
+
+		binding[@header.shoff] = @encoded.length
+		@encoded << st
+		@encoded.align 8
+
+		@sections.each { |sec|
+			next if not sec.encoded
+			binding[sec.offset] = @encoded.length
+			sec.encoded.fixup sec.encoded.binding
+			@encoded << sec.encoded
+			@encoded.align 8
+		}
+
+		@encoded.fixup! binding
+		@encoded.data
+	end
+
 	def parse_init
 		# allow the user to specify a section, falls back to .text if none specified
 		if not defined? @cursource or not @cursource