IC10/instructions - Revision history

RA2lover: add jal ra workaround

2026-09-14T14:31:08Z

add jal ra workaround

← Older revision		Revision as of 14:31, 14 September 2026
Line 398:		Line 398:
	\| description = Jump execution to line a and store next line number in ra		\| description = Jump execution to line a and store next line number in ra
	\| syntax = jal int		\| syntax = jal int
	\| note = Actual behavior as of The Power Line Update (Q3 2026) stores the next line number in ra before jumping execution to line a. This results in jal ra being a no-op (likely a bug).		\| note = Actual behavior as of The Power Line Update (Q3 2026) stores the next line number in ra before jumping execution to line a. This results in jal ra being a no-op (likely a bug).<br><br>
			As a workaround, an always-taken branch-and-link can be used instead (for example, beqzal 0 ra).
	\| example = jal provides a way to do function calls in IC10 mips		\| example = jal provides a way to do function calls in IC10 mips

RA2lover: /* Branching */ document potential bug in jal ra behavior

2026-09-14T09:25:14Z

Branching: document potential bug in jal ra behavior

← Older revision		Revision as of 09:25, 14 September 2026
Line 394:		Line 394:
	# your code here		# your code here
	}}}}		}}}}
	{{ICInstruction\|instruction=jal\|description=Jump execution to line a and store next line number in ra\|syntax=jal int		{{ICInstruction
	\|example=		\| instruction = jal
	jal provides a way to do function calls in IC10 mips		\| description = Jump execution to line a and store next line number in ra
			\| syntax = jal int
			\| note = Actual behavior as of The Power Line Update (Q3 2026) stores the next line number in ra before jumping execution to line a. This results in jal ra being a no-op (likely a bug).
			\| example = jal provides a way to do function calls in IC10 mips

	{{ICCode\|		{{ICCode\|
Line 411:		Line 414:
	div r0 r0 2		div r0 r0 2
	j ra # jump back		j ra # jump back
	}}}}		}}
			}}
	{{ICInstruction\|instruction=jr\|description=Relative jump to line a\|syntax=jr int}}		{{ICInstruction\|instruction=jr\|description=Relative jump to line a\|syntax=jr int}}

RA2lover: Document stack instruction exception behavior, mention there's no direct read-equivalent for pokes.

2026-09-13T09:04:51Z

Document stack instruction exception behavior, mention there's no direct read-equivalent for pokes.

@@ Line 146: / Line 146: @@
 == Stack ==
