Newsgroups: rec.games.corewar From: DURHAM@ricevm1.rice.edu (Mark A. Durham) Subject: Intro to Redcode Part II Organization: Rice University, Houston, TX Date: Thu, 14 Nov 1991 09:45:13 GMT IV. Address Modes Addressing modes subtly (sometimes not-so-subtly) alter the behaviour of instructions. A somewhat brief description of their general properties is given here. Specifics will be left to the instruction set section. An octothorpe (#) is used to indicate an operand with an Immediate Address Mode. Immediate mode data is contained in the current instruction's field. If the A-mode is immediate, the data is in the A-field. If the B-mode is immediate, the data is in the B-field. If no mode indicator is present (86: or the US dollar sign '$' is present), Direct Address Mode is used. Direct addresses refer to instructions relative to the current instruction. Address 0 refers to the current instruction. Direct address -1 refers to the (physically) previous instruction. Direct address +1 refers to the (physically) next instruction. The commercial-at (@) is used to indicate Indirect Address Mode. In indirect addressing, the indirect address points to an instruction as in direct addressing, except the target is not the instruction to which the indirect address points but rather the instruction pointed to by the B-field of the instruct pointed to by the indirect address. Example: x-2 DAT #0, #0 ; Target instruction. x-1 DAT #0, #-1 ; Pointer instruction. x MOV 0, @-1 ; Copies this instruction to location x-2. The less-than (<) is used to indicate (86: Auto-, 88: Pre-) Decrement Indirect Address Mode. Its behaviour is just like that of Indirect Address Mode, except the pointer is decremented before use. Example: x-2 DAT #0, #0 ; Target instruction x-1 DAT #0, #0 ; Pointer instruction. Compare to @ example. x MOV 0, <-1 ; Copies this instruction to location x-2. Commentary: Although Decrement Indirect addressing appears to be a simple extension of Indirect addressing, it is really very tricky at times - especially when combined with DJN. There are sematic differences between the '86 and '88 standards, thus the change in name from Auto-Decrement to Pre-Decrement. These differences are discussed below. This discussion is non-essential for the average Redcode programmer. I suggesting skipping to the next section for the weak-stomached. 86: Durham: Instructions are fetched from memory into an instruction register. Each operand is evaluated, storing a location (into an address register) and an instruction (into a value register) for each operand. After the operands have been evaluated, the instruction is executed. Operand Evaluation: If the mode is immediate, the address register is loaded with 0 (the current instruction's address) and the value register is loaded with the current instruction. If the mode is direct, the address register is loaded with the field value and the value register is loaded with the instruction pointed to by the address register. If the mode is indirect, the address register is loaded with the sum of the field value and the B-field value of the instruction pointed to by the field value and the value register is loaded with the instruction pointed to by the address register. If the mode is auto-decrement, the address register is loaded with a value one less than the sum of the field value and the B-field value of the instruction pointed to by the field value and the value register is loaded with the instruction pointed to by the address register. AFTER the operands have been evaluated (but before instruction execution), if either mode was auto-decrement, the appropriate memory location is decremented. If both modes were auto-decrement and both fields pointed to the same pointer, that memory location is decremented twice. Note that this instruction in memory then points to a different instruction than either operand and also differs from any copies of it in registers. 86: Other: As above, except there are no registers. Everything is done in memory. Commentary: ICWS'86 clearly states the use of an instruction register, but the other operand address and value registers are only implied. Ambiguities and lack of strong statements delineating what takes place in memory and what takes place in registers condemned ICWS'86 to eternal confusion and gave birth to ICWS'88. 88: As above except everything is done in memory and Pre-Decrement Indirect replaces Auto-Decrement Indirect. Pre-Decrement Indirect decrements memory as it is evaluating the operands rather than after. It evaluates operand A before evaluating operand B. ---------------------------------------------------------------------- V. Instruction Set DAT A, B The DAT (data) instruction serves two purposes. First, it allows you to store data for use as pointers, offsets, etc. Second, any task which executes a DAT instruction is removed from the task queue. When all of warrior's tasks have been removed from the queue, that warrior has lost. 86: DAT allows only one operand - the B-operand. The A-field is left undefined (the example shows #0), but comparisons of DAT instructions with identical B-operands must yield equality. 88: DAT allows two operands but only two modes - immediate and pre-decrement. X: DAT takes one or two operands and accepts all modes. If only one operand is present, that operand is considered to be the B-operand and the A-operand defaults to #0. Commentary: It is important to note that any decrement(s) WILL occur before the task is removed from the queue since the instruction executes only after the operand evaluation. MOV A, B The MOV (move) instruction either copies a field value (if either mode is immediate) or an entire instruction (if neither mode is immediate) to another location in core (from A to B). 86: Durham: MOV #a, #b changes itself to MOV #a, #a. Commentary: There is a clear typographical error in ICWS'86 which changes the interpretation of MOV #a, B to something non-sensical. For those with a copy of ICWS'86, delete the term "B-field" from the next-to-last line of the second column on page 4. 88: No immediate B-modes are allowed. X: Immediate B-modes are allowed and have the same effect as a B-operand of 0. (See 86: Durham: above). ADD A, B 86: The ADD instruction adds the value at the A-location to the value at the B-location, replacing the B-location's old contents. 88: If the A-mode is immediate, ADD is interpreted as above. If the A-mode is not immediate, both the A-field and the B-field of the instruction pointed to by the A-operand are added to the A-field and B-field of the instruction pointed to by the B-operand, respectively. The B-mode can not be immediate. X: Immediate B-modes are allowed and have the same effect as in 86:. Example: ADD #2, #3 becomes ADD #2, #5 when executed once. SUB A, B The SUB (subtract) instruction is interpreted as above for all three cases, except A is subtracted from B. JMP A, B The JMP (jump) instruction changes the instruction pointer to point to the instruction pointed to by the A-operand. 86: JMP allows only one operand - the A-operand. The B-operand is shown as #0. 88: JMP allows both operands, but the A-mode can not be immediate. X: JMP allows both operands and the A-mode can be immediate. An immediate A-mode operand is treated just like JMP 0, B when executed. JMZ A, B The JMZ (jump if zero) instruction jumps to the instruction pointed to by the A-operand only if the B-field of the instruction pointed to by the B-operand is zero. 88: Immediate A-modes are not allowed. JMN A, B The JMN (jump if non-zero) instruction jumps to the instruction pointed to by the A-operand only if the B-field of the instruction pointed to by the B-operand is non-zero. 88: Immediate A-modes are not allowed. DJN A, B The DJN (decrement and jump if non-zero) instruction causes the B-field of the instruction pointed to by the B-operand to be decremented. If the decremented values is non-zero, a jump to the instruction pointed to by the A-operand is taken. 88: Immediate A-modes are not allowed. CMP A, B The CMP (compare, skip if equal) instruction compares two fields (if either mode is immediate) or two entire instructions (if neither mode is immediate) and skips the next instruction if the two are equivalent. Commentary: There is a clear typographical error in ICWS'86 which changes the interpretation of CMP #a, B to something non-sensical. For those with a copy of ICWS'86, delete the term "B-field" from the fifth line from the bottom of the second column on page 5. Also, the comments to the example on page 6 have been switched (equal is not equal and vice versa). The labels are correct though. 88: Immediate B-modes are not allowed. SPL A, B The SPL (split) instruction splits the execution between this warrior's currently running tasks and a new task. Example: A battle between two warriors, 1 and 2, where warrior 1 has two tasks (1 and 1') and warrior 2 has only one task would look like this: 1, 2, 1', 2, 1, 2, 1', 2, etc. 86: SPL allows only one operand - the B-operand. The A-operand is shown as #0. After executing the SPL, the next instruction to execute for this warrior is that of the newly added task (the new task is placed at the front of the task queue). A maximum of 64 tasks is allowed for each warrior. 88: SPL splits the A-operand, not the B-operand. After executing the SPL, the next instruction to execute for this warrior is the same instruction which would have executed had another task not been added (the new task is placed at the back of the task queue). There is no explicit task limit on warriors. Immediate A-operands are not allowed. X: Immediate A-operands are allowed and behave as SPL 0, B when executed. 88: SLT A, B: The SLT (skip if less than) instruction skips the next instruction if A is less than B. No Immediate B-modes are allowed. X: Immediate B-modes are allowed. X: XCH A, B: The XCH (exchange) instructions exchanges the A-field and the B-field of the instruction pointed to by the A-operand. X: PCT A, B: The PCT (protect) instruction protects the instruction pointed to by the A-operand until the protection is removed by an instruction attempting to copy over the protected instruction. Pseudo-Ops: Instructions to the Assembler ----------------------------------------- END The END pseudo-op indicates the end of the Redcode source program. 86: END takes no operands. 88: If END is followed by a label, the first instruction to be executed is that with the label following END. X: ORG A (origin) takes over this initial instruction function from END. Commentary: If no initial instruction is identified, the first instruction of your program will be the initial instruction. You can accomplish the same effect as "END start" or "ORG start" by merely starting your program with the instruction "JMP start". 86: SPACE A, B: The SPACE pseudo-op helps pretty-up Redcode source listings. SPACE A, B means to skip A lines, then keep B lines on the next page. Some assemblers do not support SPACE, but will treat it as a comment. 88: label EQU A: The EQU (equate) pseudo-op gives the programmer a macro-like facility by replacing every subsequent occurrence of the label "label" with the string "A". Commentary: A normal label is a relative thing. Example: x DAT #0, #x ; Here x is used in the B-field x+1 DAT #0, #x ; Each instruction's B-field gives x+2 DAT #0, #x ; the offset to x. is the same as x DAT #0, #0 ; Offset of zero x+1 DAT #0, #-1 ; one x+2 DAT #0, #-2 ; two but x! EQU 0 ; Equate label like #define x! 0 DAT #0, #x! ; Exclamation points can be used DAT #0, #x! ; in labels (in Extended systems) DAT #0, #x! ; I use them exclusively to indicate ; immediate equate labels. is the same as DAT #0, #0 ; A direct text replacement DAT #0, #0 ; appears the same on every DAT #0, #0 ; line it is used. ----------------------------------------------------------------------