kompiler 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90ed49bc46f0641a23f0d7d561489d4ec326e8f3bb933a638ed789831e9ee362
-  data.tar.gz: 9c0d4b1f795b9e7a2b73a145218a972854fdd8372808a6fb68b3c210899d2ad8
+  metadata.gz: 18cda0db09b288b5ad14ebb5feb99e13fe03ea5a7897d603285b0aab0c8bdb77
+  data.tar.gz: e84247276f40846adef9798d8ea6584dc3fe156caaa18495c668ee7f99506e9e
 SHA512:
-  metadata.gz: 8a18cb49c4740e3f5d86a074c75a87c90db0de718dad6ec2547b802d1acf70dd4a726fcc163ba6bf17f83b58c91e02a0e331f48b707a2ac6d80ac331f4c852fc
-  data.tar.gz: c54ac313fed9b03a22810678244e0809dc29f25c0974c2ded1251fac7e6d01f2c28f50a0844938532eda6d7ec90b78ddf8afb0634485662ef1246677c18bc5d5
+  metadata.gz: d682ae38a0d09b9ca8c584de5a3687554a97962ab227fcfb1bd7f458d0f5c48ff1ca0386db8ddcd6f80832e5d94a53b12a655164a23e58bd168128dd8a05106e
+  data.tar.gz: 04e832aff94a2948615b3f9ca03db1cc75648673873ec9a4678aab6f09aa24b595d9a276910cf53f00de34dffebb0bfc7675b1150749bdfcbe6225bae2778401

data/bin/kompile

@@ -112,6 +112,7 @@ Available wrapping formats:
 
 Additional options for wrapping are:
  --elf-machine=<type>                 Specifies ELF header's e_machine to be the type provided (default is 0)
+ --elf-class=<class>                  Specifies the ELF file's class to either 32 or 64 (default is 64)
  --mach-o-machine=<cputype.subtype>   Specifies Mach-O header's cputype and subtype
                                       to be the type provided
 
@@ -276,13 +277,23 @@ when "none"
 when "elf.obj"
 	elf_machine = arg_keys.filter{_1[0] == "elf-machine"}[0]
 	elf_machine = (elf_machine != nil) ? elf_machine[1].to_i : 0
+	
+	elf_class = arg_keys.filter{_1[0] == "elf-class"}[0]
+	elf_class ||= ["elf-class", "64"]
+	elf_class = elf_class[1].to_i
+	
 	symbols = Kompiler::Wrappers::ELF.labels_to_symbols(labels)
-	out = Kompiler::Wrappers::ELF.wrap_obj(code, symbols, machine: elf_machine)
+	out = Kompiler::Wrappers::ELF.wrap_obj(code, symbols, machine: elf_machine, elf_class: elf_class)
 when "elf.exec"
 	elf_machine = arg_keys.filter{_1[0] == "elf-machine"}[0]
 	elf_machine = (elf_machine != nil) ? elf_machine[1].to_i : 0
+
+	elf_class = arg_keys.filter{_1[0] == "elf-class"}[0]
+	elf_class ||= ["elf-class", "64"]
+	elf_class = elf_class[1].to_i
+
 	symbols = Kompiler::Wrappers::ELF.labels_to_symbols(labels)
-	out = Kompiler::Wrappers::ELF.wrap_exec(code, symbols, machine: elf_machine)
+	out = Kompiler::Wrappers::ELF.wrap_exec(code, symbols, machine: elf_machine, elf_class: elf_class)
 when "mach-o.obj"
 	puts "Mach-O not yet implemented."
 	exit

data/lib/kompiler/wrappers/elf_wrapper.rb

@@ -28,7 +28,7 @@ module Kompiler
 			
 			sections, shstrndx = create_default_sections(code, symbols, elf_class: elf_class).values
 			
-			output = build(sections: sections, machine: e_machine, elf_class: elf_class, e_shstrndx: shstrndx, e_type: 1)
+			output = build(sections: sections, e_machine: e_machine, elf_class: elf_class, e_shstrndx: shstrndx, e_type: 1)
 			
 			output
 		end
@@ -40,14 +40,18 @@ module Kompiler
 		# Arguments:
 		# code - raw byte string
 		# options - a hash of configurable options:
