kompiler 0.1.2 → 0.2.0.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 358077245911280980e98b213394c395224c5ee04f4b81b449a073582567eb46
-  data.tar.gz: bdaae177e9ef79b9628eaae6e9e506c69d9951f89ff387c28532940fd67d2f90
+  metadata.gz: 69b1e8272e45a6c9ce0b8bb60dbfb89b0d65d0f8f615cbd744726857ecf1d94f
+  data.tar.gz: eba0c518a787b345d191a2cf41e76ecb52ca25dac10f14f17b72d5cbbcb2f201
 SHA512:
-  metadata.gz: c238947087f8d2032816abbe9882df8906b53de123e382ebc662aa3461e560ff69d5001e5ecdc8d28793bdd495a669ec36873d5d6792bfc0cc7396f423d96edd
-  data.tar.gz: 747cacbc92d042db6bf1ed5569bb7727ce29694c9c8f4cc6e24c625f26aee73532eb5ea6b93763f47c8e0f3819a43012919dd922b9155c035c43247e4fd0c9ec
+  metadata.gz: a325a47eff59b3766cead44c9e81063773af594e224d96aa667b7015a7a469d10be65e0ecdb68b36db88645472ae320309e92872ba568c3ed32f8da4525b113e
+  data.tar.gz: 31881ac3bba3ac3e3afa0a1c87366ea1680c32189d07cbdcd62e7eee33b19712fb85c0198b91b2315377e1f16ad0a973c95083810ef0a125c4a385ea84774101

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

@@ -275,33 +275,28 @@ end
 		],
 		bitsize: 32
 	},
+	
 	{
 		keyword: "ldr",
-		operands: [{type: "register", restrictions: {reg_size: 64}}, {type: "register", restrictions: {reg_size: 64}}],
-		mc_constructor: [
-			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5],
-			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5],
-			["get_bits", 0, 0, 12], # Immediate offset zero			
-			["bits", 1,0, 1,0, 0, 1,1,1, 1,1],
-		],
-		bitsize: 32
-	},
-	{
-		keyword: "ldr",
-		operands: [{type: "register", restrictions: {reg_size: 32}}, {type: "register", restrictions: {reg_size: 64}}],
+		name: "Load Register",
+		description: "Loads 4 or 8 bytes from memory at the address in the second register, and writes it to the destination register",
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination"}, {type: "register", restrictions: {reg_type: "gpr", reg_size: 64}, name: "Source address"}],
 		mc_constructor: [
 			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5],
 			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5],
 			["get_bits", 0, 0, 12], # Immediate offset zero			
-			["bits", 1,0, 1,0, 0, 1,1,1, 0,1],
+			["bits", 1,0, 1,0, 0, 1,1,1],
+			["case", ["get_key", ["get_operand", 0], :reg_size], 64, ["bits", 1], 32, ["bits", 0], []],
+			["bits", 1],
 		],
 		bitsize: 32
 	},
+	
 	{
 		keyword: "ldrb",
 		name: "Load Register Byte",
 		description: "Loads a byte from memory and writes the result to the destination register.",
-		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination"}, {type: "register", restrictions: {reg_size: 64, reg_type: "gpr"}, name: "Source address"}],
+		operands: [{type: "register", restrictions: {reg_type: "gpr", reg_size: 32}, name: "Destination"}, {type: "register", restrictions: {reg_size: 64, reg_type: "gpr"}, name: "Source address"}],
 		mc_constructor: [
 			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5],
 			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5],
@@ -321,41 +316,19 @@ end
 		],
 		bitsize: 32
 	},
