kompiler 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12bbbb642809ac234ac1cfdcd59b3d43362c0ba284a6286656fecc2cf5024e99
-  data.tar.gz: 86e653003489923b7a63bd24b0d6019b07fde08c10c8dc426357dca265b3445e
+  metadata.gz: f5938bafe84031bb6dfb99ab6452d66fb1da892a42520e5e05c274e2b89f0b73
+  data.tar.gz: 8d80c58a6d2b689fbd3bfcd69f780cb2aa258c0f02d5b905c0b16b7d1b2c8a12
 SHA512:
-  metadata.gz: e729dfc9ee22702200ea082beef419bdbcbaa6bc2ba5a4cadbc2899f6442c6f65c163ec90675ce8d8e2fe41cd80e97cee445fb7386547e78f5569016bbba69ed
-  data.tar.gz: d88ba4f53b56086cae6e63f8308058f3f28735f8db671d122c3eecbd3270e5443a1945407b7e8e73b15859758897992f2183481f667282fea29ee57f47f2b494
+  metadata.gz: e79f4af903656d29d7d2a4b9b5b1c1e75f7bc10461d4a1e203d68b98c70420d920e13e651e263469a679e361349e7b4106b519a3712efa5185d5124cbe71c1ed
+  data.tar.gz: b8065b466b2b5bca9234b7ba8fd00a5560914cc819cfa9c973884f5c489eed1d797d1eb1d633a47570629133c616caedff3ce6743d69502c7069715d1c0ae1ec

data/bin/kompile

@@ -15,7 +15,7 @@
 # limitations under the License.
 
 require 'kompiler'
-
+require 'fileutils'
 
 arg_string = ARGV.join(" ")
 
@@ -108,20 +108,27 @@ Available wrapping formats:
  elf.obj
  elf.exec
  mach-o.obj
- mach-o.exec [not implemented yet]
-
+ mach-o.exec
+ 
 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)
+ --exec-type=<type>                   Used with --wrap=mach-o.exec. Specifies whether the executable is
+                                      statically (static) or dynamically (dylink) linked (default is dylink)
+ --mach-o-threadstate=<type>          Used with --wrap=mach-o.exec and --exec-type=static. Specifies which
+                                      thread state type to use (arm64, arm32, x86-64 or x86-32)
+ --codesign=<bool>                    Used with --wrap=mach-o.*. Specifies whether to add a basic
+                                      code signature to the Mach-O file (default is false)
 
 Available options:
  --help, -h                 Prints this information
  --list-architectures       Lists available architectures
  --list-instructions [arch] Lists available instructions for the specified architecture
  --list-registers [arch]    Lists available registers for the specified architecture