+		#           machine   - a raw machine ID to fill in the e_machine field (default is 0)
 		#           elf_class - 32 for ELFClass32 or 64 for ELFClass64 (default is 64)
-		#           machine   - a raw machine ID to fill in the e_machine field
 		#           vaddr     - virtual address for the program and entry (default is 0x80000)
+		#           align     - alignment value for the load segment (default is 0x1000)
+		#           flags     - segment flags (default is 0b111, bits are in form 0bRWX)
 		def self.wrap_exec code, symbols, **options
 
 			elf_class = options[:elf_class] || 64
-			e_machine = options[:machine]
+			e_machine = options[:machine] || 0
 			vaddr = options[:vaddr] || 0x80000
+			align = options[:align] || 0x1000
+			flags = options[:flags] || 0b111
 
 			sections, shstrndx = create_default_sections(code, symbols, elf_class: elf_class).values
 
@@ -56,15 +60,15 @@ module Kompiler
 			segments = [
 				{
 					type: 1, # Loadable segment
-					flags: 7, # Execute, write, read permissions
+					flags: flags, # Execute, write, read permissions
 					vaddr: vaddr, # Virtual address of segment in memory
 					# content: code,
 					content_section_i: 1,
-					align: 4
+					align: align
 				},
 			]
 
-			output = build(sections: sections, segments: segments, machine: e_machine, elf_class: elf_class, e_type: 2, virtual_entry_address: vaddr, e_shstrndx: shstrndx)
+			output = build(sections: sections, segments: segments, e_machine: e_machine, elf_class: elf_class, e_type: 2, virtual_entry_address: vaddr, e_shstrndx: shstrndx)
 			
 			output
 		end
@@ -76,11 +80,19 @@ module Kompiler
 		def self.labels_to_symbols labels
 			out = []
 			labels.each do |name, value|
-				out << {name: name, value: value, type: 1, binding: 0}
+				out << {name: name, value: value, type: 0, binding: 0}
 			end
 			out
 		end
 
+		# Converts a values hash of name-value pairs into an array of symbols
+		def self.values_to_symbols values
+			out = []
+			values.each do |name, value|
+				out << {name: name, value: value, type: 0, binding: 0}
+			end
+		end
+
 
 		# Build ELF
 		# Builds an ELF from provided sections, segments, and other options
@@ -88,15 +100,42 @@ module Kompiler
 		# Arguments:
 		#  sections - ELF sections (structure below)
 		#  segments - ELF segments (structure below)
-		#  machine  - a raw machine ID for the ELF header
-		#  virtual_entry_address - the virtual entry address for the ELF header
-		#  elf_class - the ELF class (32 or 64)
-		#  e_shstrndx - the value for ELF header's e_shstrndx field (index of the section header string table section)
-		#  e_type - the value for ELF header's e_type field (e.g., 1 for relocatable, 3 for executable)
+		#  virtual_entry_address - the virtual entry address for the ELF header (default is 0)
+		#  elf_class - the ELF class (32 or 64) (default is 0)
+		#  e_machine  - a raw machine ID for the ELF header (default is 0)
+		#  e_shstrndx - the value for ELF header's e_shstrndx field (index of the section header string table section) (default is 0)
+		#  e_type - the value for ELF header's e_type field (e.g., 1 for relocatable, 3 for executable) (default is 0)
+		#  e_os_abi - the value for the ELF Identification header's osabi field (default is 0) (not used with elf_class = 32)
+		#  e_abi_version - the value for the ELF Identification header's abiversion field (default is 0) (not used with elf_class = 32)
+		#
+		# Section structure:
+		#  name_offset - section's name field value
+		#  type - section's type field value
+		#  flags - section's flags field value
+		#  addr - section's addr field value
+		#  link - section's link field value
+		#  info - section's info field value
+		#  addralign - section's addralign field value
+		#  entsize - section's entsize field value
+		#  content - section's content (offset and size will be computed automatically)  
+		#  segment_content_i - index of segment that contains this section's content (useful to remove repeated info and 'link' a section with a segment)
+		#  offset - if segment_content_i is present, an optional offset can be added to take only part of the segment's content (default is 0)
+		#  size - if segment_content_i is present, size can be provided optionally to take only part of the segment's content (default is 0)
 		#
