metasm 1.0.1 → 1.0.2

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

@@ -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'
@@ -140,6 +140,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 +199,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 +241,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 +258,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 +268,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 +294,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 +312,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 +330,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 +344,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 +367,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 +394,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 +420,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 +457,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
@@ -531,7 +540,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 +566,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 +593,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 +610,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 +745,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 +874,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 +931,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 +1040,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

data/metasm/exe_format/gb.rb

@@ -0,0 +1,65 @@
+#    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
+# GameBoy ROM file format
+class GameBoyRom < ExeFormat
+	class Header < SerialStruct
+		# starts at 0x104 in the file
+		mem :logo, 0x30
+		str :title, 0x10
+		byte :sgb_flag
+		byte :cartridge_type
+		byte :rom_size	# n => (n+1) * 32k bytes
+		byte :ram_size
+		byte :destination_code
+		byte :old_licensee_code
+		byte :mask_rom_version
+		byte :header_checksum
+		byte :checksum_hi
+		byte :checksum_lo
+	end
+
+	def encode_byte(val) Expression[val].encode(:u8,  @endianness) end
+	def decode_byte(edata = @encoded) edata.decode_imm(:u8,  @endianness) end
+	def sizeof_byte ; 1 ; end
+
+
+	attr_accessor :header
+
+	def initialize(cpu=nil)
+		@endianness = (cpu ? cpu.endianness : :little)
+		super(cpu)
+	end
+
+	def decode_header
+		@encoded.ptr = 0x104
+		@header = Header.decode(self)
+	end
+
+	def decode
+		decode_header
+		@encoded.add_export('entrypoint', 0x100)
+	end
+
+	def cpu_from_headers
+		Z80.new('gb')
+	end
+
+	def each_section
+		yield @encoded, 0
+	end
+
+	def get_default_entrypoints
+		['entrypoint']
+	end
+end
+end

data/metasm/exe_format/javaclass.rb