+ --list-lexis               Lists available lexis entries
 """
 exit # Exit
 end
@@ -141,14 +148,18 @@ end
 if arg_opts == ["list-instructions"]
 	arch_name = arg_words[0] || "armv8a"
 	Kompiler::ArchManager.load_all_entries()
-	arch = Kompiler::ArchManager.get_arch(arch_name)
+	Kompiler::ArchManager.load_arch arch_name
 
-	require arch[:include_path]
+	Kompiler::Architecture.instructions.each do |instruction|
+		print instruction[:keyword]
+
+		print " "
+
+		puts instruction[:operands].map{"<" + (_1[:name] || _1[:type] || "") + ">"}.join(" ")
+
+		puts instruction[:description]
 
-	Kompiler::Architecture.instructions.each do |instr|
-		puts "#{instr[:keyword]} (#{instr[:operands].size} operands): #{instr[:name]}"
-		puts instr[:description]
-		puts
+		print "\n"
 	end
 
 	exit
@@ -235,6 +246,7 @@ else
 	arch_name = "armv8a"
 end
 
+
 # Load all the architecture entries
 
 Kompiler::ArchManager.load_all_entries()
@@ -272,44 +284,139 @@ labels = detailed_out[:labels]
 labels.delete "here"
 
 
+def get_number str
+	bool, val = Kompiler::Parsers.check_immediate_operand(str)
+	return (bool == false) ? nil : val
+end
+
+
+def get_arg_key arg_keys, key, default_value=0
+	filtered = arg_keys.filter{_1[0] == key}[0]
+	value = (filtered != nil) ? filtered[1] : default_value
+	return value
+end
+
+
+class String
+	def to_num
+		status, val = Kompiler::Parsers.check_immediate_operand(self)
+		return (status == false) ? nil : val[:value]
+	end
+end
+
+
+add_exec_permission = false
+
+
 case wrap_opt
 when "none"
 	out = code
 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
+	elf_machine = get_arg_key(arg_keys, "elf-machine", "0").to_num
+	elf_class = get_arg_key(arg_keys, "elf-class", "64").to_num
+
+	if ![32, 64].include?(elf_class)
+		puts "kompile: Invalid ELF class specified."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
 	
 	symbols = Kompiler::Wrappers::ELF.labels_to_symbols(labels)
 	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
+	vaddr = 0x80000
 
-	elf_class = arg_keys.filter{_1[0] == "elf-class"}[0]
-	elf_class ||= ["elf-class", "64"]
-	elf_class = elf_class[1].to_i
+	elf_machine = get_arg_key(arg_keys, "elf-machine", "0").to_num
+	elf_class = get_arg_key(arg_keys, "elf-class", "64").to_num
 
-	symbols = Kompiler::Wrappers::ELF.labels_to_symbols(labels)
-	out = Kompiler::Wrappers::ELF.wrap_exec(code, symbols, machine: elf_machine, elf_class: elf_class)
+	if ![32, 64].include?(elf_class)
+		puts "kompile: Invalid ELF class specified."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
+
+
+	symbols = Kompiler::Wrappers::ELF.labels_to_symbols(labels, vaddr: vaddr)
+	out = Kompiler::Wrappers::ELF.wrap_exec(code, symbols, machine: elf_machine, elf_class: elf_class, vaddr: vaddr)
+	
+	add_exec_permission = true
+	
 when "mach-o.obj"
-	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)
+	macho_cpu = get_arg_key(arg_keys, "mach-o-machine", "0.0")
+	cputype, cpusubtype = macho_cpu.split(".").map(&:to_num)
+
+	if [cputype, cpusubtype].include? nil
+		puts "kompile: Invalid Mach-O machine specified."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
 
-	arch_type = arg_keys.filter{_1[0] == "mach-o-archtype"}[0]
-	arch_type = (arch_type != nil) ? arch_type[1].to_i : 64
+	arch_type = get_arg_key(arg_keys, "mach-o-archtype", "64").to_num
+
+	codesign = get_arg_key(arg_keys, "codesign", "false")
+	if !["true", "false"].include?(codesign)
+		puts "kompile: Invalid --codesign value."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
+
+	codesign = (codesign == "true")
 
 	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 executable not yet implemented."
-	exit
+	macho_cpu = get_arg_key(arg_keys, "mach-o-machine", "0.0")
+	cputype, cpusubtype = macho_cpu.split(".").map(&:to_num)
+
+	if [cputype, cpusubtype].include? nil
+		puts "kompile: Invalid Mach-O machine specified."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
+
+	arch_type = get_arg_key(arg_keys, "mach-o-archtype", "64").to_num
+
+	exec_type = get_arg_key(arg_keys, "exec-type", "dylink")
+
+
+	codesign = get_arg_key(arg_keys, "codesign", "false")
+	if !["true", "false"].include?(codesign)
+		puts "kompile: Invalid --codesign value."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
+
+	codesign = (codesign == "true")
+
+
+	case exec_type
+	when "dylink"
+		symbols = Kompiler::Wrappers::MachO.labels_to_symbols(labels)
+		out = Kompiler::Wrappers::MachO.wrap_exec_dylink(code, symbols, cputype: cputype, cpusubtype: cpusubtype, arch_type: arch_type, codesign: codesign)
+	when "static"
+		symbols = Kompiler::Wrappers::MachO.labels_to_symbols(labels)
+
+		thread_state_arch = get_arg_key(arg_keys, "mach-o-threadstate", "arm64")
+
+		entry_address = 0x1000000
+
+		thread_state = Kompiler::Wrappers::MachO.build_thread_state arch: thread_state_arch, entry_address: 0x1000000, stack_pointer: 0
+		
+		out = Kompiler::Wrappers::MachO.wrap_exec_static(code, symbols, cputype: cputype, cpusubtype: cpusubtype, arch_type: arch_type, thread_state: thread_state, codesign: codesign, virtual_entry_address: entry_address)
+
+	else
+		puts "kompile: Invalid Mach-O executable type specified."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
+	
+	add_exec_permission = true
 end
 
 
 File.binwrite out_filename, out
 
+if add_exec_permission
+	FileUtils.chmod "+x", out_filename
+end
+

data/lib/kompiler/directives.rb

@@ -13,6 +13,8 @@
 #                     If false, operands will be a raw string containing the string after the keyword.
 #
 
+require 'securerandom'
+
 
 module Kompiler
 
@@ -250,7 +252,7 @@ end
 			state[:line_i] += 1
 
 			# Insert the lines at the correct place
-			state[:lines] = state[:lines][0...state[:line_i]] + total_load_lines + state[:lines][state[:line_i]..]
+			state[:lines] = state[:lines][0...state[:line_i]] + total_load_lines + state[:lines][state[:line_i]..]		
 
 			state
 		end
@@ -415,7 +417,7 @@ end
 					end
 					
 					# Skip string definitions
-					if ['"', "'"].include? line[start_i]
+					if Kompiler::Config.string_delimiters.include? line[start_i]
 						str, parsed_length = Kompiler::Parsers.parse_str line[start_i..]
 						start_i += parsed_length
 						next
@@ -515,10 +517,200 @@ end
 				line_i += build_lines.size
 			end			
 			
-			state[:lines] = state[:lines][...state[:line_i]] + scan_lines
+			state[:lines] = state[:lines][...(state[:line_i] + def_lines.size + 2)] + scan_lines
 			
-			state[:line_i] += 1
+			state[:line_i] += def_lines.size + 2
+				
+			state
+		end
+	},
+	{
+		keyword: "isomacro",
+		collect_operands: false,
+		func: lambda do |_, state|
+			line_i = state[:line_i]
+			
+			def_line = state[:lines][line_i]
+			
+			# First: collect the part after ".macro"
+			
+			char_i = 0
+			# Skip the whitespace before .macro
+			while char_i < def_line.size && Kompiler::Config.whitespace_chars.include?(def_line[char_i])
+				char_i += 1
+			end
+			# Skip the .macro
+			while char_i < def_line.size && Kompiler::Config.keyword_chars.include?(def_line[char_i])
+				char_i += 1
+			end
+			# Skip the whitespace after .macro
+			while char_i < def_line.size && Kompiler::Config.whitespace_chars.include?(def_line[char_i])
+				char_i += 1
+			end
+			
+			# If the end of the line was reached, throw an error
+			raise "Incorrect .isomacro definition" if char_i == def_line.size
+			
+			# Now char_i contains the first index of the text after .macro
+			
+			macro_def = def_line[char_i..]
+			
+			# Second: extract the macro's name
+			
+			macro_name = ""			
+			
+			while char_i < def_line.size && Kompiler::Config.keyword_chars.include?(def_line[char_i])
+				macro_name << def_line[char_i]
+				char_i += 1
+			end
+			
+			# Third: extract the operand names (code taken from parse_instruction_line in parsers.rb)
+			
+			arg_names = Kompiler::Parsers.extract_instruction_operands(def_line[char_i..])
+			
+			# Make sure that the arg names are unique
+			raise "Macro definition error - arguments cannot have the same name: Program build not possible" if arg_names.size != arg_names.uniq.size
+			
+			# Extract the macro inside definition
+			
+			line_i = state[:line_i] + 1
+			def_lines = []
+			
+			whitespace_regexp = /[#{Kompiler::Config.whitespace_chars.join("|")}]*/
+			
+			endmacro_regexp = /\A#{whitespace_regexp}\.?endisomacro#{whitespace_regexp}\z/
+			
+			while line_i < state[:lines].size
+				break if state[:lines][line_i].match? endmacro_regexp # Check if it's an end macro instruction
+				def_lines << state[:lines][line_i]
+				line_i += 1
+			end
+			
+			
+			# Find insert indexes for each argument
+			arg_insert_locations = arg_names.map{|arg_name| [arg_name, []]}.to_h
 			
+			def_lines.each_with_index do |line, line_i|
+				
+				start_i = 0
+				
+				# Loop through each character starting position
+				while start_i < line.size					
+					
+					# Skip whitespace characters
+					if Kompiler::Config.whitespace_chars.include?(line[start_i])
+						start_i += 1
+						next
+					end
+					
+					# Skip string definitions
+					if Kompiler::Config.string_delimiters.include? line[start_i]
+						str, parsed_length = Kompiler::Parsers.parse_str line[start_i..]
+						start_i += parsed_length
+						next
+					end
+					
+					cut_line = line[start_i..]
+					
+					arg_found = false
+					
+					# Check if one of the argument names works
+					arg_names.each do |arg_name|
+						next if !cut_line.start_with?(arg_name) # Skip the argument if the line doesn't begin with it
+						next if Kompiler::Config.keyword_chars.include?(cut_line[arg_name.size]) # Skip if the argument is a partial word. So, for the argument 'arg', this will skip in the case of 'arg1'
+						# Here if the argument name should be replaced with the contents
+						arg_found = true # Indicate that a replacement was found						
+						
+						arg_insert_locations[arg_name] << [line_i, start_i] # Add the insert location to the list
+						
+						# start_i += arg_name.size
+						def_lines[line_i] = def_lines[line_i][...start_i] + (def_lines[line_i][(start_i+arg_name.size)..] || "")
+						line = def_lines[line_i]
+						
+						break # Skip the arguments loop
+					end
+					
+					# Check if an argument was found
+					# If not, skip the text until the next whitespace character
+					if !arg_found
+						while start_i < line.size && Kompiler::Config.keyword_chars.include?(line[start_i])
+							start_i += 1
+						end
+						start_i += 1 # Move one more character
+					end
+					
+				end
+				
+			end
+			
+			state[:extra_state][:isomacros] = Array.new if !state[:extra_state].keys.include?(:macros)
+			
+			state[:extra_state][:isomacros] << {name: macro_name, args: arg_names, def_lines: def_lines, arg_insert_locations: arg_insert_locations}
+			
+			
+			# Scan the lines after the macro for the macro call and replace it with the macro definition
+			
+			scan_lines = state[:lines][(state[:line_i] + def_lines.size + 1 + 1)..]
+			
+			line_i = 0
+			
+			# Re-group argument insert locations by line -> [index, arg index]			
+			
+			arg_insert_locations_regrouped = def_lines.size.times.map{[]}
+			
+			arg_insert_locations.each do |arg_name, insert_locations|
+				insert_locations.each do |line_i, char_i|
+					arg_insert_locations_regrouped[line_i] << [char_i, arg_names.index(arg_name)]
+				end
+			end
+			
+			
+			while line_i < scan_lines.size
+				keyword, operands = Kompiler::Parsers.extract_instruction_parts(scan_lines[line_i])
+				
+				# If parsing failed, move on to the next line
+				if keyword == false
+					line_i += 1
+					next
+				end
+				
+				# If the keyword isn't the macro's name, skip the line
+				if keyword != macro_name
+					line_i += 1
+					next
+				end
+				
+				# Here when the keyword matches the macro name
+				
+				# Check that the number of operands is correct
+				if operands.size != arg_names.size
+					raise "Incorrect use of the \"#{macro_name}\" macro - #{arg_names.size} operands expected, but #{operands.size} were given: Program build not possible."
+				end
+				
+				# Build the replacement lines for the macro call
+				build_lines = def_lines.map{|line| line.dup} # Copying strings inside array, because array.dup doesn't work for elements
+				
+				arg_insert_locations_regrouped.each_with_index do |locations, line_i|
+					# Sort the locations by the insert character from largest to smallest, so that the inserts are made from end to start
+					locations.sort_by{|el| el[0]}.reverse.each do |char_i, arg_index|
+						build_lines[line_i].insert char_i, operands[arg_index]
+					end
+				end
+				
+				build_lines.insert 0, ".namespace macro.#{macro_name}.#{SecureRandom.uuid.gsub('-', '')}"
+				build_lines << ".endnamespace"
+				
+				# Replace the macro call with the built lines
+				scan_lines = scan_lines[...line_i] + build_lines + scan_lines[(line_i + 1)..]
+				
+				# Skip the inserted macro
+				line_i += build_lines.size
+			end			
+			
+			state[:lines] = state[:lines][...(state[:line_i] + def_lines.size + 2)] + scan_lines
+			
+			state[:line_i] += def_lines.size + 2
+				
 			state
 		end
 	},
@@ -530,7 +722,7 @@ end
 				info_name = operands[0][:definition]
 				info_value = operands[1][:definition]
 			rescue
-				puts "Incorrect use of the \".info\" directive."
+				raise "Incorrect use of the \".info\" directive."
 			end
 			
 
@@ -548,6 +740,170 @@ end
 
 			state[:extra_state][:info_entries][info_name] << {context_info: context_info, input_str: info_value, input_full: operands[1]}
 
+			state
+		end
+	},
+	{
+		keyword: "namespace",
+		func: lambda do |operands, state|
+
+			raise "Incorrect use of the \".namespace\" directive" if operands.size != 1
+
+			namespace_name = operands[0][:definition]
+			
+
+			namespace_lines = []
+
+			line_i = state[:line_i] + 1
+
+			whitespace_regexp = /[#{Kompiler::Config.whitespace_chars.join("|")}]*/
+			end_namespace_regexp = /\A#{whitespace_regexp}\.?endnamespace#{whitespace_regexp}\z/
+
+			start_namespace_regexp = /\A#{whitespace_regexp}\.?namespace/
+
+			namespace_level = 1
+
+			while line_i < state[:lines].size
+				if state[:lines][line_i].match?(end_namespace_regexp)
+					namespace_level -= 1
+				end
+				break if namespace_level == 0
+
+				# Indicates whether a line should be looked at and changed based on whether it's on the first level
+				line_change = namespace_level == 1
+
+				namespace_lines << [line_change, state[:lines][line_i]]
+
+				if state[:lines][line_i].match?(start_namespace_regexp)
+					namespace_level += 1
+				end
+
+				line_i += 1
+			end
+
+
+			raise "\".endnamespace\" was not found for \".namespace\"" if line_i == state[:lines].size
+
+	
+			# Collect the definitions that happen inside of the namespace
+			defs = []
+
+			namespace_lines.each do |line_info|
+
+				line_change, line = line_info
+
+				next if !line_change
+
+				keyword, operands = Kompiler::Parsers.extract_instruction_parts(line)
+
+				is_instruction = false
+				Kompiler::Architecture.instructions.each do |instr|
+					is_instruction = instr[:keyword] == keyword
+					break if is_instruction
+				end
+
+				next if is_instruction
+
+				keyword = "." + keyword if keyword[0] != "."
+
+
+				case keyword
+				when ".value"
+					value_name = operands[0]
+					defs << {type: "value", name: value_name}
+				when ".macro"
+					# Remove the ".macro"
+					macro_def = line.split(keyword)[1..].join(keyword)
+					macro_name, _ = Kompiler::Parsers.extract_instruction_parts(macro_def)
+					defs << {type: "macro", name: macro_name}
+				when ".label"
+					label_name = operands[0]
+					defs << {type: "label", name: label_name}
+				when ".namespace"
+					inside_namespace_name = operands[0]
+					defs << {type: "namespace", name: inside_namespace_name}
+				end
+
+			end
+			
+
+			# Create replacements for each definition inside of the namespace
+			
+			replacements = defs.map do |definition|
+				[definition[:name], namespace_name + "." + definition[:name]]
+			end.to_h
+			defs.each do |definition|
+				next if definition[:type] != "namespace"
+				replacements[definition[:name] + "."] = namespace_name + "." + definition[:name] + "."
+			end
+
+
+			# Replace all words in the namespace that are equal to replacement[:from] as replacement[:to]
+			# Logic same as .macro's
+
+			namespace_lines.each_with_index do |line_info, line_i|
+
+				line_change, line = line_info
+
+				next if !line_change
+				
+				start_i = 0
+				
+				# Loop through each character starting position
+				while start_i < line.size					
+					
+					# Skip whitespace characters
+					if Kompiler::Config.whitespace_chars.include?(line[start_i])
+						start_i += 1
+						next
+					end
+					
+					# Skip string definitions
+					if Kompiler::Config.string_delimiters.include? line[start_i]
+						str, parsed_length = Kompiler::Parsers.parse_str line[start_i..]
+						start_i += parsed_length
+						next
+					end
+					
+					cut_line = line[start_i..]
+					
+					skip_to_next_word = true
+					
+					# Check if one of the argument names works
+					replacements.each do |from, to|
+						next if !cut_line.start_with?(from) # Skip the argument if the line doesn't begin with it
+						next if Kompiler::Config.keyword_chars.include?(cut_line[from.size]) && from[-1] != "." # Skip if the argument is a partial word. So, for the argument 'arg', this will skip in the case of 'arg1'
+						# Here if the argument name should be replaced with the contents
+						skip_to_next_word = from[-1] == "." # Skip to the next word only if the replacement is a namespace call
+						
+						new_line = line[...start_i] + to + cut_line[from.size..]
+						
+						
+						start_i += to.size
+
+						namespace_lines[line_i] = [true, new_line]
+						line = namespace_lines[line_i]
+												
+						break # Skip the arguments loop
+					end
+					
+					# Check if an argument was found
+					# If not, skip the text until the next whitespace character
+					if skip_to_next_word
+						while start_i < line.size && Kompiler::Config.keyword_chars.include?(line[start_i])
+							start_i += 1
+						end
+						start_i += 1 # Move one more character
+					end
+					
+				end
+				
+			end	
+
+			namespace_lines.map!{_1[1]}
+
+			state[:lines] = state[:lines][...state[:line_i]] + namespace_lines + state[:lines][(state[:line_i] + namespace_lines.size + 2)..]
+
 			state
 		end
 	}

data/lib/kompiler/wrappers/elf_wrapper.rb

@@ -77,10 +77,10 @@ module Kompiler
 		
 
 		# Converts a label hash of name-address pairs into an array of symbols
-		def self.labels_to_symbols labels
+		def self.labels_to_symbols labels, vaddr: 0
 			out = []
 			labels.each do |name, value|
-				out << {name: name, value: value, type: 0, binding: 0}
+				out << {name: name, value: value + vaddr, type: 0, binding: 0}
 			end
 			out
 		end