-		def self.build sections: [], segments: [], machine: nil, virtual_entry_address: 0, elf_class: 64, e_shstrndx: 0, e_type: 0
+		# Segment structure:
+		#  type - segment's type field value
+		#  flags - segment's flags field value
+		#  vaddr - segment's vaddr field value (default is 0)
+		#  paddr - segment's paddr field value (default is value of vaddr)
+		#  vsize - segment's memsz / vsize field value (default is same as content.size)
+		#  align - segment's alignment value. This will also ensure that the segment's content is aligned to this boundary in the file
+		#  content - segment's content (offset and size will be computed automatically)
+		#  section_content_i - index of section that contaisn this segment's content (idea is same as section[:segment_content_i])
+		#  offset - idea same as section[:offset]
+		#  size - idea same as section[:size]
+		#
+		def self.build sections: [], segments: [], virtual_entry_address: 0, elf_class: 64, e_machine: 0, e_shstrndx: 0, e_type: 0, e_os_abi: 0, e_abi_version: 0
 
-			raise "Machine ID not specified for the ELF header." if machine == nil
 
 			case elf_class
 			when 64
@@ -158,7 +197,12 @@ module Kompiler
 			# EI_Version (current)
 			e_ident.bytes 1, elf_char
 
-			e_ident.align 16, "\0"
+			e_ident.bytes e_os_abi, 1 # OS_ABI
+			e_ident.bytes e_abi_version, 1 # ABI_VERSION
+			
+			e_ident.bytes [0] * 6 # Pad to 15
+
+			e_ident.bytes [16] # E_Ident size
 
 			elf_header.add e_ident
 
@@ -166,7 +210,7 @@ module Kompiler
 			elf_header.bytes e_type, elf_half
 
 			# E_Machine (input)
-			elf_header.bytes machine, elf_half
+			elf_header.bytes e_machine, elf_half
 
 			# E_version (current)
 			elf_header.bytes 1, elf_word
@@ -219,7 +263,8 @@ module Kompiler
 			
 			sections_content = PackedBytes.new
 			
-			sections.each_with_index do |section, section_i|
+			sections.each_with_index do |section, section_i|				
+			
 				if !section.keys.include?(:content)
 					section[:size] = 0
 					section[:offset] = 0
@@ -240,10 +285,11 @@ module Kompiler
 				section[:offset] = sections_content.result.bytesize + sections_contents_offset
 
 				matching_segments.each do |segment|
-					segment[:offset] = 0 if !segment.keys.include?(:offset)
-					segment[:offset] += section[:offset]
-					
-					segment[:size] = section[:size] if !segment.keys.include?(:size)
+					segment[:offset] ||= 0
+
+					segment[:size] ||= section[:size] - segment[:offset]
+
+					segment[:offset] += section[:offset]	
 				end
 
 				sections_content.add section[:content]
@@ -256,49 +302,54 @@ module Kompiler
 
 			segments.each_with_index do |segment, segment_i|
 
-				if !segment.keys.include?(:align)
-					segment[:align] = 1
-				end
+				segment[:align] ||= 1
 
-				if !segment.keys.include?(:vaddr)
-					segment[:vaddr] = 0
-				end
+				segment[:vaddr] ||= 0
 
-				if !segment.keys.include?(:paddr)
-					segment[:paddr] = segment[:vaddr]
-				end
+				segment[:paddr] ||= segment[:vaddr]
 
 				if segment.keys.include?(:content)
 					segment[:size] = segment[:content].bytesize
 				end
 
-				if !segment.keys.include?(:vsize)
-					segment[:vsize] = segment[:size]
-				end
+				segment[:vsize] ||= segment[:size]
+
 
 				if segment[:vaddr] % segment[:align] != 0
 					raise "Improper segment at index #{segment_i} - the virtual address is not aligned to the specified alignment boundary."
 				end
 
+				# If the segment uses :content, add the segment's content to the file and compute the offset
+				if !segment.keys.include?(:content_section_i)
 