@@ -0,0 +1,424 @@
+#    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 JavaClass < ExeFormat
+	MAGIC = "\xCA\xFE\xBA\xBE"
+
+	CONSTANT_TAG = {0x1 => 'Utf8',   0x3 => 'Integer',
+			0x4 => 'Float',  0x5 => 'Long',
+			0x6 => 'Double', 0x7 => 'Class',
+			0x8 => 'String', 0x9 => 'Fieldref',
+			0xa => 'Methodref', 0xb => 'InterfaceMethodref',
+			0xc => 'NameAndType' }
+
+	class SerialStruct < Metasm::SerialStruct
+		new_int_field :u1, :u2, :u4
+	end
+
+	class Header < SerialStruct
+		mem :magic, 4, MAGIC
+		u2 :minor_version
+		u2 :major_version
+	end
+
+	class ConstantPool < SerialStruct
+		u2 :constant_pool_count
+		attr_accessor :constant_pool
+
+		def decode(c)
+			super(c)
+
+			@constant_pool = [nil]
+
+			i = 1
+			while i < @constant_pool_count
+				entry = ConstantPoolInfo.decode(c)
+				entry.idx = i
+				@constant_pool << entry
+				i += 1
+
+				if entry.tag =~ /Long|Double/
+					# we must insert a phantom cell
+					# for long and double constants
+					@constant_pool << nil
+					i += 1
+				end
+			end
+		end
+
+		def encode(c)
+			cp = super(c)
+
+			@constant_pool.each { |entry|
+				next if entry.nil?
+				cp << entry.encode(c)
+			}
+			cp
+		end
+
+		def [](idx)
+			@constant_pool[idx]
+		end
+
+		def []=(idx, val)
+			raise 'cannot be used to add a cp entry' if @constant_pool[idx].nil?
+			@constant_pool[idx] = val
+		end
+	end
+
+	class ConstantPoolInfo < SerialStruct
+		u1 :tag
+		fld_enum :tag, CONSTANT_TAG
+		attr_accessor :info, :idx
+
+		def decode(c)
+			super(c)
+
+			case @tag
+			when 'Utf8'
+				@info = ConstantUtf8.decode(c)
+			when /Integer|Float/
+				@info = ConstantIntFloat.decode(c)
+			when /Long|Double/
+				@info = ConstantLongDouble.decode(c)
+			when /Class|String/
+				@info = ConstantIndex.decode(c)
+			when /ref$/
+				@info = ConstantRef.decode(c)
+			when 'NameAndType'
+				@info = ConstantNameAndType.decode(c)
+			else
+				raise 'unkown constant tag'
+				return
+			end
+		end
+
+		def encode(c)
+			super(c) << @info.encode(c)
+		end
+	end
+
+	class ConstantUtf8 < SerialStruct
+		u2 :length
+		attr_accessor :bytes
+
+		def decode(c)
+			super(c)
+			@bytes = c.encoded.read(@length)
+		end
+
+		def encode(c)
+			super(c) << @bytes
+		end
+	end
+
+	class ConstantIntFloat < SerialStruct
+		u4 :bytes
+	end
+
+	class ConstantLongDouble < SerialStruct
+		u4 :high_bytes
+		u4 :low_bytes
+	end
+
+	class ConstantIndex < SerialStruct
+		u2 :index
+	end
+
+	class ConstantRef < SerialStruct
+		u2 :class_index
+		u2 :name_and_type_index
+	end
+
+	class ConstantNameAndType < SerialStruct
+		u2 :name_index
+		u2 :descriptor_index
+	end
+
+	class ClassInfo < SerialStruct
+		u2 :access_flags
+		u2 :this_class
+		u2 :super_class
+	end
+
+	class Interfaces < SerialStruct
+		u2 :interfaces_count
+		attr_accessor :interfaces
+
+		def decode(c)
+			super(c)
+
+			@interfaces = []
+			@interfaces_count.times {
+				@interfaces << ConstantIndex.decode(c)
+			}
+		end
+
+		def encode(c)
+			ret = super(c)
+
+			@interfaces.each { |e|
+				ret << e.encode(c)
+			}
+			ret
+		end
+
+		def [](idx)
+			@interfaces[idx]
+		end
+	end
+
+	class Fields < SerialStruct
+		u2 :fields_count
+		attr_accessor :fields
+
+		def decode(c)
+			super(c)
+			@fields = []
+			@fields_count.times {
+				@fields << FieldMethodInfo.decode(c)
+			}
+		end
+
+		def encode(c)
+			ret = super(c)
+
+			@fields.each { |e|
+				ret << e.encode(c)
+			}
+			ret
+		end
+
+		def [](idx)
+			@fields[idx]
+		end
+	end
+
+	class Methods < SerialStruct
+		u2 :methods_count
+		attr_accessor :methods
+
+		def decode(c)
+			super(c)
+			@methods = []
+			@methods_count.times {
+				@methods << FieldMethodInfo.decode(c)
+			}
+		end
+
+		def encode(c)
+			ret = super(c)
+
+			@methods.each { |e|
+				ret << e.encode(c)
+			}
+			ret
+		end
+
+		def [](idx)
+			@methods[idx]
+		end
+	end
+
+	class FieldMethodInfo < SerialStruct
+		u2 :access_flags
+		u2 :name_index
+		u2 :descriptor_index
+		attr_accessor :attributes
+
+		def decode(c)
+			super(c)
+			@attributes = Attributes.decode(c)
+		end
+
+		def encode(c)
+			super(c) << @attributes.encode(c)
+		end
+	end
+
+	class Attributes < SerialStruct
+		u2 :attributes_count
+		attr_accessor :attributes
+
+		def decode(c)
+			super(c)
+
+			@attributes = []
+			@attributes_count.times { |i|
+				@attributes << AttributeInfo.decode(c)
+			}
+		end
+
+		def encode(c)
+			ret = super(c)
+
+			@attributes.each { |e|
+				ret << e.encode(c)
+			}
+			ret
+		end
+
+		def [](idx)
+			@attributes[idx]
+		end
+	end
+
+	class AttributeInfo < SerialStruct
+		u2 :attribute_name_index
+		u4 :attribute_length
+		attr_accessor :data
+
+		def decode(c)
+			super(c)
+			@data = c.encoded.read(@attribute_length)
+		end
+
+		def encode(c)
+			super(c) << @data
+		end
+	end
+
+	def encode_u1(val) Expression[val].encode(:u8, @endianness) end
+	def encode_u2(val) Expression[val].encode(:u16, @endianness) end
+	def encode_u4(val) Expression[val].encode(:u32, @endianness) end
+	def decode_u1(edata = @encoded) edata.decode_imm(:u8, @endianness) end
+	def decode_u2(edata = @encoded) edata.decode_imm(:u16, @endianness) end
+	def decode_u4(edata = @encoded) edata.decode_imm(:u32, @endianness) end
+	def sizeof_u1 ; 1 ; end
+	def sizeof_u2 ; 2 ; end
+	def sizeof_u4 ; 4 ; end
+
+	attr_accessor :header, :constant_pool, :class_info, :interfaces, :fields, :methods, :attributes
+
+	def initialize(endianness=:big)
+		@endianness = endianness
+		@encoded = EncodedData.new
+		super()
+	end
+
+	def decode
+		@header = Header.decode(self)
+		@constant_pool = ConstantPool.decode(self)
+		@class_info = ClassInfo.decode(self)
+		@interfaces = Interfaces.decode(self)
+		@fields = Fields.decode(self)
+		@methods = Methods.decode(self)
+		@attributes = Attributes.decode(self)
+	end
+
+	def encode
+		@encoded = EncodedData.new
+		@encoded << @header.encode(self)
+		@encoded << @constant_pool.encode(self)
+		@encoded << @class_info.encode(self)
+		@encoded << @interfaces.encode(self)
+		@encoded << @fields.encode(self)
+		@encoded << @methods.encode(self)
+		@encoded << @attributes.encode(self)
+		@encoded.data
+	end
+
+	def cpu_from_headers
+		raise 'JVM'
+	end
+
+	def each_section
+		raise 'n/a'
+	end
+
+	def get_default_entrypoints
+		[]
+	end
+
+	def string_at(idx)
+		loop do
+			tmp = @constant_pool[idx].info
+			return tmp.bytes if tmp.kind_of? ConstantUtf8
+			idx = tmp.index
+		end
+	end
+
+	def decode_methodref(mref)
+		class_idx = mref.info.class_index
+		nt_idx = mref.info.name_and_type_index
+		name_idx = @constant_pool[nt_idx].info.name_index
+		desc_idx = @constant_pool[nt_idx].info.descriptor_index
+
+		string_at(class_idx) + '/' + string_at(name_idx) + string_at(desc_idx)
+	end
+
+	def cp_add(cpi, tag)
+		cpe = ConstantPoolInfo.new
+		cpe.tag = tag
+		cpe.info = cpi
+		cpe.idx = @constant_pool.constant_pool_count
+
+		@constant_pool.constant_pool << cpe
+		@constant_pool.constant_pool_count += 1
+		@constant_pool.constant_pool_count += 1 if tag =~ /Long|Double/
+
+		cpe.idx
+	end
+
+	def cp_find(tag)
+		constant_pool.constant_pool.each { |e|
+			next if !e or e.tag != tag
+			if yield(e.info)
+				return e.idx
+			end
+		}
+		nil
+	end
+
+
+	def cp_auto_utf8(string)
+		if idx = cp_find('Utf8') { |i| i.bytes == string }
+			return idx
+		end
+
+		cpi = ConstantUtf8.new
+		cpi.bytes = string
+		cpi.length = string.length
+		cp_add(cpi, 'Utf8')
+	end
+
+	def cp_auto_class(classname)
+		if idx = cp_find('Class') { |i| string_at(i.index) == classname }
+			return idx
+		end
+
+		cpi = ConstantIndex.new
+		cpi.index = cp_auto_utf8(classname)
+		cp_add(cpi, 'Class')
+	end
+
+	def cp_add_methodref(classname, name, descriptor)
+		nat = ConstantNameAndType.new
+		nat.name_index = cp_auto_utf8(name)
+		nat.descriptor_index = cp_auto_utf8(descriptor)
+		natidx = cp_add(nat, 'NameAndType')
+
+		cpi = ConstantRef.new
+		cpi.class_index = cp_auto_class(classname)
+		cpi.name_and_type_index = natidx
+
+		cp_add(cpi, 'Methodref')
+	end
+
+	def attribute_create(name, data)
+		a = AttributeInfo.new
+		a.attribute_name_index = cp_auto_utf8(name)
+		a.attribute_length = data.size
+		a.data = data
+		a
+	end
+end
+end