-	{
-		keyword: "str",
-		description: "Stores the contents of a 32 bit register at the address specified by the second register",
-		operands: [{type: "register", restrictions: {reg_size: 32}, name: "Content"}, {type: "register", restrictions: {reg_size: 64}, name: "Address"}],
-		mc_constructor: [
-			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5],
-			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5],
-			["get_bits", 0, 0, 12], # Immediate offset zero			
-			["bits", 0,0, 1,0, 0, 1,1,1, 0,1],
-		],
-		bitsize: 32
-	},
-	{
-		keyword: "str",
-		description: "Stores the contents of a 64 bit register at the address specified by the second register",
-		operands: [{type: "register", restrictions: {reg_size: 64}, name: "Content"}, {type: "register", restrictions: {reg_size: 64}, name: "Address"}],
-		mc_constructor: [
-			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5],
-			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5],
-			["get_bits", 0, 0, 12], # Immediate offset zero			
-			["bits", 0,0, 1,0, 0, 1,1,1, 1,1],
-		],
-		bitsize: 32
-	},
 	
 	{
-		keyword: "str_unsigned",
-		name: "STR (immediate), unsigned offset",
-		description: "Stores the contents of a 32 bit register at the address specified by the second register with an unsigned immediate offset.",
-		operands: [{type: "register", restrictions: {reg_size: 32}, name: "Content"}, {type: "register", restrictions: {reg_size: 64}, name: "Address"}, {type: "immediate", name: "Address Offset"}],
+		keyword: "str",
+		name: "Store",
+		description: "Stores the contents of a 64 bit register at the address specified by the second register.",
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Content"}, {type: "register", restrictions: {reg_type: "gpr", reg_size: 64}, name: "Address"}],
 		mc_constructor: [
 			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5],
 			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5],
-			["get_bits", ["get_operand", 2], 0, 12], # Immediate offset zero			
-			["bits", 0,0, 1,0, 0, 1,1,1, 0,1],
+			["get_bits", 0, 0, 12],	
+			["bits", 0,0, 1,0, 0, 1,1,1],
+			["case", ["get_key", ["get_operand", 0], :reg_size], 64, ["bits", 1], 32, ["bits", 0], []],
+			["bits", 1] # size second bit always 1
 		],
 		bitsize: 32
 	},
@@ -364,42 +337,60 @@ end
 		keyword: "str_unsigned",
 		name: "STR (immediate), unsigned offset",
 		description: "Stores the contents of a 64 bit register at the address specified by the second register with an unsigned immediate offset.",
-		operands: [{type: "register", restrictions: {reg_size: 64}, name: "Content"}, {type: "register", restrictions: {reg_size: 64}, name: "Address"}, {type: "immediate", name: "Address Offset"}],
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Content"}, {type: "register", restrictions: {reg_type: "gpr", reg_size: 64}, name: "Address"}, {type: "immediate", name: "Address Offset"}],
 		mc_constructor: [
+			["case", ["get_key", ["get_operand", 0], :reg_size],
+				64, ["if_eq_else", ["modulo", ["get_operand", 2], 8], 0, [], ["raise_error", "str_unsigned Error: Unsigned offset must be divisible by 8 for 64-bit registers."]],
+				32, ["if_eq_else", ["modulo", ["get_operand", 2], 4], 0, [], ["raise_error", "str_unsigned Error: Unsigned offset must be divisible by 4 for 32-bit registers."]],
+				[]
+			],
 			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5],
 			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5],
-			["get_bits", ["get_operand", 2], 0, 12], # Immediate offset zero			
-			["bits", 0,0, 1,0, 0, 1,1,1, 1,1],
+			["get_bits",
+				["case", ["get_key", ["get_operand", 0], :reg_size],
+					64, ["divide", ["get_operand", 2], 8],
+					32, ["divide", ["get_operand", 2], 4],
+					["get_operand", 2]
+				],
+			0, 12],	
+			["bits", 0,0, 1,0, 0, 1,1,1],
+			["case", ["get_key", ["get_operand", 0], :reg_size], 64, ["bits", 1], 32, ["bits", 0], []],
+			["bits", 1] # size second bit always 1
 		],
 		bitsize: 32
 	},
 	