-				if segment.keys.include? :content_section_i
-					next
-				end
-				
+					# ELF requires file_offset and vaddr to be a multiple of the alignment value
+					
+					file_offset = segments_contents_offset + segments_content.result.bytesize
 
-				# ELF requires file_offset and vaddr to be a multiple of the alignment value
-				
-				file_offset = segments_contents_offset + segments_content.result.bytesize
+					pad_amount = 0
+					if file_offset % segment[:align] != 0
+						pad_amount = segment[:align] - (file_offset % segment[:align])
+					end
+
+					segments_content.bytes "\0" * pad_amount
+
+					segment[:offset] = segments_content.result.bytesize + segments_contents_offset
+					segments_content.add segment[:content]
 
-				pad_amount = 0
-				if file_offset % segment[:align] != 0
-					pad_amount = segment[:align] - (file_offset % segment[:align])
 				end
 
-				segments_content.bytes "\0" * pad_amount
 
-				segment[:offset] = segments_content.result.bytesize + segments_contents_offset
-				segments_content.add segment[:content]
+				# If some sections depend on the segment, update their values
+				
+				matching_sections = sections.filter{_1[:segment_content_i] == segment_i}
+
+				matching_sections.each do |section|
+					section[:offset] ||= 0
+
+					section[:size] ||= segment[:size] - section[:offset]
+					
+					section[:offset] += segment[:offset]
+				end
 
 			end
 
@@ -324,15 +375,29 @@ module Kompiler
 
 			ph = PackedBytes.new
 
-			segments.each do |segment|
-				ph.bytes segment[:type], elf_word
-				ph.bytes segment[:flags], elf_word
-				ph.bytes segment[:offset], elf_off
-				ph.bytes segment[:vaddr], elf_addr
-				ph.bytes segment[:paddr], elf_addr
-				ph.bytes segment[:size], elf_xword
-				ph.bytes segment[:vsize], elf_xword
-				ph.bytes segment[:align], elf_xword
+			case elf_class
+			when 64
+				segments.each do |segment|
+					ph.bytes segment[:type], elf_word
+					ph.bytes segment[:flags], elf_word
+					ph.bytes segment[:offset], elf_off
+					ph.bytes segment[:vaddr], elf_addr
+					ph.bytes segment[:paddr], elf_addr
+					ph.bytes segment[:size], elf_xword
+					ph.bytes segment[:vsize], elf_xword
+					ph.bytes segment[:align], elf_xword
+				end
+			when 32
+				segments.each do |segment|
+					ph.bytes segment[:type], elf_word
+					ph.bytes segment[:offset], elf_off
+					ph.bytes segment[:vaddr], elf_addr
+					ph.bytes segment[:paddr], elf_addr
+					ph.bytes segment[:size], elf_word
+					ph.bytes segment[:vsize], elf_word
+					ph.bytes segment[:flags], elf_word
+					ph.bytes segment[:align], elf_word
+				end
 			end
 
 			file_content.add ph
@@ -398,101 +463,234 @@ module Kompiler
 					entsize: 0,
 					content: program_bytes,
 				},
-				{
-					name: ".symtab",
-					type: 2,
-					flags: 0,
-					addr: 0,
-					link: sym_strtab_section_index, # Index of string table used for symbol names
-					info: symbols.size + 1, # Index of first non-local symbol
-					addralign: 0,
-					entsize: symtab_ent_size,
-					content: "",
-				},
-				{
-					name: ".strtab",
-					type: 3,
-					flags: 0,
-					addr: 0,
-					link: 0,
-					info: 0,
-					addralign: 0,
-					entsize: 0,
-					content: "",
-				},
-				{
-					name: ".shstrtab",
-					type: 3,
-					flags: 0,
-					addr: 0,
-					link: 0,
-					info: 0,
-					addralign: 0,
-					entsize: 0,
-					content: "",
-				},
 			]
 
-			symtab = PackedBytes.new
 
-			# First section is all zeros
-			symtab.bytes [0] * symtab_ent_size
+			symbols.map! do |sym|
+				sym[:section_index] = sym[:section_index] || progbits_section_index
+				sym
+			end
+
+			symtab_section, sym_strtab_contents = create_symtab_section(symbols, link: sym_strtab_section_index, info: "first-non-local", elf_class: elf_class)
 