-{{ICInstruction|instruction=clr|description=Clears the stack memory for the provided device.|syntax=clr d?}}
+{{ICInstruction
-{{ICInstruction|instruction=clrd|description=Seeks directly for the provided device id and clears the stack memory of that device|syntax=clrd id(r?{{!}}num)}}
+| instruction = clr
-{{ICInstruction|instruction=get|description=Using the provided device, attempts to read the stack value at the provided address, and places it in the register.|syntax=get r? device(d?{{!}}r?{{!}}id) address(r?{{!}}num)}}
+| description = Clears the stack memory for the provided device.
-{{ICInstruction|instruction=getd|description=Seeks directly for the provided device id, attempts to read the stack value at the provided address, and places it in the register.|syntax=getd r? id(r?{{!}}id) address(r?{{!}}num)}}
+| note = Throws a DeviceNotFound exception when used on inaccessible devices.<br><br>
-{{ICInstruction|instruction=peek|description=Register = the value at the top of the stack|syntax=peek r?}}
-{{ICInstruction|instruction=poke|description=Stores the provided value at the provided address in the stack.|syntax=poke address(r?{{!}}num) value(r?{{!}}num)}}
+Throws a MemoryNotReadable exception when used on devices without a writable stack memory. (likely a bug)
-{{ICInstruction|instruction=pop|description=Register = the value at the top of the stack and decrements sp|syntax=pop r?}}
+| syntax = clr d?
-{{ICInstruction|instruction=push|description=Pushes the value of a to the stack at sp and increments sp|syntax=push a(r?{{!}}num)}}
+}}
-{{ICInstruction|instruction=put|description=Using the provided device, attempts to write the provided value to the stack at the provided address.|syntax=put device(d?{{!}}r?{{!}}id) address(r?{{!}}num) value(r?{{!}}num)}}
+{{ICInstruction
-{{ICInstruction|instruction=putd|description=Seeks directly for the provided device id, attempts to write the provided value to the stack at the provided address.|syntax=putd id(r?{{!}}id) address(r?{{!}}num) value(r?{{!}}num)}}
+| instruction = clrd
 == Slot/Logic ==

RA2lover: Add exception documentation to bitfield extract/insert instructions, ext example code

2026-09-04T22:41:46Z

Add exception documentation to bitfield extract/insert instructions, ext example code

← Older revision		Revision as of 22:41, 4 September 2026
Line 240:		Line 240:
	\| example = ror $1234, 4 -> $4000000000000123		\| example = ror $1234, 4 -> $4000000000000123
	}}{{ICInstruction\|instruction=xor\|description=Performs a bitwise logical XOR (exclusive OR) operation on the binary representation of two values. Each bit of the result is determined by evaluating the corresponding bits of the input values. If the bits are different (one bit is 0 and the other is 1), the resulting bit is set to 1. If the bits are the same (both 0 or both 1), the resulting bit is set to 0.\|syntax=xor r? a(r?{{!}}num) b(r?{{!}}num)}}		}}{{ICInstruction\|instruction=xor\|description=Performs a bitwise logical XOR (exclusive OR) operation on the binary representation of two values. Each bit of the result is determined by evaluating the corresponding bits of the input values. If the bits are different (one bit is 0 and the other is 1), the resulting bit is set to 1. If the bits are the same (both 0 or both 1), the resulting bit is set to 0.\|syntax=xor r? a(r?{{!}}num) b(r?{{!}}num)}}
	{{ICInstruction\|instruction=ext\|description=Extracts a bit field from source value, beginning at bit offset for length bits and places result in the provided register. Payload cannot exceed 53 bits in final length.\|syntax=ext r? source(r?{{!}}num) offset(r?{{!}}num) length(r?{{!}}num)}}		{{ICInstruction
	{{ICInstruction\|instruction=ins\|description=Inserts a bit field into the provided register, beginning at bit offset for length bits. Payload cannot exceed 53 bits in final length~~. NOTE: As of 2026-01-12, stable version has a bug with parameter order (uses offset-length-field instead of field-offset-length). Beta version has correct order~~.		\| instruction = ext
	\|syntax=ins r? field(r?{{!}}num) offset(r?{{!}}num) length(r?{{!}}num)		\| description = Extracts a bit field from source value, beginning at bit offset for length bits and places result in the provided register. Payload cannot exceed 53 bits in final length.
	\|example=		\| note = Throws a ShiftUnderflow exception if offset is smaller than 1 or length is smaller than 0.<br>
	{{ICCode\|move r0 $DE0000EF		Throws a ShiftOverflow exception if offset is greater than or equal to 53 bits.<br>
			Throws a PayloadOverflow exception if length is greater than 53 bits.
			\| example = {{ICCode\|
			move r0 $DEADBEEF
			ext r1 r0 8 16 #After execution, r1's value is $ADBE
			}}
			\| syntax = ext r? source(r?{{!}}num) offset(r?{{!}}num) length(r?{{!}}num)
			}}
			{{ICInstruction
			\| instruction = ins
			\| description = Inserts a bit field into the provided register, beginning at bit offset for length bits. Payload cannot exceed 53 bits in final length.
			\| syntax = ins r? field(r?{{!}}num) offset(r?{{!}}num) length(r?{{!}}num)
			\| note = Throws a ShiftUnderflow exception if length is smaller than 1 or offset is smaller than 0.<br>
			Throws a ShiftOverflow exception if offset is greater than 53 bits.<br>
			Throws a PayloadOverflow exception if offset+length is greater to or equal to 53 bits.<br>
			\| example = {{ICCode\|move r0 $DE0000EF
	move r1 $ADBE		move r1 $ADBE
	ins r0 r1 8 16 #inserts field r1 at bit 8 for 16 bits, result: $DEADBEEF}}}}		ins r0 r1 8 16 #inserts field r1 at bit 8 for 16 bits, result: $DEADBEEF}}
			}}

	== Comparison ==		== Comparison ==

RA2lover: Improve documentation for lr instruction

2026-09-04T09:23:38Z

Improve documentation for lr instruction

@@ Line 170: / Line 170: @@
 l r0 Sensor Temperature
 }}}}
-{{ICInstruction|instruction=lr|description=Loads reagent of device's ReagentMode where a hash of the reagent type to check for. ReagentMode can be either Contents (0), Required (1), Recipe (2). Can use either the word, or the number.|syntax=lr r? device(d?{{!}}r?{{!}}id) reagentMode int}}
+{{ICInstruction
 {{ICInstruction|instruction=ls|description=Loads slot LogicSlotType on device to register.|syntax=ls r? device(d?{{!}}r?{{!}}id) slotIndex logicSlotType
 |example=

RA2lover: Add new opcodes from Beta 0.2.6330.27281, move move from mathematical to utility

2026-06-09T02:31:18Z

Add new opcodes from Beta 0.2.6330.27281, move move from mathematical to utility

Show changes

TK421: /* Slot/Logic */ mention signed32bit int required for rmap

2026-01-17T03:36:01Z

Slot/Logic: mention signed32bit int required for rmap

← Older revision		Revision as of 03:36, 17 January 2026
Line 124:		Line 124:
	}}}}		}}}}
	{{ICInstruction\|instruction=ss\|description=Stores register value to device stored in a slot LogicSlotType on device.\|syntax=ss device(d?{{!}}r?{{!}}id) slotIndex logicSlotType r?}}		{{ICInstruction\|instruction=ss\|description=Stores register value to device stored in a slot LogicSlotType on device.\|syntax=ss device(d?{{!}}r?{{!}}id) slotIndex logicSlotType r?}}
	{{ICInstruction\|instruction=rmap\|description=Given a reagent hash, store the corresponding prefab hash that the device expects to fulfill the reagent requirement. For example, on an autolathe, the hash for Iron will store the hash for ItemIronIngot.\|syntax=rmap r? d? reagentHash(r?{{!}}num)}}		{{ICInstruction\|instruction=rmap\|description=Given a reagent hash (signed 32bit int), store the corresponding prefab hash that the device expects to fulfill the reagent requirement. For example, on an autolathe, the hash for Iron will store the hash for ItemIronIngot.\|syntax=rmap r? d? reagentHash(r?{{!}}num)}}

	=== Slot/Logic / Batched ===		=== Slot/Logic / Batched ===

