kompiler 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90ed49bc46f0641a23f0d7d561489d4ec326e8f3bb933a638ed789831e9ee362
-  data.tar.gz: 9c0d4b1f795b9e7a2b73a145218a972854fdd8372808a6fb68b3c210899d2ad8
+  metadata.gz: 12bbbb642809ac234ac1cfdcd59b3d43362c0ba284a6286656fecc2cf5024e99
+  data.tar.gz: 86e653003489923b7a63bd24b0d6019b07fde08c10c8dc426357dca265b3445e
 SHA512:
-  metadata.gz: 8a18cb49c4740e3f5d86a074c75a87c90db0de718dad6ec2547b802d1acf70dd4a726fcc163ba6bf17f83b58c91e02a0e331f48b707a2ac6d80ac331f4c852fc
-  data.tar.gz: c54ac313fed9b03a22810678244e0809dc29f25c0974c2ded1251fac7e6d01f2c28f50a0844938532eda6d7ec90b78ddf8afb0634485662ef1246677c18bc5d5
+  metadata.gz: e729dfc9ee22702200ea082beef419bdbcbaa6bc2ba5a4cadbc2899f6442c6f65c163ec90675ce8d8e2fe41cd80e97cee445fb7386547e78f5569016bbba69ed
+  data.tar.gz: d88ba4f53b56086cae6e63f8308058f3f28735f8db671d122c3eecbd3270e5443a1945407b7e8e73b15859758897992f2183481f667282fea29ee57f47f2b494

data/bin/kompile

@@ -107,13 +107,15 @@ Available wrapping formats:
  none
  elf.obj
  elf.exec
- mach-o.obj  [not implemented yet]
+ mach-o.obj
  mach-o.exec [not implemented yet]
 
 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
+ --mach-o-archtype=<type>             Specifies the file architecture type to either 32 or 64 (default is 64)
 
 Available options:
  --help, -h                 Prints this information
@@ -260,7 +262,7 @@ code = File.binread(in_filename)
 
 detailed_out = Kompiler::CompilerFunctions.detailed_compile(code)
 
-# p detailed_out
+# pp detailed_out
 
 out = nil
 
@@ -276,18 +278,35 @@ 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
+	macho_cpu = arg_keys.filter{_1[0] == "mach-o-machine"}[0]
+	macho_cpu = (macho_cpu != nil) ? macho_cpu[1] : "0.0"
+	cputype, cpusubtype = macho_cpu.split(".").map(&:to_i)
+
+	arch_type = arg_keys.filter{_1[0] == "mach-o-archtype"}[0]
+	arch_type = (arch_type != nil) ? arch_type[1].to_i : 64
+
+	symbols = Kompiler::Wrappers::MachO.labels_to_symbols(labels)
+	out = Kompiler::Wrappers::MachO.wrap_obj(code, symbols, cputype: cputype, cpusubtype: cpusubtype, arch_type: arch_type)
 when "mach-o.exec"
-	puts "Mach-O not yet implemented."
+	puts "Mach-O executable not yet implemented."
 	exit
 end
 

data/lib/kompiler/directives.rb

@@ -519,6 +519,35 @@ end
 			
 			state[:line_i] += 1
 			
+			state
+		end
+	},
+	{
+		keyword: "info",
+		func: lambda do |operands, state|
+
+			begin
+				info_name = operands[0][:definition]
+				info_value = operands[1][:definition]
+			rescue
+				puts "Incorrect use of the \".info\" directive."
+			end
+			
+
+			state[:line_i] += 1
+
+			context_info = {}
+
+			context_info[:current_address] = state[:current_address]
+
+			context_info[:line_i] = state[:line_i]
+
+			state[:extra_state][:info_entries] ||= Hash.new
+
+			state[:extra_state][:info_entries][info_name] ||= Array.new
+
+			state[:extra_state][:info_entries][info_name] << {context_info: context_info, input_str: info_value, input_full: operands[1]}
+
 			state
 		end
 	}

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
 

data/lib/kompiler/wrappers/macho_wrapper.rb