+			sections << symtab_section
 			
-			symtab_string_table_content = "\0".encode("ASCII")
+			sections << create_strtab_section(sym_strtab_contents, name: ".strtab", elf_class: elf_class)
 
-			symbols.each do |symbol|
+			
+			sections << create_strtab_section("\0", name: ".shstrtab", elf_class: elf_class)
 
-				if symbol.keys.include? :name
-					name_offset = symtab_string_table_content.bytesize
-					symtab_string_table_content << symbol[:name] + "\0"
+
+			sections.each_with_index do |section, section_i|
+				if section.keys.include? :name
+					section[:name_offset] = sections[sh_strtab_section_index][:content].bytesize
+					sections[sh_strtab_section_index][:content] << section[:name] + "\0"
 				else
-					name_offset = 0
+					section[:name_offset] = 0
 				end
+			end
+
+
+			return {sections: sections, shstrndx: sh_strtab_section_index}
+			
+		end
+
 
-				# name
-				symtab.bytes name_offset, elf_word
 
-				symbol_info = symbol[:type] | (symbol[:binding] << 4)
+		# Creates a section structure with type symtab, builds symbol entries and symbol string table contents
+		# Returns [symtab_section, sym_strtab_contents]
+		#
+		# Arguments:
+		#  symbols - an array of hashes with info about each symbol (structure below)
+		#  **options - additional options
+		#
+		# Options are:
+		#  elf_class - elf class, either 64 or 32 (default is 64)
+		#  name - the symtab section's name (default is .symtab)
+		#  link - the symtab section's link field value (default is 0)
+		#  info - the symtab section's info field value (default is 0)
+		#         set to "first-non-local" to auto-sort all symbols and
+		#         set info field to the index of the first non-local symbol
+		#  flags - the symtab section's flags field value (default is 0)
+		#
+		# Symbol hash structure:
+		#  :name - the symbol's name (optional)
+		#  :type - symbol type (0 - notype, 1 - object, 2 - func, 3 - section, 4 - file)
+		#  :binding - symbol binding (0 - local, 1 - global, 2 - weak)
+		#  :section_index - corresponding section's index (0 - undef, 0xfff1 - absolute, 0xfff2 - common block)
+		#  :value - the symbol's value
+		#  :size - the symbol's size (default is 0)
+		#
+		def self.create_symtab_section symbols, **options
+
+			elf_class = options[:elf_class] || 64
+
+			section_name = options[:name] || ".symtab"
+			section_link = options[:link] || 0
+			section_info = options[:info] || 0
+			section_flags = options[:flags] || 0
 
-				# info
-				symtab.bytes symbol_info, elf_char
+			# Check if the auto option was selected
+			if section_info == "first-non-local"
 
-				# other (must be zero)
-				symtab.bytes 0, elf_char
+				# Sort symbols for global symbols to come last
 
-				# section index of where the symbol is located
-				symtab.bytes progbits_section_index, elf_half
+				local_symbols = symbols.filter{_1[:binding] == 0}
+				non_local_symbols = symbols.filter{_1[:binding] != 0}
 
-				# symbol value
-				symtab.bytes symbol[:value], elf_addr
+				first_non_local_i = local_symbols.size
 
-				# symbol size
-				symbol_size = symbol[:size] || 0
-				symtab.bytes symbol_size, elf_xword
+				# Sort symbols for local ones to come first
+				symbols = local_symbols + non_local_symbols
+
+				# + 1 because the first symbol will be pre-forced to be all zeros and local
+				section_info = first_non_local_i + 1
+			end
+
+
+			case elf_class
+			when 64
+				elf_char = 1
+				elf_half = 2
+				elf_word = 4
+				elf_addr = 8
+				elf_xword = 8
+				symtab_ent_size = 24
+			when 32
+				elf_char = 1
+				elf_half = 2
+				elf_word = 4
+				elf_addr = 4
+				elf_xword = 4
+				symtab_ent_size = 16
 			end
 
-			sections[symtab_section_index][:content] = symtab.result
-			sections[sym_strtab_section_index][:content] = symtab_string_table_content
+			symtab_content = PackedBytes.new
+			sym_strtab_contents = "\0".encode "ASCII"
 