+	
 	{
 		keyword: "str_pre_index",
 		name: "STR (immediate), signed offset, pre-index",
-		description: "Stores the contents of a 64-bit register at the address specified by the second register with a signed immediate offset that is added before storing.",
-		operands: [{type: "register", restrictions: {reg_size: 64}, name: "Content"}, {type: "register", restrictions: {reg_size: 64}, name: "Address"}, {type: "immediate", name: "Address Offset"}],
+		description: "Stores the contents of a general purpose register at the address specified by the second register with an immediate offset added before writing.",
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Content"}, {type: "register", restrictions: {reg_type: "gpr", reg_size: 64}, name: "Address"}, {type: "immediate", name: "Address Offset"}],
 		mc_constructor: [
 			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5],
 			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5],
 			["bits", 1, 1],
 			["get_bits", ["get_operand", 2], 0, 9],	
-			["bits", 0, 0,0, 0,0, 0, 1,1,1, 1,1],
+			["bits", 0, 0,0, 0,0, 0, 1,1,1],
+			["case", ["get_key", ["get_operand", 0], :reg_size], 64, ["bits", 1], 32, ["bits", 0], []],
+			["bits", 1] # size second bit always 1
 		],
 		bitsize: 32
 	},
 	
 	{
-		keyword: "str_pre_index",
-		name: "STR (immediate), signed offset, pre-index",
-		description: "Stores the contents of a 32-bit register at the address specified by the second register with a signed immediate offset that is added before storing.",
-		operands: [{type: "register", restrictions: {reg_size: 32}, name: "Content"}, {type: "register", restrictions: {reg_size: 64}, name: "Address"}, {type: "immediate", name: "Address Offset"}],
+		keyword: "str_post_index",
+		name: "STR (immediate), signed offset, post-index",
+		description: "Stores the contents of a general purpose register at the address specified by the second register, with an immediate offset added after writing.",
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Content"}, {type: "register", restrictions: {reg_type: "gpr", reg_size: 64}, name: "Address"}, {type: "immediate", name: "Address Offset"}],
 		mc_constructor: [
 			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5],
 			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5],
-			["bits", 1, 1],
+			["bits", 1, 0],
 			["get_bits", ["get_operand", 2], 0, 9],	
-			["bits", 0, 0,0, 0,0, 0, 1,1,1, 0,1],
+			["bits", 0, 0,0, 0,0, 0, 1,1,1],
+			["case", ["get_key", ["get_operand", 0], :reg_size], 64, ["bits", 1], 32, ["bits", 0], []],
+			["bits", 1] # size second bit always 1
 		],
 		bitsize: 32
 	},
@@ -407,69 +398,64 @@ end
 	
 	{
 		keyword: "cmp",
-		operands: [{type: "register", restrictions: {reg_size: 64}}, {type: "immediate"}],
+		name: "Compare (immediate)",
+		description: "Subtracts an immediate value from a register value, and updates the condition flags based on the result.",
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}}, {type: "immediate"}],
 		mc_constructor: [
 			["bits", 1,1,1,1,1],
 			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5],
-			["get_bits", ["get_operand", 1], 0, 12], # Immediate offset zero			
-			["bits", 0, 0,1,0,0,0,1, 1, 1, 1],
+			["get_bits", ["get_operand", 1], 0, 12], # Immediate value	
+			["bits", 0, 0,1,0,0,0,1, 1, 1],
+			["case", ["get_key", ["get_operand", 0], :reg_size], 64, ["bits", 1], 32, ["bits", 0], []], # sf
 		],
 		bitsize: 32
 	},
 	
 	{
 		keyword: "cmp",
-		name: "CMP (two registers)",
-		description: "Compares two 64-bit registers and updates condition flags based on the result.",
-		operands: [{type: "register", restrictions: {reg_size: 64}, name: "Register 1"}, {type: "register", restrictions: {reg_size: 64}, name: "Register 2"}],
+		name: "Compare (registers)",
+		description: "Subtracts the second register value from the first register value, and updates the condition flags based on the result.",
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Register 1"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Register 2"}],
 		mc_constructor: [
+			["if_eq_else", ["get_key", ["get_operand", 0], :reg_size], ["get_key", ["get_operand", 1], :reg_size], [], ["raise_error", "cmp Error: Register sizes are not the same"]],
 			["bits", 1,1,1,1,1], # Rd
-			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5],
+			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5], # Rn
 			["get_bits", 0, 0, 6], # Immediate offset zero (shift amount)
 			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5], # Rm
 			["bits", 0],
 			["bits", 0, 0], # Shift type
-			["bits", 1,1,0,1,0,1,1,1],
-		],
-		bitsize: 32
-	},
-	
-	{
-		keyword: "cmp",
-		name: "CMP (two registers)",
-		description: "Compares two 32-bit registers and updates condition flags based on the result.",
-		operands: [{type: "register", restrictions: {reg_size: 32}, name: "Register 1"}, {type: "register", restrictions: {reg_size: 32}, name: "Register 2"}],
-		mc_constructor: [
-			["bits", 1,1,1,1,1], # Rd
-			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5],
-			["get_bits", 0, 0, 6], # Immediate offset zero (shift amount)
-			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5], # Rm
-			["bits", 0],
-			["bits", 0, 0], # Shift type
-			["bits", 1,1,0,1,0,1,1,0],
+			["bits", 1,1,0,1,0,1,1],
+			["case", ["get_key", ["get_operand", 0], :reg_size], 64, ["bits", 1], 32, ["bits", 0], []], # sf
 		],
 		bitsize: 32
 	},
+
 	
 	{
 		keyword: "sub",
-		operands: [{type: "register", restrictions: {reg_size: 64}}, {type: "register", restrictions: {reg_size: 64}}, {type: "immediate"}],
+		name: "Subtract (immediate)",
+		description: "Subtract an immediate value from a register value, and store the result in the destination register",
+		operands: [{type: "register", restrictions: {reg_type: "gpr"}, name: "Destination"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Source"}, {type: "immediate", name: "Immediate"}],
 		mc_constructor: [
+			["if_eq_else", ["get_key", ["get_operand", 0], :reg_size], ["get_key", ["get_operand", 1], :reg_size], [], ["raise_error", "sub 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", ["get_operand", 2], 0, 12], # Immediate offset zero
 			["bits", 0], # Shift	
-			["bits", 0,1,0,0,0,1,0,1,1],
+			["bits", 0,1,0,0,0,1,0,1],
+			["case", ["get_key", ["get_operand", 0], :reg_size], 64, ["bits", 1], 32, ["bits", 0], []], # sf
 		],
 		bitsize: 32
 	},
 	
 	{
 		keyword: "mul",
-		name: "MUL",
-		description: "Multiply the contents of two registers and store the output in the destination register.",
-		operands: [{type: "register", restrictions: {reg_type: "gpr"}}, {type: "register", restrictions: {reg_type: "gpr"}}, {type: "register", restrictions: {reg_type: "gpr"}}],
+		name: "Multiply",
+		description: "Multiply the contents of two registers, and store the output in 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"}],
 		mc_constructor: [
+			["if_eq_else", ["get_key", ["get_operand", 0], :reg_size], ["get_key", ["get_operand", 1], :reg_size], [], ["raise_error", "mul 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", "mul Error: Register sizes are not the same"]],
 			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5], # Rd
 			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5], # Rn
 			["bits", 1,1,1,1,1, 0], # Ra o0
@@ -482,6 +468,29 @@ end
 	},
 	
 	