Veriszg: /* Bitwise */ confirmed "ins" command bugged in stable, but correct in beta, updated desc

2026-01-12T21:24:02Z

Bitwise: confirmed "ins" command bugged in stable, but correct in beta, updated desc

← Older revision		Revision as of 21:24, 12 January 2026
Line 154:		Line 154:
	{{ICInstruction\|instruction=xor\|description=Performs a bitwise logical XOR (exclusive OR) operation on the binary representation of two values. Each bit of the result is determined by evaluating the corresponding bits of the input values. If the bits are different (one bit is 0 and the other is 1), the resulting bit is set to 1. If the bits are the same (both 0 or both 1), the resulting bit is set to 0.\|syntax=xor r? a(r?{{!}}num) b(r?{{!}}num)}}		{{ICInstruction\|instruction=xor\|description=Performs a bitwise logical XOR (exclusive OR) operation on the binary representation of two values. Each bit of the result is determined by evaluating the corresponding bits of the input values. If the bits are different (one bit is 0 and the other is 1), the resulting bit is set to 1. If the bits are the same (both 0 or both 1), the resulting bit is set to 0.\|syntax=xor r? a(r?{{!}}num) b(r?{{!}}num)}}
	{{ICInstruction\|instruction=ext\|description=Extracts a bit field from source value, beginning at bit offset for length bits and places result in the provided register. Payload cannot exceed 53 bits in final length.\|syntax=ext r? source(r?{{!}}num) offset(r?{{!}}num) length(r?{{!}}num)}}		{{ICInstruction\|instruction=ext\|description=Extracts a bit field from source value, beginning at bit offset for length bits and places result in the provided register. Payload cannot exceed 53 bits in final length.\|syntax=ext r? source(r?{{!}}num) offset(r?{{!}}num) length(r?{{!}}num)}}
	{{ICInstruction\|instruction=ins\|description=Inserts a bit field into the provided register, beginning at bit offset for length bits. Payload cannot exceed 53 bits in final length. ~~WARNING~~: ~~Parameters~~ order ~~differs from documentation~~ - offset ~~and~~ length ~~come before field value~~.		{{ICInstruction\|instruction=ins\|description=Inserts a bit field into the provided register, beginning at bit offset for length bits. Payload cannot exceed 53 bits in final length. NOTE: As of 2026-01-12, stable version has a bug with parameter order (uses offset-length-field instead of field-offset-length). Beta version has correct order.
	\|syntax=ins r? ~~offset~~(r?{{!}}num) ~~length~~(r?{{!}}num) ~~field~~(r?{{!}}num)		\|syntax=ins r? field(r?{{!}}num) offset(r?{{!}}num) length(r?{{!}}num)
	\|example=		\|example=
	{{ICCode\|move r0 $DE0000EF		{{ICCode\|move r0 $DE0000EF
	move r1 $ADBE		move r1 $ADBE
	ins r0 8 16 r1 #inserts ~~16 bits of~~ r1 ~~starting~~ at bit 8, result: $DEADBEEF}}}}		ins r0 r1 8 16 #inserts field r1 at bit 8 for 16 bits, result: $DEADBEEF}}}}

	== Comparison ==		== Comparison ==

Veriszg: /* Bitwise */ ext

2026-01-12T21:03:22Z

Bitwise: ext

← Older revision		Revision as of 21:03, 12 January 2026
Line 153:		Line 153:
	{{ICInstruction\|instruction=srl\|description=Performs a bitwise logical right shift operation on the binary representation of a value. It shifts the bits to the right and fills the vacated leftmost bits with zeros\|syntax=srl r? a(r?{{!}}num) b(r?{{!}}num)}}		{{ICInstruction\|instruction=srl\|description=Performs a bitwise logical right shift operation on the binary representation of a value. It shifts the bits to the right and fills the vacated leftmost bits with zeros\|syntax=srl r? a(r?{{!}}num) b(r?{{!}}num)}}
	{{ICInstruction\|instruction=xor\|description=Performs a bitwise logical XOR (exclusive OR) operation on the binary representation of two values. Each bit of the result is determined by evaluating the corresponding bits of the input values. If the bits are different (one bit is 0 and the other is 1), the resulting bit is set to 1. If the bits are the same (both 0 or both 1), the resulting bit is set to 0.\|syntax=xor r? a(r?{{!}}num) b(r?{{!}}num)}}		{{ICInstruction\|instruction=xor\|description=Performs a bitwise logical XOR (exclusive OR) operation on the binary representation of two values. Each bit of the result is determined by evaluating the corresponding bits of the input values. If the bits are different (one bit is 0 and the other is 1), the resulting bit is set to 1. If the bits are the same (both 0 or both 1), the resulting bit is set to 0.\|syntax=xor r? a(r?{{!}}num) b(r?{{!}}num)}}
	{{ICInstruction\|instruction=ext\|description=Extracts a bit field from a, beginning at b for c length and ~~placed~~ in the provided register. Payload cannot exceed 53 bits in final length.\|syntax=ext r? a(r?{{!}}num) b(r?{{!}}num) c(r?{{!}}num)}}		{{ICInstruction\|instruction=ext\|description=Extracts a bit field from source value, beginning at bit offset for length bits and places result in the provided register. Payload cannot exceed 53 bits in final length.\|syntax=ext r? source(r?{{!}}num) offset(r?{{!}}num) length(r?{{!}}num)}}
	{{ICInstruction\|instruction=ins\|description=Inserts a bit field into the provided register, beginning at bit offset for length bits. Payload cannot exceed 53 bits in final length. WARNING: Parameters order differs from documentation - offset and length come before field value.		{{ICInstruction\|instruction=ins\|description=Inserts a bit field into the provided register, beginning at bit offset for length bits. Payload cannot exceed 53 bits in final length. WARNING: Parameters order differs from documentation - offset and length come before field value.
	\|syntax=ins r? offset(r?{{!}}num) length(r?{{!}}num) field(r?{{!}}num)		\|syntax=ins r? offset(r?{{!}}num) length(r?{{!}}num) field(r?{{!}}num)

Veriszg: /* Bitwise */ revert, game is bugged, ins and ext have different parameters

2026-01-12T21:01:31Z

Bitwise: revert, game is bugged, ins and ext have different parameters

← Older revision		Revision as of 21:01, 12 January 2026
Line 154:		Line 154:
	{{ICInstruction\|instruction=xor\|description=Performs a bitwise logical XOR (exclusive OR) operation on the binary representation of two values. Each bit of the result is determined by evaluating the corresponding bits of the input values. If the bits are different (one bit is 0 and the other is 1), the resulting bit is set to 1. If the bits are the same (both 0 or both 1), the resulting bit is set to 0.\|syntax=xor r? a(r?{{!}}num) b(r?{{!}}num)}}		{{ICInstruction\|instruction=xor\|description=Performs a bitwise logical XOR (exclusive OR) operation on the binary representation of two values. Each bit of the result is determined by evaluating the corresponding bits of the input values. If the bits are different (one bit is 0 and the other is 1), the resulting bit is set to 1. If the bits are the same (both 0 or both 1), the resulting bit is set to 0.\|syntax=xor r? a(r?{{!}}num) b(r?{{!}}num)}}
	{{ICInstruction\|instruction=ext\|description=Extracts a bit field from a, beginning at b for c length and placed in the provided register. Payload cannot exceed 53 bits in final length.\|syntax=ext r? a(r?{{!}}num) b(r?{{!}}num) c(r?{{!}}num)}}		{{ICInstruction\|instruction=ext\|description=Extracts a bit field from a, beginning at b for c length and placed in the provided register. Payload cannot exceed 53 bits in final length.\|syntax=ext r? a(r?{{!}}num) b(r?{{!}}num) c(r?{{!}}num)}}
	{{ICInstruction\|instruction=ins\|description=Inserts a bit field ~~of a~~ into the provided register, beginning at b for c length. Payload cannot exceed 53 bits in final length.		{{ICInstruction\|instruction=ins\|description=Inserts a bit field into the provided register, beginning at bit offset for length bits. Payload cannot exceed 53 bits in final length. WARNING: Parameters order differs from documentation - offset and length come before field value.
	\|syntax=ins r? a(r?{{!}}num) b(r?{{!}}num) c(r?{{!}}num)		\|syntax=ins r? offset(r?{{!}}num) length(r?{{!}}num) field(r?{{!}}num)
	\|example=		\|example=
	{{ICCode\|move r0 $DE0000EF		{{ICCode\|move r0 $DE0000EF
	move r1 $ADBE		move r1 $ADBE
	ins r0 r1 8 16 #~~expected value~~ of ~~r0 is~~ $DEADBEEF}}}}		ins r0 8 16 r1 #inserts 16 bits of r1 starting at bit 8, result: $DEADBEEF}}}}

	== Comparison ==		== Comparison ==

← Older revision		Revision as of 21:03, 12 January 2026
Line 153:		Line 153:
	{{ICInstruction\|instruction=srl\|description=Performs a bitwise logical right shift operation on the binary representation of a value. It shifts the bits to the right and fills the vacated leftmost bits with zeros\|syntax=srl r? a(r?{{!}}num) b(r?{{!}}num)}}		{{ICInstruction\|instruction=srl\|description=Performs a bitwise logical right shift operation on the binary representation of a value. It shifts the bits to the right and fills the vacated leftmost bits with zeros\|syntax=srl r? a(r?{{!}}num) b(r?{{!}}num)}}
	{{ICInstruction\|instruction=xor\|description=Performs a bitwise logical XOR (exclusive OR) operation on the binary representation of two values. Each bit of the result is determined by evaluating the corresponding bits of the input values. If the bits are different (one bit is 0 and the other is 1), the resulting bit is set to 1. If the bits are the same (both 0 or both 1), the resulting bit is set to 0.\|syntax=xor r? a(r?{{!}}num) b(r?{{!}}num)}}		{{ICInstruction\|instruction=xor\|description=Performs a bitwise logical XOR (exclusive OR) operation on the binary representation of two values. Each bit of the result is determined by evaluating the corresponding bits of the input values. If the bits are different (one bit is 0 and the other is 1), the resulting bit is set to 1. If the bits are the same (both 0 or both 1), the resulting bit is set to 0.\|syntax=xor r? a(r?{{!}}num) b(r?{{!}}num)}}
	{{ICInstruction\|instruction=ext\|description=Extracts a bit field from a, beginning at b for c length and ~~placed~~ in the provided register. Payload cannot exceed 53 bits in final length.\|syntax=ext r? a(r?{{!}}num) b(r?{{!}}num) c(r?{{!}}num)}}		{{ICInstruction\|instruction=ext\|description=Extracts a bit field from source value, beginning at bit offset for length bits and places result in the provided register. Payload cannot exceed 53 bits in final length.\|syntax=ext r? source(r?{{!}}num) offset(r?{{!}}num) length(r?{{!}}num)}}
	{{ICInstruction\|instruction=ins\|description=Inserts a bit field into the provided register, beginning at bit offset for length bits. Payload cannot exceed 53 bits in final length. WARNING: Parameters order differs from documentation - offset and length come before field value.		{{ICInstruction\|instruction=ins\|description=Inserts a bit field into the provided register, beginning at bit offset for length bits. Payload cannot exceed 53 bits in final length. WARNING: Parameters order differs from documentation - offset and length come before field value.
	\|syntax=ins r? offset(r?{{!}}num) length(r?{{!}}num) field(r?{{!}}num)		\|syntax=ins r? offset(r?{{!}}num) length(r?{{!}}num) field(r?{{!}}num)