+			# First entry must be all zeros
+			symtab_content.bytes [0] * symtab_ent_size
 
-			sections_string_table_content = "\0"
+			case elf_class
+			when 64
+				symbols.each do |symbol|
+					if symbol.keys.include? :name
+						name_offset = sym_strtab_contents.bytesize
+						sym_strtab_contents << symbol[:name] + "\0"
+					else
+						name_offset = 0
+					end
 
-			sections.each_with_index do |section, section_i|
-				if section.keys.include? :name
-					section[:name_offset] = sections_string_table_content.bytesize
-					sections_string_table_content << section[:name] + "\0"
-				else
-					section[:name_offset] = 0
+					# name
+					symtab_content.bytes name_offset, elf_word
+
+					symbol_info = symbol[:type] | (symbol[:binding] << 4)
+					# info
+					symtab_content.bytes symbol_info, elf_char
+
+					# other
+					symtab_content.bytes 0, elf_char
+
+					# shndx
+					symtab_content.bytes symbol[:section_index], elf_half
+
+					# value
+					symtab_content.bytes symbol[:value], elf_addr
+
+					# size
+					symtab_content.bytes symbol[:size] || 0, elf_xword
+				end
+			when 32
+				symbols.each do |symbol|
+					if symbol.keys.include? :name
+						name_offset = sym_strtab_contents.bytesize
+						sym_strtab_contents << symbol[:name] + "\0"
+					else
+						name_offset = 0
+					end
+
+					# name
+					symtab_content.bytes name_offset, elf_word
+
+					# value
+					symtab_content.bytes symbol[:value], elf_addr
+
+					# size
+					symtab_content.bytes symbol[:size] || 0, elf_xword
+					
+					symbol_info = symbol[:type] | (symbol[:binding] << 4)
+					# info
+					symtab_content.bytes symbol_info, elf_char
+
+					# other
+					symtab_content.bytes 0, elf_char
+
+					# shndx
+					symtab_content.bytes symbol[:section_index], elf_half
 				end
 			end
 
-			sections[sh_strtab_section_index][:content] = sections_string_table_content
 
-			return {sections: sections, shstrndx: sh_strtab_section_index}
+			symtab_section = {
+				name: ".symtab",
+				type: 2,
+				flags: section_flags,
+				addr: 0,
+				link: section_link,
+				info: section_info,
+				addralign: 0,
+				entsize: symtab_ent_size,
+				content: symtab_content.result,
+			}
+
+			return symtab_section, sym_strtab_contents
 			
 		end
 
+
+		# Create string table section
+		# Creates a hash with information for a string table section
+		# 
+		# Arguments:
+		#  string_content - the string table's content
+		#  **options - additional options
+		#
+		# Options:
+		#  name - the section's name (default is nil)
+		#  info - the section's info field value (default is 0)
+		#  link - the section's link field value (default is 0)
+		#  flags - the section's flags field value (default is 0)
+		#  addr - the section's addr field value (default is 0)
+		#  addralign - the section's addralign field value (default is 0)
+		#  elf_class - ELF class 32 or 64 (not used)
+		#
+		def self.create_strtab_section string_content, **options
+			name = options[:name]
+			info = options[:info] || 0
+			link = options[:link] || 0
+			flags = options[:flags] || 0
+			addr = options[:addr] || 0
+			addralign = options[:addralign] || 0
+
+
+			section = {
+				type: 3,
+				info: info,
+				link: link,
+				flags: flags,
+				addr: addr,
+				addralign: addralign,
+				content: string_content,
+				entsize: 0,
+			}
+
+			section[:name] = name if name != nil
+
+			return section
+		end
+
+		
+
 	end # Kompiler::ELF
 	end # Kompiler::Wrappers
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kompiler
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Kyryl Shyshko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-02 00:00:00.000000000 Z
+date: 2025-04-04 00:00:00.000000000 Z
 dependencies: []
 description: 'Kompiler is a low-level, modular and extendable compiler for any architecture.
   By default Kompiler supports ARMv8-a, but other architecture extensions can be downloaded