+	{
+		keyword: "madd",
+		name: "Multiply-Add",
+		description: "Multiplies two register values, adds a third register value, 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 (to multiply)"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Register 2 (to multiply)"}, {type: "register", restrictions: {reg_type: "gpr"}, name: "Register 3 (to add)"}],
+		mc_constructor: [
+			# Checks for register sizes being the same
+			["if_eq_else", ["get_key", ["get_operand", 0], :reg_size], ["get_key", ["get_operand", 1], :reg_size], [], ["raise_error", "madd 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", "madd Error: Register sizes are not the same"]], 
+			["if_eq_else", ["get_key", ["get_operand", 2], :reg_size], ["get_key", ["get_operand", 3], :reg_size], [], ["raise_error", "madd Error: Register sizes are not the same"]], 
+
+			["get_bits", ["encode_gp_register", ["get_operand", 0]], 0, 5], # Rd
+			["get_bits", ["encode_gp_register", ["get_operand", 1]], 0, 5], # Rn
+			["get_bits", ["encode_gp_register", ["get_operand", 3]], 0, 5], #Ra
+			["bits", 0], # o0
+			["get_bits", ["encode_gp_register", ["get_operand", 2]], 0, 5], # Rm
+			["bits", 0,0,0, 1,1,0,1,1, 0,0],
+			["case", ["get_key", ["get_operand", 0], :reg_size], 64, ["bits", 1], 32, ["bits", 0], []], # sf
+		],
+		bitsize: 32,
+	},
+	
+	
 	#
 	# B.cond instructions
 	#

data/lib/kompiler/mc_builder.rb

@@ -28,6 +28,16 @@ MC_AST_NODES = [
 	{name: "get_label_address", n_args: 1, func: lambda {|args, state| state[:labels].include?(args[0]) ? state[:labels][args[0]] : raise("Label \"#{args[0]}\" not found: Program build not possible") } },
 	{name: "bits", n_args: "any", func: lambda {|args, state| args } },
 	{name: "if_eq_else", n_args: 4, eval_args: false, func: lambda {|args, state| (eval_mc_node_arg(args[0], state) == eval_mc_node_arg(args[1], state)) ? eval_mc_node_arg(args[2], state) : eval_mc_node_arg(args[3], state) }},
+	{name: "case", n_args: "any", eval_args: false, func: lambda do |args, state| 
+		value = eval_mc_node_arg(args[0], state)
+		raise "Incorrect use of the \"case\" MC Constructor: incorrect number of arguments. This is likely a problem with the architecture, not the program being compiled." if (args.size - 2) % 2 != 0
+		args[1...-1].each_slice(2) do |check_value, block|
+			if value == check_value
+				return eval_mc_node_arg(block, state)
+			end
+		end
+		eval_mc_node_arg(args.last, state)
+	end},
 	{name: "raise_error", n_args: 1, func: lambda {|args, state| raise args[0] } },
 	{name: "get_key", n_args: 2, func: lambda {|args, state| args[0][args[1]] }},
 ]

data/lib/kompiler/parsers.rb

@@ -22,6 +22,8 @@ def self.parse_str(code)
 				str_content << "\r"
 			elsif code[i] == "\\"
 				str_content << "\\"
+			elsif code[i] == "0"
+				str_content << "\0"
 			else
 				str_content << "\\"
 				str_content << code[i]
@@ -145,6 +147,29 @@ def self.check_decimal_operand(str)
 end
 
 
+def self.check_char_operand(str)
+
+	# If doesn't start with ' or doesn't end with ', return false
+	if (str[0] != "'") || (str[-1] != "'")
+		return [false, nil]
+	end
+
+	# Use existing logic to parse the contents
+	to_parse = str.dup
+	to_parse[0] = '"'
+	to_parse[-1] = '"'
+	content, parse_i = parse_str(to_parse)
+	
+	# If more than one character, return false
+	if content.size != 1
+		return [false, nil]
+	end
+
+	return [true, content.encode("ascii").bytes[0]]
+end
+
+
+
 def self.check_immediate_operand(operand_str)
 	
 	is_bin, bin_value = check_binary_operand(operand_str)
@@ -156,6 +181,9 @@ def self.check_immediate_operand(operand_str)
 	is_hex, hex_value = check_hex_operand(operand_str)
 	return [true, {type: "immediate", value: hex_value, def_type: "hex"}] if is_hex
 	
+	is_char, char_value = check_char_operand(operand_str)
+	return [true, {type: "immediate", value: char_value, def_type: "char"}] if is_char
+	
 	return [false, nil]
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kompiler
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0.pre.2
 platform: ruby
 authors:
 - Kyryl Shyshko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-27 00:00:00.000000000 Z
+date: 2024-11-28 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