@@ -0,0 +1,441 @@
+require 'kompiler/wrappers/packed_bytes'
+
+
+module Kompiler
+
+module Wrappers
+
+
+module MachO
+
+	MH_MAGIC_32 = 0xfeedface
+	MH_MAGIC_64 = 0xfeedfacf
+
+
+	def self.wrap_obj code, symbols, arch_type: 64, cputype: 0, cpusubtype: 0
+
+		segments = [
+			{
+				name: "__TEXT",
+				vaddr: 0,
+				vsize: code.bytesize,
+				maxprot: 7,
+				initprot: 7,
+				flags: 0,
+
+				sections: [
+					{
+						name: "__text",
+						vaddr: 0,
+						vsize: 0,
+						align: 1,
+						flags: 0,
+						content: code,
+					},
+				]
+			}
+		]
+
+
+		output = MachO.build(segments: segments, symbols: symbols, arch_type: arch_type, cputype: cputype, cpusubtype: cpusubtype, filetype: 1, align_section_contents: false)
+
+		return output
+
+	end
+
+
+	
+
+
+
+	
+	def self.build_macho_header arch_type: 64, cputype: 0, cpusubtype: 0, filetype: 0, ncmds: 0, sizeofcmds: 0, flags: 0
+
+		macho_header = PackedBytes.new
+
+		case arch_type
+		when 64
+			macho_header.uint32 MH_MAGIC_64
+		when 32
+			macho_header.uint32 MH_MAGIC_32
+		end
+
+		macho_header.uint32 cputype
+		macho_header.uint32 cpusubtype
+
+		macho_header.uint32 filetype
+
+		macho_header.uint32 ncmds
+
+		macho_header.uint32 sizeofcmds
+		
+		macho_header.uint32 flags
+
+		if arch_type == 64
+			# Reserved field in 64-bit
+			macho_header.uint32 0
+		end
+
+		return macho_header
+	end
+
+
+	# Build a Mach-O file from the input segments, symbols and other pre-built load commands
+	# 
+	# Arguments:
+	#  segments - list of segments to include in the file (structure below)
+	#  symbols - list of symbols to be included inside a single symtab (structure below)
+	#  prebuilt_lcs - a list of other already built load commands (strings) to be included in the file
+	#  arch_type - architecture type, either 32- or 64-bit (default is 64)
+	#  cputype - Mach-O header cputype field
+	#  cpusubtype - Mach-O header cpusubtype field
+	#  filetype - Mach-O file type
+	#  align_section_contents - specifies whether to align the contents of each section to its alignment boundary (default is false)
+	#
+	# Segment structure:
+	#  name - the segment's name
+	#  vaddr - virtual load address of the segment
+	#  vsize - virtual size in memory of the segment
+	#  maxprot - Mach-O segment maxprot field
+	#  initprot - Mach-O segment initprot field
+	#  flags - Mach-O segment flags field
+	#  sections - a list of segment's section (structure below)
+	#
+	# Segment section structure:
+	#  name - the section's name
+	#  vaddr - virtual load address of section
+	#  vsize - virtual size in memory of the section
+	#  align - section's byte alignment
+	#  flags - section's flags
+	#  content - section's content
+	#
+	# Symbol structure:
+	#  name - symbol's name
+	#  value - symbol's value
+	#  type - symbol's type field value
+	#  sect - symbol's sect field value
+	#  desc - symbol's desc field value
+	# 
+	def self.build segments: [], symbols: [], prebuilt_lcs: [], arch_type: 64, cputype: 0, cpusubtype: 0, filetype: 0, align_section_contents: false
+
+		file_content = PackedBytes.new
+
+		case arch_type
+		when 32
+			flexval_size = 4
+		when 64
+			flexval_size = 8
+		end
+
+		segment_entry_size = 4 * 2 + 16 + flexval_size * 4 + 4 * 2 + 4 * 2
+
+		section_entry_size = 16 + 16 + flexval_size * 2 + 7 * 4
+		
+		if arch_type == 64
+			section_entry_size += 4 # one more reserved field for 64-bit
+		end
+
+		symtab_entry_size = 4 * 6
+
+
+		n_sections = 1
+
+		prebuilt_lcs_size = prebuilt_lcs.map(&:bytesize).sum
+		
+		cmds_size = segment_entry_size + section_entry_size * n_sections + symtab_entry_size + prebuilt_lcs_size
+		
+
+		n_cmds = segments.size + 1 + prebuilt_lcs.size # One segment (with possibly multiple sections), one symtab
+		
+		macho_header = build_macho_header(
+			arch_type: 64,
+			cputype: cputype,
+			cpusubtype: cpusubtype,
+			filetype: filetype,
+			ncmds: n_cmds,
+			sizeofcmds: cmds_size,
+			flags: 0
+		)
+		
+
+		file_content.add macho_header
+
+
+
+		# Calculate where all of the content can be placed
+		contents_offset = cmds_size + file_content.result.bytesize
+		
+
+		contents = ""
+		
+
+
+		segments.each do |segment|
+
+			raise "Segment name is larger than 16 characters" if segment[:name].bytesize > 16
+
+			start_size = contents.bytesize
+
+			segment[:sections].each_with_index do |section, section_i|
+
+				raise "Section name \"#{section[:name]}\" is larger than 16 characters" if section[:name].bytesize > 16
+
+				section[:align] ||= 1
+
+				raise "Section alignment value cannot be 0" if section[:align] == 0
+
+				sec_offset = contents_offset + contents.bytesize
+
+				pad_amount = 0
+				if (sec_offset % section[:align] != 0) && align_sections
+					pad_amount = section[:align] - (sec_offset % section[:align])
+				end
+
+				sec_offset += pad_amount
+				contents << "\0" * pad_amount
+
+				section[:file_offset] = sec_offset
+
+				if section_i == 0
+					segment[:file_offset] = sec_offset
+					start_size = contents.bytesize
+				end
+
+				contents << section[:content]
+
+				section[:vaddr] ||= 0
+				section[:vsize] ||= section[:content].bytesize
+			end
+
+			end_size = contents.bytesize
+
+			segment[:file_offset] ||= 0
+			segment[:filesize] = end_size - start_size
+
+			segment[:vaddr] ||= 0
+			segment[:vsize] ||= segment[:filesize]
+			
+			segment[:flags] ||= 0
+
+			segment[:maxprot] ||= 0
+			segment[:initprot] ||= 0
+		end
+
+
+		
+
+		symtab_contents = PackedBytes.new
+		
+		sym_strtab_contents = "\0"
+
+		symbols.each do |symbol|
+			if symbol.keys.include? :name
+				symbol[:name_offset] = sym_strtab_contents.bytesize
+				sym_strtab_contents << symbol[:name] + "\0"
+			else
+				symbol[:name_offset] = 0
+			end
+
+			symtab_contents.uint32 symbol[:name_offset]
+			symtab_contents.uint8 symbol[:type]
+			symtab_contents.uint8 symbol[:sect]
+			symtab_contents.uint16 symbol[:desc]
+			symtab_contents.bytes symbol[:value], flexval_size
+		end
+
+
+		symtab_offset = contents.bytesize + contents_offset
+		symtab_align = 8
+
+		if symtab_offset % symtab_align != 0
+			pad = (symtab_align - (symtab_offset % symtab_align))
+			contents << "\0" * pad
+			symtab_offset += pad
+		end
+
+		contents << symtab_contents.result
+
+		sym_strtab_offset = contents.bytesize + contents_offset
+		
+		contents << sym_strtab_contents
+
+
+
+		load_commands = PackedBytes.new
+
+
+		segments.each do |segment|
+
+			case arch_type
+			when 64
+				load_commands.uint32 0x19 # LC_SEGMENT_64
+			when 32
+				load_commands.uint32 0x1 # LC_SEGMENT
+			end
+
+			load_commands.uint32 segment_entry_size + section_entry_size * segment[:sections].size
+
+			load_commands.bytes segment[:name] + "\0" * (16 - segment[:name].bytesize)
+
+			load_commands.bytes segment[:vaddr], flexval_size
+			load_commands.bytes segment[:vsize], flexval_size
+
+			load_commands.bytes segment[:file_offset], flexval_size
+			load_commands.bytes segment[:filesize], flexval_size
+
+			load_commands.uint32 segment[:maxprot]
+			load_commands.uint32 segment[:initprot]
+
+			load_commands.uint32 segment[:sections].size
+
+			load_commands.uint32 segment[:flags]
+
+
+
+			segment[:sections].each do |section|
+
+				load_commands.bytes section[:name] + "\0" * (16 - section[:name].bytesize)
+				load_commands.bytes segment[:name] + "\0" * (16 - segment[:name].bytesize)
+
+				load_commands.bytes section[:vaddr], flexval_size
+				load_commands.bytes section[:vsize], flexval_size
+
+				load_commands.uint32 section[:file_offset]
+				load_commands.uint32 section[:align]
+
+				load_commands.uint32 0 # reloff
+				load_commands.uint32 0 # nreloc
+
+				load_commands.uint32 section[:flags]
+
+				load_commands.uint32 0 # reserved 1
+				load_commands.uint32 0 # reserved 2
+
+				if arch_type == 64
+					load_commands.uint32 0 # reserved 3 (only in 64-bit)
+				end
+				
+			end
+		end
+		
+
+
+		# Symtab load command
+
+		load_commands.uint32 0x2 # LC_SYMTAB
+		load_commands.uint32 symtab_entry_size
+
+		load_commands.uint32 symtab_offset
+		load_commands.uint32 symbols.size
+
+		load_commands.uint32 sym_strtab_offset
+		load_commands.uint32 sym_strtab_contents.bytesize
+
+
+		load_commands.add prebuilt_lcs
+
+
+		file_content.add load_commands
+
+
+		file_content.add contents
+		
+
+		return file_content.result
+		
+	end
+
+
+	# Converts a hash of label name-address pairs into section symbols suitable for the MachO.build method
+	#
+	# Arguments:
+	#  labels - the hash of labels
+	#  section_index - index of the section the symbols belong to (default is 1)
+	#  external - specifies if the label is external or not (default is false)
+	#  private_external - specifies if the label is private external or not (default is false)
+	#  debug_entry - specifies if the label is a debug entry or not (default is false)
+	def self.labels_to_symbols labels, 
+		out = []
+		labels.each do |name, value|
+			out << create_symbol(name: name, value: value, type: :sect, external: false, section_number: 1)
+		end
+		return out
+	end
+
+
+	# Creates a symbol from input information suitable for the MachO.build method
+	#
+	# Arguments:
+	#  name - the symbol's name
+	#  value - the symbol's value
+	#  type - the symbol's type: :undef, :abs, :sect, :prebound, :indirect (default is :sect)
+	#  private_external - specifies whether the symbol is private external (default is false)
+	#  external - specifies whether the symbol is external (default is false)
+	#  debug_entry - specifies whether the symbol is a debugging entry (default is false)
+	#  options - options depending on the symbol's type
+	#
+	# Type == :sect options:
+	#  section_number - section number the symbol is defined in
+	#  
+	def self.create_symbol name: nil, value: nil, type: :sect, private_external: false, external: false, debug_entry: false, **options
+
+		raise "No name provided for the symbol" if name == nil
+		raise "No value provided for the symbol" if value == nil
+
+		symbol = {name: name, value: value}
+
+		type_encodings = {undef: 0x0, abs: 0x2, sect: 0xe, prebound: 0xc, indirect: 0xa}
+		encoded_type = type_encodings[type]
+
+		raise "Unknown symbol type \"#{type}\" - must be :undef, :abs, :sect, :prebound, or :indirect." if encoded_type == nil
+		
+
+		pext_bit = 0x0
+		if private_external == true
+			pext_bit = 0x10
+		end
+
+		ext_bit = 0x0
+		if external == true
+			ext_bit = 0x1
+		end
+
+		debug_entry_bit = 0x0
+		if debug_entry == true
+			debug_entry_bit = 0xe
+		end
+
+		type_field = encoded_type | pext_bit | ext_bit | debug_entry_bit
+
+		symbol[:type] = type_field
+
+
+		case type
+		when :undef
+			symbol[:sect] = 0
+		when :abs
+			symbol[:sect] = 0
+		when :sect
+			section_number = options[:section_number] || 0
+			raise "Section number too high - maximum is 255." if section_number > 255
+			symbol[:sect] = section_number
+		when :prebound
+			symbol[:sect] = 0
+		when :indirect
+			symbol[:sect] = 0
+		end
+
+		symbol[:desc] = 0
+
+		return symbol
+	end
+
+
+
+end # Kompiler::Wrappers::MachO
+
+end # Kompiler::Wrappers
+
+end # Kompiler
+
+

data/lib/kompiler/wrappers.rb

@@ -1 +1,2 @@
 require 'kompiler/wrappers/elf_wrapper'
+require 'kompiler/wrappers/macho_wrapper'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kompiler
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Kyryl Shyshko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-02 00:00:00.000000000 Z
+date: 2025-04-06 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
@@ -42,6 +42,7 @@ files:
 - lib/kompiler/parsers.rb
 - lib/kompiler/wrappers.rb
 - lib/kompiler/wrappers/elf_wrapper.rb
+- lib/kompiler/wrappers/macho_wrapper.rb
 - lib/kompiler/wrappers/packed_bytes.rb
 homepage: https://github.com/kyryloshy/kompiler
 licenses: