kompiler 0.3.0.pre.4 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b00e5940820b7f2798ede46f7014a87ab43d7ade0ca171c223eae550668673c0
-  data.tar.gz: dcd9d7bd8d170a37206d51a6b427c48217d115f048620404b045a8f6005eb6e0
+  metadata.gz: 18cda0db09b288b5ad14ebb5feb99e13fe03ea5a7897d603285b0aab0c8bdb77
+  data.tar.gz: e84247276f40846adef9798d8ea6584dc3fe156caaa18495c668ee7f99506e9e
 SHA512:
-  metadata.gz: 023ae20fa5229d793e71ebea06bc46dea243170129e12eaf5c099c16dabdabcecb6302f0893ef17cbf0128c30a8d7d9f0b77841ecfa6ddb871d18e0c517373d4
-  data.tar.gz: ae856004b38f75b46b4b62c7455c5f94cbeb2f21dd34e54443ff776f4fbb23432eb42f389bd706f3d649c8b2d69bee3a3e2d2cf7095d24178c32e50f32b47149
+  metadata.gz: d682ae38a0d09b9ca8c584de5a3687554a97962ab227fcfb1bd7f458d0f5c48ff1ca0386db8ddcd6f80832e5d94a53b12a655164a23e58bd168128dd8a05106e
+  data.tar.gz: 04e832aff94a2948615b3f9ca03db1cc75648673873ec9a4678aab6f09aa24b595d9a276910cf53f00de34dffebb0bfc7675b1150749bdfcbe6225bae2778401

data/bin/kompile

@@ -16,29 +16,118 @@
 
 require 'kompiler'
 
+
+arg_string = ARGV.join(" ")
+
+arg_words = []
+arg_keys = []
+arg_opts = []
+arg_letters = []
+
+current_i = 0
+
+permitted_word_chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + ["_", ".", "-"]
+
+whitespace_chars = ["\t", " "]
+
+def get_word string, permitted_word_chars, offset = 0
+	if string[0] == '"'
+		str_content, n_parsed = Kompiler::Parsers.parse_str(string[offset..])
+		return str_content, n_parsed + offset
+	else
+		current_i = offset
+		word = ""
+		while permitted_word_chars.include? string[current_i]
+			word << string[current_i]
+			current_i += 1
+		end
+		return word, current_i
+	end
+end
+
+
+while current_i < arg_string.size
+
+	if whitespace_chars.include? arg_string[current_i]
+		current_i += 1
+	end
+
+	if arg_string[current_i] == "-" && arg_string[current_i + 1] == "-"
+		current_i += 2
+		keyword, current_i = get_word(arg_string, permitted_word_chars, current_i)
+
+
+		if arg_string[current_i] == "="
+			current_i += 1
+			value, current_i = get_word(arg_string, permitted_word_chars, current_i)
+
+			arg_keys << [keyword, value]
+		elsif whitespace_chars.include?(arg_string[current_i]) || current_i == arg_string.size
+			arg_opts << keyword
+		else
+			puts "Unrecognized argument syntax at index #{current_i}"
+			exit
+		end
+
+		next
+	end
+
+	if arg_string[current_i] == "-"
+		current_i += 1
+		
+		letters, current_i = get_word(arg_string, permitted_word_chars, current_i)
+
+		arg_letters += letters.chars
+
+		next
+	end
+	
+	
+	word, current_i = get_word(arg_string, permitted_word_chars, current_i)	
+	arg_words << word
+end
+
+
+
+
 # Print the help screen if requested
-if (ARGV.size == 1) && ["--help", "-h"].include?(ARGV[0])
-puts """Usage: kompile [options] | [<input_file> <output_file> [architecture]]
+if arg_opts.include?("help") || arg_letters.include?("h")
+puts """Usage: kompile <input_file> [<output_file>] [compile_options]
+   or: kompile OPTION
 
-Available options:
- --help, -h				Prints this screen
- --list-architectures	Prints available architectures
- -L						Alias to --list-architectures
+Compile a file:
+ input_file             Path to the input file
+ output_file            Path to the output file (optional, default is out.bin)
+
+Compilation options:
+ --arch=<arch_name>     Compile for the specified architecture (optional, default is armv8a)
+ --wrap=<format>        Wrap the compiled program in the specified format (default is none)
 
-To compile, run:
- kompile <input_file> <output_file> [architecture]
+Available wrapping formats:
+ none
+ elf.obj
+ elf.exec
+ mach-o.obj  [not implemented yet]
+ mach-o.exec [not implemented yet]
 
-Arguments:
- <input_file>			The path to the input file
- <output_file>			The path where the compiled output will be saved
- [architecture]			(Optional) One of the installed architectures to use for compilation (defaults to \"armv8a\")
+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
+
+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
 """
 exit # Exit
 end
 
 
 # Print the available architectures if requested
-if (ARGV.size == 1) && ["--list-architectures", "-L"].include?(ARGV[0])
+if arg_opts == ["list-architectures"]
 	Kompiler::ArchManager.load_all_entries()
 	puts "Available architectures:"
 	
@@ -48,52 +137,171 @@ if (ARGV.size == 1) && ["--list-architectures", "-L"].include?(ARGV[0])
 	exit # Exit
 end
 
-in_filename = ARGV[0]
-out_filename = ARGV[1]
-arch_name = ARGV[2] || "armv8a"
+if arg_opts == ["list-instructions"]
+	arch_name = arg_words[0] || "armv8a"
+	Kompiler::ArchManager.load_all_entries()
+	arch = Kompiler::ArchManager.get_arch(arch_name)
+
+	require arch[:include_path]
+
+	Kompiler::Architecture.instructions.each do |instr|
+		puts "#{instr[:keyword]} (#{instr[:operands].size} operands): #{instr[:name]}"
+		puts instr[:description]
+		puts
+	end
+
+	exit
+end
+
+if arg_opts == ["list-registers"]
+	arch_name = arg_words[0] || "armv8a"
+	Kompiler::ArchManager.load_all_entries()
+	arch = Kompiler::ArchManager.get_arch(arch_name)
+
+	require arch[:include_path]
+
+	Kompiler::Architecture.registers.each do |reg|
+		puts "#{reg[:reg_name]}"
+	end
+
+	exit
+end
+
+
+
+if arg_words.size < 1
+	puts "kompile: No input file path provided."
+	puts "Type \"kompile --help\" for more information."
+	exit
+end
+
+in_filename = arg_words[0]
+out_filename = (arg_words.size > 1) ? arg_words[1] : "out.bin"
+
 
 if !in_filename
 	puts "Error: No input file provided"
 	exit
 end
 
+if !File.exist?(in_filename)
+	puts "Error: File \"#{in_filename}\" doesn't exist"
+	exit
+end
+
+
 if !out_filename
 	puts "Error: No output file provided"
 	exit
 end
 
-if !File.exist?(in_filename)
-	puts "Error: #{in_filename} doesn't exist"
+
+
+
+
+wrap_opt = arg_keys.select{_1[0] == "wrap"}
+
+
+if wrap_opt.size > 1
+	puts "kompile: Only one wrapping option can be provided with \"--wrap\"."
+	puts "Type \"kompile --help\" for more information."
 	exit
+elsif wrap_opt.size == 1
+	wrap_opt = wrap_opt[0][1]
+else
+	wrap_opt = "none"
 end
 
-# Load all the architecture entries
 
-Kompiler::ArchManager.load_all_entries()
+if !["elf.obj", "elf.exec", "mach-o.obj", "mach-o.exec", "none"].include?(wrap_opt)
+	puts "kompile: Unknown wrapping option \"#{wrap_opt}\"."
+	puts "Type \"kompile --help\" for more information."
+	exit
+end
+
+
+
 
-# Find the right architecture
-arch = Kompiler::ArchManager.get_arch(arch_name)
+arch_opt = arg_keys.select{_1[0] == "arch"}
 
-if arch == nil
-	puts "Error: Architecture \"#{arch_name}\" not found."
+if arch_opt.size > 1
+	puts "kompile: Only one architecture can be provided with \"--arch\"."
+	puts "Type \"kompile --help\" for more information."
 	exit
+elsif arch_opt.size == 1
+	arch_name = arch_opt[0][1]
+else
+	arch_name = "armv8a"
 end
 
-# Get the include path for the architecture
-arch_include_path = arch[:include_path]
+# Load all the architecture entries
+
+Kompiler::ArchManager.load_all_entries()
 
 # Load the architecture
+
+arch_config = Kompiler::ArchManager.get_arch(arch_name)
+
+if arch_config == nil
+	puts "kompile: Could not find the architecture \"#{arch_name}\"."
+	puts "Type \"kompile --list-architectures\" for the list of known architectures."
+	exit
+end
+
 begin
-	require arch_include_path
-rescue LoadError => e
-	puts "Error: Could not load #{arch_name} architecture's configuration."
+	Kompiler::ArchManager.load_arch(arch_name)
+rescue
+	puts "kompile: Could not load the architecture \"#{arch_name}\"."
 	exit
 end
 
-code = File.read(in_filename)
 
-compiled_bytes_str = Kompiler::CompilerFunctions.compile(code, [in_filename])
 
-File.open(out_filename, "wb") do |file|
-	file.write compiled_bytes_str
+code = File.binread(in_filename)
+
+detailed_out = Kompiler::CompilerFunctions.detailed_compile(code)
+
+# p detailed_out
+
+out = nil
+
+code = detailed_out[:machine_code]
+labels = detailed_out[:labels]
+
+labels.delete "here"
+
+
+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
+	
+	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
+
+	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, elf_class: elf_class)
+when "mach-o.obj"
+	puts "Mach-O not yet implemented."
+	exit
+when "mach-o.exec"
+	puts "Mach-O not yet implemented."
+	exit
 end
+
+
+File.binwrite out_filename, out
+

data/lib/kompiler/arch_manager.rb

@@ -1,6 +1,11 @@
 # Copyright 2024 Kyrylo Shyshko
 # Licensed under the Apache License, Version 2.0. See LICENSE file for details.
 
+#
+# Implements logic for managing all available architectures.
+#
+
+
 module Kompiler
 
 	# Object for managing architecture entries / available architectures
@@ -22,6 +27,10 @@ module Kompiler
 		def self.load_all_entries
 			Gem.find_files("kompiler/arch_entries/*").each { |file| require file }
 		end
+
+		def self.load_arch arch_name
+			require get_arch(arch_name)[:include_path]
+		end
 	end
 
-end
+end

data/lib/kompiler/architecture.rb

@@ -1,6 +1,10 @@
 # Copyright 2024 Kyrylo Shyshko
 # Licensed under the Apache License, Version 2.0. See LICENSE file for details.
 
+#
+# Implements logic to set and read info of the currently used architecture.
+#
+
 module Kompiler
 
 module Architecture
@@ -27,4 +31,4 @@ end
 
 end
 
-end
+end

data/lib/kompiler/architectures/armv8a/instructions.rb

@@ -13,7 +13,7 @@ end
 	{	keyword: "mov",
 		name: "Move (immediate)",
 		description: "Moves an immediate value to the destination register",
-		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination"}, {type: "immediate", restrictions: {}, name: "Immediate value"}],
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination register"}, {type: "immediate", restrictions: {}, name: "Immediate value"}],
 		mc_constructor: [
 			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5],
 			["get_bits", ["get_operand", 1], 0, 16],
@@ -25,7 +25,7 @@ end
 	{	keyword: "mov",
 		name: "Move (register)",
 		description: "Copies the value in the source register to the destination register",
-		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Source"}],
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination register"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Source register"}],
 		mc_constructor: [
 			["if_eq_else", ["get_key", ["get_operand", 0], :reg_size], ["get_key", ["get_operand", 1], :reg_size], [], ["raise_error", "mov Error: Register sizes are not the same"]],
 			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5], # Rd
@@ -40,7 +40,7 @@ end
 	{	keyword: "mov_sp",
 		name: "Move (to/from SP)",
 		description: "Move between a general-purpose register and the stack pointer.",
-		operands: [{type: "register", restrictions: {reg_type: "gpr"}}, {type: "register", restrictions: {reg_type: "gpr"}}],
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination register"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Source register"}],
 		mc_constructor: [
 			# Get the non-SP register
 			["if_eq_else", ["downcase_str", ["get_key", ["get_operand", 0], :reg_name]], "sp", ["set_var", "non_sp_reg", ["get_operand", 1]], ["set_var", "non_sp_reg", ["get_operand", 0]]],
@@ -53,32 +53,26 @@ end
 		bitsize: 32
 	},
 	{	keyword: "mvn", # MVN writes the bitwise opposite of the source register to a destination register
-		description: "MVN writes the bitwise opposite of the source register to the destination register",
-		operands: [{type: "register", restrictions: {reg_size: 64}, name: "Destination"}, {type: "register", restrictions: {reg_size: 64}, name: "Source"}],
-		mc_constructor: [
-			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5], # Rd
-			["bits", 1,1,1,1,1], # Rn
-			["bits", 0,0,0,0,0,0], # imm6 (shift amount) set to zero
-			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5], # Rm
-			["bits", 1, 0,0, 0,1,0,1,0,1,0, 1] # N - shift type (zero / LSL) - bits
-		],
-		bitsize: 32
-	},
-	{	keyword: "mvn", # MVN writes the bitwise opposite of the source register to a destination register
-		description: "MVN writes the bitwise opposite of the source register to the destination register",
-		operands: [{type: "register", restrictions: {reg_size: 32}, name: "Destination"}, {type: "register", restrictions: {reg_size: 32}, name: "Source"}],
+		name: "Move inverse",
+		description: "Writes the bitwise opposite of the source register value to the destination register.",
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination register"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Source register"}],
 		mc_constructor: [
+			["ensure_eq", ["get_operand_key", 0, :reg_size], ["get_operand_key", 1, :reg_size], "mvn Error: Register sizes are not the same."],
+
 			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5], # Rd
 			["bits", 1,1,1,1,1], # Rn
 			["bits", 0,0,0,0,0,0], # imm6 (shift amount) set to zero
 			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5], # Rm
-			["bits", 1, 0,0, 0,1,0,1,0,1,0, 0] # N - shift type (zero / LSL) - bits
+			["bits", 1, 0,0, 0,1,0,1,0,1,0], # N - shift type (zero / LSL) - bits
+			["case", ["get_operand_key", 0, :reg_size], 32, ["bits", 0], 64, ["bits", 1], [0]]
 		],
 		bitsize: 32
 	},
 	{
 		keyword: "add",
-		operands: [{type: "register", restrictions: {reg_type: "gpr"}}, {type: "register", restrictions: {reg_type: "gpr"}}, {type: "immediate"}],
+		name: "Add (immediate)",
+		description: "Adds the source register value and the immediate value, and writes the result to the destination register.",
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination register"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Source register"}, {type: "immediate", name: "Immediate value"}],
 		mc_constructor: [
 			["if_eq_else", ["get_key", ["get_operand", 0], :reg_size], ["get_key", ["get_operand", 1], :reg_size], [], ["raise_error", "add Error: Register sizes are not the same"]],
 
@@ -95,7 +89,7 @@ end
 		keyword: "add",
 		name: "ADD (registers)",
 		description: "Adds two source registers and writes the result to the destination register",
-		operands: [{type: "register", restrictions: {reg_type: "gpr"}}, {type: "register", restrictions: {reg_type: "gpr"}}, {type: "register", restrictions: {reg_type: "gpr"}}],
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination register"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Source register 1"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Source register 2"}],
 		mc_constructor: [
 			# Make sure register sizes are the same
 			["if_eq_else", ["get_key", ["get_operand", 0], :reg_size], ["get_key", ["get_operand", 1], :reg_size], [], ["raise_error", "add Error: Register sizes are not the same"]],
@@ -115,9 +109,9 @@ end
 	
 	{
 		keyword: "and",
-		name: "And (register)",
+		name: "Bitwise And (register)",
 		description: "Performs a bitwise AND of two register values and writes the result to the destination register.",
-		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Register 1"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Register 2"}],
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination register"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Source register 1"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Source register 2"}],
 		mc_constructor: [
 			["if_eq_else", ["get_key", ["get_operand", 0], :reg_size], ["get_key", ["get_operand", 1], :reg_size], [], ["raise_error", "and Error: Register sizes are not the same"]],
 			["if_eq_else", ["get_key", ["get_operand", 1], :reg_size], ["get_key", ["get_operand", 2], :reg_size], [], ["raise_error", "and Error: Register sizes are not the same"]],
@@ -135,17 +129,21 @@ end
 	
 	{
 		keyword: "orr", # And between registers, with shift set to zero
-		name: "Or",
+		name: "Bitwise OR (register)",
 		description: "Computes a logical bit-wise OR operation between two registers and writes the result to the destination register.",
-		operands: [{type: "register", restrictions: {reg_size: 64}, name: "Destination"}, {type: "register", restrictions: {reg_size: 64}, name: "Register 1"}, {type: "register", restrictions: {reg_size: 64}, name: "Register 2"}],
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination register"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Source register 1"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Source register 2"}],
 		mc_constructor: [
+			["ensure_eq", ["get_operand_key", 0, :reg_size], ["get_operand_key", 1, :reg_size], "orr Error: Register sizes are not the same."],
+			
 			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5],
 			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5],
 			["get_bits", 0, 0, 6], # imm6 (shift amount) set to zero
 			["get_bits", ["encode_gp_register", ["get_operand", 2]], 0, 5],
 			["bits", 0], # N
 			["bits", 0,0], # shift type
-			["bits", 0,1,0,1,0, 1,0, 1],
+			["bits", 0,1,0,1,0, 1,0],
+
+			["case", ["get_operand_key", 0, :reg_size], 32, ["bits", 0], 64, ["bits", 1], ["bits", 0]],
 		],
 		bitsize: 32
 	},
@@ -180,13 +178,17 @@ end
 	},
 	{
 		keyword: "b",
-		operands: [{type: "immediate"}],
+		name: "Branch (immediate)",
+		description: "Branches (jumps) to a PC-relative offset specified by the immediae value.",
+		operands: [{type: "immediate", name: "Immediate PC Offset"}],
 		mc_constructor: [["get_bits", ["get_operand", 0], 0, 26], ["bits", 1,0,1,0,0,0]],
 		bitsize: 32
 	},
 	{
 		keyword: "b",
-		operands: [{type: "label"}],
+		name: "Branch (label)",
+		description: "Branches (jumps) to a label using a PC-relative offset.",
+		operands: [{type: "label", name: "Program label"}],
 		mc_constructor: [
 			["if_eq_else", ["modulo", ["subtract", ["get_label_address", ["get_operand", 0]], ["get_current_address"]], 4], 0, [], ["raise_error", "Can't branch to the address - offset not divisible by 4 bytes."]], # Check if address is accessible
 			["get_bits", ["divide", ["subtract", ["get_label_address", ["get_operand", 0]], ["get_current_address"]], 4], 0, 26],
@@ -196,6 +198,8 @@ end
 	},
 	{
 		keyword: "br",
+		name: "Branch (register)",
+		description: "Branches (jumps) to an address in a register.",
 		operands: [{type: "register", restrictions: {reg_size: 64}}],
 		mc_constructor: [
 			["bits", 0,0,0,0,0],
@@ -206,6 +210,8 @@ end
 	},
 	{
 		keyword: "bl",
+		name: "Branch with link (label)",
+		description: "Branches (jumps) to a label using a PC-relative offset, and sets the register X30 to PC + 4.",
 		operands: [{type: "label"}],
 		mc_constructor: [
 			["if_eq_else", ["modulo", ["subtract", ["get_label_address", ["get_operand", 0]], ["get_current_address"]], 4], 0, [], ["raise_error", "Can't branch to the address - offset not divisible by 4 bytes."]], # Check if address is accessible
@@ -1148,6 +1154,49 @@ end
 		bitsize: 32
 	},
 	
+	{
+		keyword: "sxtw",
+		name: "Sign Extend Word",
+		description: "Sign extends the 32-bit signed integer in the source general-purpose register to a 64-bit signed integer, and writes the result to the destination general-purpose register.",
+		operands: [{type: "register", restrictions: {reg_type: "gpr", reg_size: 64}, name: "Destination register"}, {type: "register", restrictions: {reg_type: "gpr", reg_size: 32}, name: "Source register"}],
+		mc_constructor: [
+			["get_bits", ["get_operand_key", 0, :reg_value], 0, 5],
+			["get_bits", ["get_operand_key", 1, :reg_value], 0, 5],
+			["bits", 1,1,1,1,1,0, 0,0,0,0,0,0, 1, 0,1,1,0,0,1, 0,0, 1],
+		],
+		bitsize: 32
+	},
+	{
+		keyword: "sxth",
+		name: "Sign Extend Halfword",
+		description: "Sign extends the 16-bit signed integer in the source general-purpose register to the size of the destination register, and writes the result to the destination general-purpose register.",
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination register"}, {type: "register", restrictions: {reg_type: "gpr", reg_size: 32}, name: "Source register"}],
+		mc_constructor: [
+			["get_bits", ["get_operand_key", 0, :reg_value], 0, 5],
+			["get_bits", ["get_operand_key", 1, :reg_value], 0, 5],
+			["bits", 1,1,1,1,0,0, 0,0,0,0,0,0], 
+			["case", ["get_key", ["get_operand", 0], :reg_size], 64, ["bits", 1], 32, ["bits", 0], []],
+			["bits", 0,1,1,0,0,1, 0,0],
+			["case", ["get_key", ["get_operand", 0], :reg_size], 64, ["bits", 1], 32, ["bits", 0], []],
+		],
+		bitsize: 32
+	},
+	{
+		keyword: "sxtb",
+		name: "Sign Extend Byte",
+		description: "Sign extends the 8-bit signed integer in the source general-purpose register to the size of the destination register, and writes the result to the destination general-purpose register.",
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination register"}, {type: "register", restrictions: {reg_type: "gpr", reg_size: 32}, name: "Source register"}],
+		mc_constructor: [
+			["get_bits", ["get_operand_key", 0, :reg_value], 0, 5],
+			["get_bits", ["get_operand_key", 1, :reg_value], 0, 5],
+			["bits", 1,1,1,0,0,0, 0,0,0,0,0,0], 
+			["case", ["get_key", ["get_operand", 0], :reg_size], 64, ["bits", 1], 32, ["bits", 0], []],
+			["bits", 0,1,1,0,0,1, 0,0],
+			["case", ["get_key", ["get_operand", 0], :reg_size], 64, ["bits", 1], 32, ["bits", 0], []],
+		],
+		bitsize: 32
+	},
+	
 ]
 
 end # Kompiler::ARMv8A

data/lib/kompiler/architectures/armv8a/load.rb

@@ -5,6 +5,8 @@ require 'kompiler/architectures/armv8a/instructions.rb'
 require 'kompiler/architectures/armv8a/sys_instructions.rb'
 require 'kompiler/architectures/armv8a/registers.rb'
 require 'kompiler/architectures/armv8a/sys_registers.rb'
+require 'kompiler/architectures/armv8a/simd_fp_instructions.rb'
+require 'kompiler/architectures/armv8a/simd_fp_registers.rb'
 
 
-Kompiler::Architecture.set_arch(Kompiler::ARMv8A.instructions + Kompiler::ARMv8A.sys_instructions, Kompiler::ARMv8A.registers + Kompiler::ARMv8A.sys_registers)
+Kompiler::Architecture.set_arch(Kompiler::ARMv8A.instructions + Kompiler::ARMv8A.sys_instructions + Kompiler::ARMv8A.simd_fp_instructions, Kompiler::ARMv8A.registers + Kompiler::ARMv8A.sys_registers + Kompiler::ARMv8A.simd_fp_registers)