{ "version": 2, "sourceCommit": "ac3d34ea65c3b8349c4f6c00306bade9e3fec5c9", "registerNames": [ "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3", "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7", "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "t8", "t9", "k0", "k1", "gp", "sp", "fp", "ra" ], "records": [ { "name": "add", "group": "Integer arithmetic", "syntax": "add d, s, t", "description": "Add signed integers; raise an exception on signed overflow.", "example": "add $t0, $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 32, "role": "" } ], "sourcePattern": "000000 sssss ttttt fffff 00000 100000", "sourceSyntax": "add $t1,$t2,$t3", "mask": 4227860479, "match": 32, "opcode": 0, "funct": 32, "fmt": null, "sampleValues": { "rs": 9, "rt": 10, "rd": 8 }, "exampleWord": 19546144, "context": "" }, { "name": "addu", "group": "Integer arithmetic", "syntax": "addu d, s, t", "description": "Add and keep the low 32 bits; no overflow exception.", "example": "addu $t0, $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 33, "role": "" } ], "sourcePattern": "000000 sssss ttttt fffff 00000 100001", "sourceSyntax": "addu $t1,$t2,$t3", "mask": 4227860479, "match": 33, "opcode": 0, "funct": 33, "fmt": null, "sampleValues": { "rs": 9, "rt": 10, "rd": 8 }, "exampleWord": 19546145, "context": "" }, { "name": "addi", "group": "Integer arithmetic", "syntax": "addi t, s, imm", "description": "Add a sign-extended 16-bit immediate; trap on signed overflow.", "example": "addi $t0, $t1, -1", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 8, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "imm" } ], "immediate": "signed", "note": "The immediate is sign-extended, including for sltiu.", "sourcePattern": "001000 sssss fffff tttttttttttttttt", "sourceSyntax": "addi $t1,$t2,-100", "mask": 4227858432, "match": 536870912, "opcode": 8, "funct": null, "fmt": null, "sampleValues": { "rs": 9, "rt": 8, "immediate": -1 }, "exampleWord": 556335103, "context": "" }, { "name": "addiu", "group": "Integer arithmetic", "syntax": "addiu t, s, imm", "description": "The immediate is still sign-extended; no overflow exception.", "example": "addiu $sp, $sp, -16", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 9, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "imm" } ], "immediate": "signed", "note": "The immediate is sign-extended, including for sltiu.", "sourcePattern": "001001 sssss fffff tttttttttttttttt", "sourceSyntax": "addiu $t1,$t2,-100", "mask": 4227858432, "match": 603979776, "opcode": 9, "funct": null, "fmt": null, "sampleValues": { "rs": 29, "rt": 29, "immediate": -16 }, "exampleWord": 666763248, "context": "" }, { "name": "sub", "group": "Integer arithmetic", "syntax": "sub d, s, t", "description": "Subtract t from s; trap on signed overflow.", "example": "sub $t0, $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 34, "role": "" } ], "sourcePattern": "000000 sssss ttttt fffff 00000 100010", "sourceSyntax": "sub $t1,$t2,$t3", "mask": 4227860479, "match": 34, "opcode": 0, "funct": 34, "fmt": null, "sampleValues": { "rs": 9, "rt": 10, "rd": 8 }, "exampleWord": 19546146, "context": "" }, { "name": "subu", "group": "Integer arithmetic", "syntax": "subu d, s, t", "description": "Subtract and keep the low 32 bits; no overflow exception.", "example": "subu $t0, $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 35, "role": "" } ], "sourcePattern": "000000 sssss ttttt fffff 00000 100011", "sourceSyntax": "subu $t1,$t2,$t3", "mask": 4227860479, "match": 35, "opcode": 0, "funct": 35, "fmt": null, "sampleValues": { "rs": 9, "rt": 10, "rd": 8 }, "exampleWord": 19546147, "context": "" }, { "name": "mul", "group": "Integer arithmetic", "syntax": "mul d, s, t", "description": "A real instruction in classic MIPS32: keep the low 32 product bits. Do not rely on HI/LO afterward. Earlier targets may implement it as a pseudo-instruction.", "example": "mul $t0, $t1, $t2", "kind": "real", "format": "SPECIAL2 / R", "fields": [ { "name": "opcode", "width": 6, "value": 28, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 2, "role": "" } ], "sourcePattern": "011100 sssss ttttt fffff 00000 000010", "sourceSyntax": "mul $t1,$t2,$t3", "mask": 4227860479, "match": 1879048194, "opcode": 28, "funct": 2, "fmt": null, "sampleValues": { "rs": 9, "rt": 10, "rd": 8 }, "exampleWord": 1898594306, "context": "" }, { "name": "mult", "group": "Integer arithmetic", "syntax": "mult s, t", "description": "Multiply two signed 32-bit integers. Write the signed 64-bit product to HI:LO.", "example": "mult $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": 0, "role": "" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 24, "role": "" } ], "sourcePattern": "000000 fffff sssss 00000 00000 011000", "sourceSyntax": "mult $t1,$t2", "mask": 4227923967, "match": 24, "opcode": 0, "funct": 24, "fmt": null, "sampleValues": { "rs": 9, "rt": 10 }, "exampleWord": 19529752, "context": "" }, { "name": "multu", "group": "Integer arithmetic", "syntax": "multu s, t", "description": "Multiply two unsigned 32-bit integers. Write the unsigned 64-bit product to HI:LO.", "example": "multu $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": 0, "role": "" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 25, "role": "" } ], "sourcePattern": "000000 fffff sssss 00000 00000 011001", "sourceSyntax": "multu $t1,$t2", "mask": 4227923967, "match": 25, "opcode": 0, "funct": 25, "fmt": null, "sampleValues": { "rs": 9, "rt": 10 }, "exampleWord": 19529753, "context": "" }, { "name": "div", "group": "Integer arithmetic", "syntax": "div s, t", "description": "Divide signed s by signed t. LO receives the quotient, truncated toward zero; HI receives the remainder. Check division by zero and INT_MIN / -1 first.", "example": "div $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": 0, "role": "" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 26, "role": "" } ], "sourcePattern": "000000 fffff sssss 00000 00000 011010", "sourceSyntax": "div $t1,$t2", "mask": 4227923967, "match": 26, "opcode": 0, "funct": 26, "fmt": null, "sampleValues": { "rs": 9, "rt": 10 }, "exampleWord": 19529754, "context": "" }, { "name": "divu", "group": "Integer arithmetic", "syntax": "divu s, t", "description": "Divide unsigned s by unsigned t. LO receives the quotient; HI receives the remainder. Check division by zero first.", "example": "divu $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": 0, "role": "" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 27, "role": "" } ], "sourcePattern": "000000 fffff sssss 00000 00000 011011", "sourceSyntax": "divu $t1,$t2", "mask": 4227923967, "match": 27, "opcode": 0, "funct": 27, "fmt": null, "sampleValues": { "rs": 9, "rt": 10 }, "exampleWord": 19529755, "context": "" }, { "name": "mfhi", "group": "Integer arithmetic", "syntax": "mfhi d", "description": "Copy the contents of HI into general-purpose register d; use this to retrieve a division remainder or the high half of a multiplication result.", "example": "mfhi $t0", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": 0, "role": "" }, { "name": "rt", "width": 5, "value": 0, "role": "" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 16, "role": "" } ], "sourcePattern": "000000 00000 00000 fffff 00000 010000", "sourceSyntax": "mfhi $t1", "mask": 4294903807, "match": 16, "opcode": 0, "funct": 16, "fmt": null, "sampleValues": { "rd": 8 }, "exampleWord": 16400, "context": "" }, { "name": "mflo", "group": "Integer arithmetic", "syntax": "mflo d", "description": "Copy the contents of LO into general-purpose register d; use this to retrieve a division quotient or the low half of a multiplication result.", "example": "mflo $t0", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": 0, "role": "" }, { "name": "rt", "width": 5, "value": 0, "role": "" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 18, "role": "" } ], "sourcePattern": "000000 00000 00000 fffff 00000 010010", "sourceSyntax": "mflo $t1", "mask": 4294903807, "match": 18, "opcode": 0, "funct": 18, "fmt": null, "sampleValues": { "rd": 8 }, "exampleWord": 16402, "context": "" }, { "name": "mthi", "group": "Integer arithmetic", "syntax": "mthi s", "description": "Copy general-purpose register s into HI. LO is unchanged.", "example": "mthi $t0", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": 0, "role": "" }, { "name": "rd", "width": 5, "value": 0, "role": "" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 17, "role": "" } ], "sourcePattern": "000000 fffff 00000 00000 00000 010001", "sourceSyntax": "mthi $t1", "mask": 4229955583, "match": 17, "opcode": 0, "funct": 17, "fmt": null, "sampleValues": { "rs": 8 }, "exampleWord": 16777233, "context": "" }, { "name": "mtlo", "group": "Integer arithmetic", "syntax": "mtlo s", "description": "Copy general-purpose register s into LO. HI is unchanged.", "example": "mtlo $t0", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": 0, "role": "" }, { "name": "rd", "width": 5, "value": 0, "role": "" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 19, "role": "" } ], "sourcePattern": "000000 fffff 00000 00000 00000 010011", "sourceSyntax": "mtlo $t1", "mask": 4229955583, "match": 19, "opcode": 0, "funct": 19, "fmt": null, "sampleValues": { "rs": 8 }, "exampleWord": 16777235, "context": "" }, { "name": "neg", "group": "Integer arithmetic", "syntax": "neg d, s", "description": "Compute d = 0 − s as a signed operation. Signed overflow raises an exception; negating INT_MIN cannot be represented.", "example": "neg $t0, $t1", "kind": "pseudo", "expansion": { "code": "sub d, $zero, s", "note": "Pinned MARS expansion for this operand form.", "count": "1", "sourceForm": "neg $t1,$t2" } }, { "name": "negu", "group": "Integer arithmetic", "syntax": "negu d, s", "description": "Compute d = 0 − s modulo 2^32. No signed-overflow exception is raised.", "example": "negu $t0, $t1", "kind": "pseudo", "expansion": { "code": "subu d, $zero, s", "note": "Pinned MARS expansion for this operand form.", "count": "1", "sourceForm": "negu $t1,$t2" } }, { "name": "abs", "group": "Integer arithmetic", "syntax": "abs d, s", "description": "Signed absolute value. The absolute value of INT_MIN is not representable as a signed 32-bit integer.", "example": "abs $t0, $t1", "kind": "pseudo", "expansion": { "code": "sra $at, s, 31\nxor d, $at, s\nsubu d, d, $at", "note": "3 real instructions. Clobbers $at. The pinned sequence returns INT_MIN unchanged for INT_MIN; it does not trap on that unrepresentable positive absolute value.", "count": "3", "sourceForm": "abs $t1,$t2" } }, { "name": "rem", "group": "Integer arithmetic", "syntax": "rem d, s, t", "description": "Compute the signed remainder s % t. Commonly expands to signed division and a read of HI. Check division boundaries first.", "example": "rem $t0, $t1, $t2", "kind": "pseudo", "expansion": { "code": "bne t, $zero, do_divide\n# nop here only when delayed branching is enabled\nbreak\ndo_divide:\ndiv s, t\nmfhi d", "note": "Pinned MARS inserts a divisor-zero guard. With delayed branching enabled, insert nop immediately after bne; the internal target still resolves to the divide instruction. Clobbers HI/LO. Signed overflow boundaries still need a caller check. The label here is explanatory and must be unique if used in source.", "count": "4–5", "sourceForm": "rem $t1,$t2,$t3" } }, { "name": "remu", "group": "Integer arithmetic", "syntax": "remu d, s, t", "description": "Compute the unsigned remainder s % t. Commonly expands to unsigned division and a read of HI. The divisor must be nonzero.", "example": "remu $t0, $t1, $t2", "kind": "pseudo", "expansion": { "code": "bne t, $zero, do_divide\n# nop here only when delayed branching is enabled\nbreak\ndo_divide:\ndivu s, t\nmfhi d", "note": "Pinned MARS inserts a divisor-zero guard. With delayed branching enabled, insert nop immediately after bne; the internal target still resolves to the divide instruction. Clobbers HI/LO. Signed overflow boundaries still need a caller check. The label here is explanatory and must be unique if used in source.", "count": "4–5", "sourceForm": "remu $t1,$t2,$t3" } }, { "name": "and", "group": "Bitwise operations and shifts", "syntax": "and d, s, t", "description": "Bitwise AND: each result bit is 1 only when both corresponding operand bits are 1. d = s AND t.", "example": "and $t0, $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 36, "role": "" } ], "sourcePattern": "000000 sssss ttttt fffff 00000 100100", "sourceSyntax": "and $t1,$t2,$t3", "mask": 4227860479, "match": 36, "opcode": 0, "funct": 36, "fmt": null, "sampleValues": { "rs": 9, "rt": 10, "rd": 8 }, "exampleWord": 19546148, "context": "" }, { "name": "or", "group": "Bitwise operations and shifts", "syntax": "or d, s, t", "description": "Bitwise OR: each result bit is 1 when either corresponding operand bit is 1. d = s OR t.", "example": "or $t0, $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 37, "role": "" } ], "sourcePattern": "000000 sssss ttttt fffff 00000 100101", "sourceSyntax": "or $t1,$t2,$t3", "mask": 4227860479, "match": 37, "opcode": 0, "funct": 37, "fmt": null, "sampleValues": { "rs": 9, "rt": 10, "rd": 8 }, "exampleWord": 19546149, "context": "" }, { "name": "xor", "group": "Bitwise operations and shifts", "syntax": "xor d, s, t", "description": "Bitwise exclusive OR: each result bit is 1 when the corresponding operand bits differ. d = s XOR t.", "example": "xor $t0, $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 38, "role": "" } ], "sourcePattern": "000000 sssss ttttt fffff 00000 100110", "sourceSyntax": "xor $t1,$t2,$t3", "mask": 4227860479, "match": 38, "opcode": 0, "funct": 38, "fmt": null, "sampleValues": { "rs": 9, "rt": 10, "rd": 8 }, "exampleWord": 19546150, "context": "" }, { "name": "nor", "group": "Bitwise operations and shifts", "syntax": "nor d, s, t", "description": "Compute ~(s OR t).", "example": "nor $t0, $t1, $zero", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 39, "role": "" } ], "sourcePattern": "000000 sssss ttttt fffff 00000 100111", "sourceSyntax": "nor $t1,$t2,$t3", "mask": 4227860479, "match": 39, "opcode": 0, "funct": 39, "fmt": null, "sampleValues": { "rs": 9, "rt": 0, "rd": 8 }, "exampleWord": 18890791, "context": "" }, { "name": "andi", "group": "Bitwise operations and shifts", "syntax": "andi t, s, imm", "description": "Zero-extend the 16-bit immediate, then compute t = s AND immediate. Useful for masking bits; immediate range 0…65535.", "example": "andi $t0, $t1, 0x00ff", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 12, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "imm" } ], "immediate": "unsigned", "note": "The immediate is a 16-bit unsigned field.", "sourcePattern": "001100 sssss fffff tttttttttttttttt", "sourceSyntax": "andi $t1,$t2,100", "mask": 4227858432, "match": 805306368, "opcode": 12, "funct": null, "fmt": null, "sampleValues": { "rs": 9, "rt": 8, "immediate": 255 }, "exampleWord": 824705279, "context": "" }, { "name": "ori", "group": "Bitwise operations and shifts", "syntax": "ori t, s, imm", "description": "Zero-extend the 16-bit immediate, then compute t = s OR immediate. Useful for setting bits; immediate range 0…65535.", "example": "ori $t0, $t1, 0x00ff", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 13, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "imm" } ], "immediate": "unsigned", "note": "The immediate is a 16-bit unsigned field.", "sourcePattern": "001101 sssss fffff tttttttttttttttt", "sourceSyntax": "ori $t1,$t2,100", "mask": 4227858432, "match": 872415232, "opcode": 13, "funct": null, "fmt": null, "sampleValues": { "rs": 9, "rt": 8, "immediate": 255 }, "exampleWord": 891814143, "context": "" }, { "name": "xori", "group": "Bitwise operations and shifts", "syntax": "xori t, s, imm", "description": "Zero-extend the 16-bit immediate, then compute t = s XOR immediate. Useful for toggling bits; immediate range 0…65535.", "example": "xori $t0, $t1, 0x00ff", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 14, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "imm" } ], "immediate": "unsigned", "note": "The immediate is a 16-bit unsigned field.", "sourcePattern": "001110 sssss fffff tttttttttttttttt", "sourceSyntax": "xori $t1,$t2,100", "mask": 4227858432, "match": 939524096, "opcode": 14, "funct": null, "fmt": null, "sampleValues": { "rs": 9, "rt": 8, "immediate": 255 }, "exampleWord": 958923007, "context": "" }, { "name": "lui", "group": "Bitwise operations and shifts", "syntax": "lui t, imm", "description": "Place the immediate in the upper 16 bits; clear the lower 16 bits.", "example": "lui $t0, 0x1234", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 15, "role": "" }, { "name": "rs", "width": 5, "value": 0, "role": "" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "imm" } ], "immediate": "unsigned", "note": "The immediate is a 16-bit unsigned field.", "sourcePattern": "001111 00000 fffff ssssssssssssssss", "sourceSyntax": "lui $t1,100", "mask": 4292870144, "match": 1006632960, "opcode": 15, "funct": null, "fmt": null, "sampleValues": { "rt": 8, "immediate": 4660 }, "exampleWord": 1007161908, "context": "" }, { "name": "sll", "group": "Bitwise operations and shifts", "syntax": "sll d, t, shamt", "description": "Shift t left by shamt bits, fill low bits with zeroes and discard high bits. The immediate shift count is 0…31.", "example": "sll $t0, $t1, 3", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": 0, "role": "" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": null, "role": "shamt" }, { "name": "funct", "width": 6, "value": 0, "role": "" } ], "sourcePattern": "000000 00000 sssss fffff ttttt 000000", "sourceSyntax": "sll $t1,$t2,10", "mask": 4292870207, "match": 0, "opcode": 0, "funct": 0, "fmt": null, "sampleValues": { "rt": 9, "rd": 8, "shamt": 3 }, "exampleWord": 606400, "context": "" }, { "name": "srl", "group": "Bitwise operations and shifts", "syntax": "srl d, t, shamt", "description": "Shift t right logically by shamt bits, filling high bits with zeroes. The immediate shift count is 0…31.", "example": "srl $t0, $t1, 3", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": 0, "role": "" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": null, "role": "shamt" }, { "name": "funct", "width": 6, "value": 2, "role": "" } ], "sourcePattern": "000000 00000 sssss fffff ttttt 000010", "sourceSyntax": "srl $t1,$t2,10", "mask": 4292870207, "match": 2, "opcode": 0, "funct": 2, "fmt": null, "sampleValues": { "rt": 9, "rd": 8, "shamt": 3 }, "exampleWord": 606402, "context": "" }, { "name": "sra", "group": "Bitwise operations and shifts", "syntax": "sra d, t, shamt", "description": "Shift t right arithmetically by shamt bits, replicating the sign bit. The immediate shift count is 0…31.", "example": "sra $t0, $t1, 3", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": 0, "role": "" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": null, "role": "shamt" }, { "name": "funct", "width": 6, "value": 3, "role": "" } ], "sourcePattern": "000000 00000 sssss fffff ttttt 000011", "sourceSyntax": "sra $t1,$t2,10", "mask": 4292870207, "match": 3, "opcode": 0, "funct": 3, "fmt": null, "sampleValues": { "rt": 9, "rd": 8, "shamt": 3 }, "exampleWord": 606403, "context": "" }, { "name": "sllv", "group": "Bitwise operations and shifts", "syntax": "sllv d, t, s", "description": "Shift t left by the count in the low 5 bits of s. Fill low bits with zeroes; discard high bits. Operand order is destination, value, count.", "example": "sllv $t0, $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 4, "role": "" } ], "sourcePattern": "000000 ttttt sssss fffff 00000 000100", "sourceSyntax": "sllv $t1,$t2,$t3", "mask": 4227860479, "match": 4, "opcode": 0, "funct": 4, "fmt": null, "sampleValues": { "rs": 10, "rt": 9, "rd": 8 }, "exampleWord": 21577732, "context": "" }, { "name": "srlv", "group": "Bitwise operations and shifts", "syntax": "srlv d, t, s", "description": "Shift t right logically by the count in the low 5 bits of s. Fill high bits with zeroes. Operand order is destination, value, count.", "example": "srlv $t0, $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 6, "role": "" } ], "sourcePattern": "000000 ttttt sssss fffff 00000 000110", "sourceSyntax": "srlv $t1,$t2,$t3", "mask": 4227860479, "match": 6, "opcode": 0, "funct": 6, "fmt": null, "sampleValues": { "rs": 10, "rt": 9, "rd": 8 }, "exampleWord": 21577734, "context": "" }, { "name": "srav", "group": "Bitwise operations and shifts", "syntax": "srav d, t, s", "description": "Shift t right arithmetically by the count in the low 5 bits of s. Replicate the sign bit. Operand order is destination, value, count.", "example": "srav $t0, $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 7, "role": "" } ], "sourcePattern": "000000 ttttt sssss fffff 00000 000111", "sourceSyntax": "srav $t1,$t2,$t3", "mask": 4227860479, "match": 7, "opcode": 0, "funct": 7, "fmt": null, "sampleValues": { "rs": 10, "rt": 9, "rd": 8 }, "exampleWord": 21577735, "context": "" }, { "name": "not", "group": "Bitwise operations and shifts", "syntax": "not d, s", "description": "Invert every bit; commonly expands to nor d, s, $zero.", "example": "not $t0, $t1", "kind": "pseudo", "expansion": { "code": "nor d, s, $zero", "note": "Pinned MARS expansion for this operand form.", "count": "1", "sourceForm": "not $t1,$t2" } }, { "name": "slt", "group": "Comparisons and branches", "syntax": "slt d, s, t", "description": "Compare s and t as signed 32-bit integers. Write 1 to d if s < t; otherwise write 0.", "example": "slt $t0, $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 42, "role": "" } ], "sourcePattern": "000000 sssss ttttt fffff 00000 101010", "sourceSyntax": "slt $t1,$t2,$t3", "mask": 4227860479, "match": 42, "opcode": 0, "funct": 42, "fmt": null, "sampleValues": { "rs": 9, "rt": 10, "rd": 8 }, "exampleWord": 19546154, "context": "" }, { "name": "sltu", "group": "Comparisons and branches", "syntax": "sltu d, s, t", "description": "Compare s and t as unsigned 32-bit integers. Write 1 to d if s < t; otherwise write 0.", "example": "sltu $t0, $t1, $t2", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 43, "role": "" } ], "sourcePattern": "000000 sssss ttttt fffff 00000 101011", "sourceSyntax": "sltu $t1,$t2,$t3", "mask": 4227860479, "match": 43, "opcode": 0, "funct": 43, "fmt": null, "sampleValues": { "rs": 9, "rt": 10, "rd": 8 }, "exampleWord": 19546155, "context": "" }, { "name": "slti", "group": "Comparisons and branches", "syntax": "slti t, s, imm", "description": "Sign-extend the 16-bit immediate, then compare it with signed s. Write 1 to t if s is less; otherwise write 0.", "example": "slti $t0, $t1, 10", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 10, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "imm" } ], "immediate": "signed", "note": "The immediate is sign-extended, including for sltiu.", "sourcePattern": "001010 sssss fffff tttttttttttttttt", "sourceSyntax": "slti $t1,$t2,-100", "mask": 4227858432, "match": 671088640, "opcode": 10, "funct": null, "fmt": null, "sampleValues": { "rs": 9, "rt": 8, "immediate": 10 }, "exampleWord": 690487306, "context": "" }, { "name": "sltiu", "group": "Comparisons and branches", "syntax": "sltiu t, s, imm", "description": "Sign-extend the 16-bit immediate, then interpret both operands as unsigned. Write 1 to t if s is less; otherwise write 0. The immediate is not zero-extended.", "example": "sltiu $t0, $t1, 10", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 11, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "imm" } ], "immediate": "signed", "note": "The immediate is sign-extended, including for sltiu.", "sourcePattern": "001011 sssss fffff tttttttttttttttt", "sourceSyntax": "sltiu $t1,$t2,-100", "mask": 4227858432, "match": 738197504, "opcode": 11, "funct": null, "fmt": null, "sampleValues": { "rs": 9, "rt": 8, "immediate": 10 }, "exampleWord": 757596170, "context": "" }, { "name": "beq", "group": "Comparisons and branches", "syntax": "beq s, t, label", "description": "Branch to label if register s equals register t; otherwise continue. The real instruction compares two registers.", "example": "beq $t0, $t1, equal", "kind": "real", "format": "I / branch", "fields": [ { "name": "opcode", "width": 6, "value": 4, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "offset", "width": 16, "value": null, "role": "branchOffset" } ], "immediate": "signed", "branch": true, "note": "offset = (target − (PC + 4)) / 4, signed 16 bits. Fixed rt bits select the condition where shown; there is no funct field.", "sourcePattern": "000100 fffff sssss tttttttttttttttt", "sourceSyntax": "beq $t1,$t2,label", "mask": 4227858432, "match": 268435456, "opcode": 4, "funct": null, "fmt": null, "sampleValues": { "rs": 8, "rt": 9, "offset": 7 }, "exampleWord": 285802503, "context": "For this encoded example, assume PC = 0x00400000 and label = 0x00400020. The label in the example is illustrative." }, { "name": "bne", "group": "Comparisons and branches", "syntax": "bne s, t, label", "description": "Branch to label if register s differs from register t; otherwise continue. The real instruction compares two registers.", "example": "bne $t0, $t1, different", "kind": "real", "format": "I / branch", "fields": [ { "name": "opcode", "width": 6, "value": 5, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "offset", "width": 16, "value": null, "role": "branchOffset" } ], "immediate": "signed", "branch": true, "note": "offset = (target − (PC + 4)) / 4, signed 16 bits. Fixed rt bits select the condition where shown; there is no funct field.", "sourcePattern": "000101 fffff sssss tttttttttttttttt", "sourceSyntax": "bne $t1,$t2,label", "mask": 4227858432, "match": 335544320, "opcode": 5, "funct": null, "fmt": null, "sampleValues": { "rs": 8, "rt": 9, "offset": 7 }, "exampleWord": 352911367, "context": "For this encoded example, assume PC = 0x00400000 and label = 0x00400020. The label in the example is illustrative." }, { "name": "bgez", "group": "Comparisons and branches", "syntax": "bgez s, label", "description": "Branch to label if s, interpreted as a signed integer, is greater than or equal to zero.", "example": "bgez $t0, nonnegative", "kind": "real", "format": "REGIMM / I", "fields": [ { "name": "opcode", "width": 6, "value": 1, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": 1, "role": "" }, { "name": "offset", "width": 16, "value": null, "role": "branchOffset" } ], "immediate": "signed", "branch": true, "note": "offset = (target − (PC + 4)) / 4, signed 16 bits. Fixed rt bits select the condition where shown; there is no funct field.", "sourcePattern": "000001 fffff 00001 ssssssssssssssss", "sourceSyntax": "bgez $t1,label", "mask": 4229890048, "match": 67174400, "opcode": 1, "funct": null, "fmt": null, "sampleValues": { "rs": 8, "offset": 7 }, "exampleWord": 83951623, "context": "For this encoded example, assume PC = 0x00400000 and label = 0x00400020. The label in the example is illustrative." }, { "name": "bgtz", "group": "Comparisons and branches", "syntax": "bgtz s, label", "description": "Branch to label if s, interpreted as a signed integer, is greater than zero.", "example": "bgtz $t0, positive", "kind": "real", "format": "I / branch", "fields": [ { "name": "opcode", "width": 6, "value": 7, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": 0, "role": "" }, { "name": "offset", "width": 16, "value": null, "role": "branchOffset" } ], "immediate": "signed", "branch": true, "note": "offset = (target − (PC + 4)) / 4, signed 16 bits. Fixed rt bits select the condition where shown; there is no funct field.", "sourcePattern": "000111 fffff 00000 ssssssssssssssss", "sourceSyntax": "bgtz $t1,label", "mask": 4229890048, "match": 469762048, "opcode": 7, "funct": null, "fmt": null, "sampleValues": { "rs": 8, "offset": 7 }, "exampleWord": 486539271, "context": "For this encoded example, assume PC = 0x00400000 and label = 0x00400020. The label in the example is illustrative." }, { "name": "blez", "group": "Comparisons and branches", "syntax": "blez s, label", "description": "Branch to label if s, interpreted as a signed integer, is less than or equal to zero.", "example": "blez $t0, nonpositive", "kind": "real", "format": "I / branch", "fields": [ { "name": "opcode", "width": 6, "value": 6, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": 0, "role": "" }, { "name": "offset", "width": 16, "value": null, "role": "branchOffset" } ], "immediate": "signed", "branch": true, "note": "offset = (target − (PC + 4)) / 4, signed 16 bits. Fixed rt bits select the condition where shown; there is no funct field.", "sourcePattern": "000110 fffff 00000 ssssssssssssssss", "sourceSyntax": "blez $t1,label", "mask": 4229890048, "match": 402653184, "opcode": 6, "funct": null, "fmt": null, "sampleValues": { "rs": 8, "offset": 7 }, "exampleWord": 419430407, "context": "For this encoded example, assume PC = 0x00400000 and label = 0x00400020. The label in the example is illustrative." }, { "name": "bltz", "group": "Comparisons and branches", "syntax": "bltz s, label", "description": "Branch to label if s, interpreted as a signed integer, is less than zero.", "example": "bltz $t0, negative", "kind": "real", "format": "REGIMM / I", "fields": [ { "name": "opcode", "width": 6, "value": 1, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": 0, "role": "" }, { "name": "offset", "width": 16, "value": null, "role": "branchOffset" } ], "immediate": "signed", "branch": true, "note": "offset = (target − (PC + 4)) / 4, signed 16 bits. Fixed rt bits select the condition where shown; there is no funct field.", "sourcePattern": "000001 fffff 00000 ssssssssssssssss", "sourceSyntax": "bltz $t1,label", "mask": 4229890048, "match": 67108864, "opcode": 1, "funct": null, "fmt": null, "sampleValues": { "rs": 8, "offset": 7 }, "exampleWord": 83886087, "context": "For this encoded example, assume PC = 0x00400000 and label = 0x00400020. The label in the example is illustrative." }, { "name": "beqz", "group": "Comparisons and branches", "syntax": "beqz s, label", "description": "Branch to label if s is zero. Commonly expands to beq s, $zero, label.", "example": "beqz $t0, is_zero", "kind": "pseudo", "expansion": { "code": "beq s, $zero, label", "note": "Pinned MARS expansion for this operand form. The expansion ends in a real branch; its following instruction is the delay slot when delayed branching is enabled. MARS does not automatically append a nop for these ordinary branch pseudos.", "count": "1", "sourceForm": "beqz $t1,label" } }, { "name": "bnez", "group": "Comparisons and branches", "syntax": "bnez s, label", "description": "Branch to label if s is nonzero. Commonly expands to bne s, $zero, label.", "example": "bnez $t0, nonzero", "kind": "pseudo", "expansion": { "code": "bne s, $zero, label", "note": "Pinned MARS expansion for this operand form. The expansion ends in a real branch; its following instruction is the delay slot when delayed branching is enabled. MARS does not automatically append a nop for these ordinary branch pseudos.", "count": "1", "sourceForm": "bnez $t1,label" } }, { "name": "blt", "group": "Comparisons and branches", "syntax": "blt s, t, label", "description": "Branch to label if signed s < signed t. Commonly expands to a signed comparison followed by a conditional branch.", "example": "blt $t0, $t1, less", "kind": "pseudo", "expansion": { "code": "slt $at, s, t\nbne $at, $zero, label", "note": "The expansion below follows the pinned MARS register-operand form. $at is register $1; reserve it for the assembler. The expansion ends in a real branch; its following instruction is the delay slot when delayed branching is enabled. MARS does not automatically append a nop for these ordinary branch pseudos.", "count": "2", "sourceForm": "blt $t1,$t2,label" } }, { "name": "ble", "group": "Comparisons and branches", "syntax": "ble s, t, label", "description": "Branch to label if signed s ≤ signed t. Expands to a comparison and a conditional branch.", "example": "ble $t0, $t1, less_or_equal", "kind": "pseudo", "expansion": { "code": "slt $at, t, s\nbeq $at, $zero, label", "note": "The expansion below follows the pinned MARS register-operand form. $at is register $1; reserve it for the assembler. The expansion ends in a real branch; its following instruction is the delay slot when delayed branching is enabled. MARS does not automatically append a nop for these ordinary branch pseudos.", "count": "2", "sourceForm": "ble $t1,$t2,label" } }, { "name": "bgt", "group": "Comparisons and branches", "syntax": "bgt s, t, label", "description": "Branch to label if signed s > signed t. Expands to a comparison and a conditional branch.", "example": "bgt $t0, $t1, greater", "kind": "pseudo", "expansion": { "code": "slt $at, t, s\nbne $at, $zero, label", "note": "The expansion below follows the pinned MARS register-operand form. $at is register $1; reserve it for the assembler. The expansion ends in a real branch; its following instruction is the delay slot when delayed branching is enabled. MARS does not automatically append a nop for these ordinary branch pseudos.", "count": "2", "sourceForm": "bgt $t1,$t2,label" } }, { "name": "bge", "group": "Comparisons and branches", "syntax": "bge s, t, label", "description": "Branch to label if signed s ≥ signed t. Expands to a comparison and a conditional branch.", "example": "bge $t0, $t1, greater_or_equal", "kind": "pseudo", "expansion": { "code": "slt $at, s, t\nbeq $at, $zero, label", "note": "The expansion below follows the pinned MARS register-operand form. $at is register $1; reserve it for the assembler. The expansion ends in a real branch; its following instruction is the delay slot when delayed branching is enabled. MARS does not automatically append a nop for these ordinary branch pseudos.", "count": "2", "sourceForm": "bge $t1,$t2,label" } }, { "name": "bltu", "group": "Comparisons and branches", "syntax": "bltu s, t, label", "description": "Branch to label if unsigned s < unsigned t. Expands to an unsigned comparison and a conditional branch.", "example": "bltu $t0, $t1, unsigned_less", "kind": "pseudo", "expansion": { "code": "sltu $at, s, t\nbne $at, $zero, label", "note": "The expansion below follows the pinned MARS register-operand form. $at is register $1; reserve it for the assembler. The expansion ends in a real branch; its following instruction is the delay slot when delayed branching is enabled. MARS does not automatically append a nop for these ordinary branch pseudos.", "count": "2", "sourceForm": "bltu $t1,$t2,label" } }, { "name": "bleu", "group": "Comparisons and branches", "syntax": "bleu s, t, label", "description": "Branch to label if unsigned s ≤ unsigned t. Expands to an unsigned comparison and a conditional branch.", "example": "bleu $t0, $t1, unsigned_less_or_equal", "kind": "pseudo", "expansion": { "code": "sltu $at, t, s\nbeq $at, $zero, label", "note": "The expansion below follows the pinned MARS register-operand form. $at is register $1; reserve it for the assembler. The expansion ends in a real branch; its following instruction is the delay slot when delayed branching is enabled. MARS does not automatically append a nop for these ordinary branch pseudos.", "count": "2", "sourceForm": "bleu $t1,$t2,label" } }, { "name": "bgtu", "group": "Comparisons and branches", "syntax": "bgtu s, t, label", "description": "Branch to label if unsigned s > unsigned t. Expands to an unsigned comparison and a conditional branch.", "example": "bgtu $t0, $t1, unsigned_greater", "kind": "pseudo", "expansion": { "code": "sltu $at, t, s\nbne $at, $zero, label", "note": "The expansion below follows the pinned MARS register-operand form. $at is register $1; reserve it for the assembler. The expansion ends in a real branch; its following instruction is the delay slot when delayed branching is enabled. MARS does not automatically append a nop for these ordinary branch pseudos.", "count": "2", "sourceForm": "bgtu $t1,$t2,label" } }, { "name": "bgeu", "group": "Comparisons and branches", "syntax": "bgeu s, t, label", "description": "Branch to label if unsigned s ≥ unsigned t. Expands to an unsigned comparison and a conditional branch.", "example": "bgeu $t0, $t1, unsigned_greater_or_equal", "kind": "pseudo", "expansion": { "code": "sltu $at, s, t\nbeq $at, $zero, label", "note": "The expansion below follows the pinned MARS register-operand form. $at is register $1; reserve it for the assembler. The expansion ends in a real branch; its following instruction is the delay slot when delayed branching is enabled. MARS does not automatically append a nop for these ordinary branch pseudos.", "count": "2", "sourceForm": "bgeu $t1,$t2,label" } }, { "name": "b", "group": "Comparisons and branches", "syntax": "b label", "description": "Unconditional branch; commonly beq $zero, $zero, label.", "example": "b loop", "kind": "pseudo", "expansion": { "code": "bgez $zero, label", "note": "Pinned MARS expansion for this operand form. The expansion ends in a real branch; its following instruction is the delay slot when delayed branching is enabled. MARS does not automatically append a nop for these ordinary branch pseudos.", "count": "1", "sourceForm": "b label" } }, { "name": "seq", "group": "Comparisons and branches", "syntax": "seq d, s, t", "description": "Write 1 to d if s equals t; otherwise write 0. Equality compares the bit patterns.", "example": "seq $t0, $t1, $t2", "kind": "pseudo", "expansion": { "code": "subu d, s, t\nori $at, $zero, 1\nsltu d, d, $at", "note": "The expansion below follows the pinned MARS register-operand form. $at is register $1; reserve it for the assembler.", "count": "3", "sourceForm": "seq $t1,$t2,$t3" } }, { "name": "sne", "group": "Comparisons and branches", "syntax": "sne d, s, t", "description": "Write 1 to d if s differs from t; otherwise write 0. Equality compares the bit patterns.", "example": "sne $t0, $t1, $t2", "kind": "pseudo", "expansion": { "code": "subu d, s, t\nsltu d, $zero, d", "note": "Pinned MARS expansion for this operand form.", "count": "2", "sourceForm": "sne $t1,$t2,$t3" } }, { "name": "sle", "group": "Comparisons and branches", "syntax": "sle d, s, t", "description": "Write 1 to d if signed s ≤ signed t; otherwise write 0.", "example": "sle $t0, $t1, $t2", "kind": "pseudo", "expansion": { "code": "slt d, t, s\nori $at, $zero, 1\nsubu d, $at, d", "note": "The expansion below follows the pinned MARS register-operand form. $at is register $1; reserve it for the assembler.", "count": "3", "sourceForm": "sle $t1,$t2,$t3" } }, { "name": "sge", "group": "Comparisons and branches", "syntax": "sge d, s, t", "description": "Write 1 to d if signed s ≥ signed t; otherwise write 0.", "example": "sge $t0, $t1, $t2", "kind": "pseudo", "expansion": { "code": "slt d, s, t\nori $at, $zero, 1\nsubu d, $at, d", "note": "The expansion below follows the pinned MARS register-operand form. $at is register $1; reserve it for the assembler.", "count": "3", "sourceForm": "sge $t1,$t2,$t3" } }, { "name": "sgt", "group": "Comparisons and branches", "syntax": "sgt d, s, t", "description": "Write 1 to d if signed s > signed t; otherwise write 0.", "example": "sgt $t0, $t1, $t2", "kind": "pseudo", "expansion": { "code": "slt d, t, s", "note": "Pinned MARS expansion for this operand form.", "count": "1", "sourceForm": "sgt $t1,$t2,$t3" } }, { "name": "lw", "group": "Memory and addresses", "syntax": "lw t, offset(s)", "description": "Load a 32-bit word from memory into t. Address = s + sign-extended 16-bit byte offset. The address must be a multiple of 4.", "example": "lw $t0, 12($sp) # t0 = word at sp + 12", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 35, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "offset" } ], "immediate": "signed", "note": "The offset is signed and measured in bytes. The rt field identifies the value register, including for stores.", "sourcePattern": "100011 ttttt fffff ssssssssssssssss", "sourceSyntax": "lw $t1,-100($t2)", "mask": 4227858432, "match": 2348810240, "opcode": 35, "funct": null, "fmt": null, "sampleValues": { "rs": 29, "rt": 8, "immediate": 12 }, "exampleWord": 2410151948, "context": "" }, { "name": "sw", "group": "Memory and addresses", "syntax": "sw t, offset(s)", "description": "Store all 32 bits of t to memory. Address = s + sign-extended 16-bit byte offset. The address must be a multiple of 4; t is not modified.", "example": "sw $t0, 12($sp) # word at sp + 12 = t0", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 43, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "offset" } ], "immediate": "signed", "note": "The offset is signed and measured in bytes. The rt field identifies the value register, including for stores.", "sourcePattern": "101011 ttttt fffff ssssssssssssssss", "sourceSyntax": "sw $t1,-100($t2)", "mask": 4227858432, "match": 2885681152, "opcode": 43, "funct": null, "fmt": null, "sampleValues": { "rs": 29, "rt": 8, "immediate": 12 }, "exampleWord": 2947022860, "context": "" }, { "name": "lb", "group": "Memory and addresses", "syntax": "lb t, offset(s)", "description": "Load one 8-bit byte from memory into t and sign-extend it to 32 bits. Address = s + sign-extended 16-bit byte offset; no alignment restriction.", "example": "lb $t0, 0($a0) # 0xff becomes 0xffffffff", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 32, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "offset" } ], "immediate": "signed", "note": "The offset is signed and measured in bytes. The rt field identifies the value register, including for stores.", "sourcePattern": "100000 ttttt fffff ssssssssssssssss", "sourceSyntax": "lb $t1,-100($t2)", "mask": 4227858432, "match": 2147483648, "opcode": 32, "funct": null, "fmt": null, "sampleValues": { "rs": 4, "rt": 8, "immediate": 0 }, "exampleWord": 2156396544, "context": "" }, { "name": "lbu", "group": "Memory and addresses", "syntax": "lbu t, offset(s)", "description": "Load one 8-bit byte from memory into t and zero-extend it to 32 bits. Address = s + sign-extended 16-bit byte offset; no alignment restriction.", "example": "lbu $t0, 0($a0) # 0xff becomes 0x000000ff", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 36, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "offset" } ], "immediate": "signed", "note": "The offset is signed and measured in bytes. The rt field identifies the value register, including for stores.", "sourcePattern": "100100 ttttt fffff ssssssssssssssss", "sourceSyntax": "lbu $t1,-100($t2)", "mask": 4227858432, "match": 2415919104, "opcode": 36, "funct": null, "fmt": null, "sampleValues": { "rs": 4, "rt": 8, "immediate": 0 }, "exampleWord": 2424832000, "context": "" }, { "name": "lh", "group": "Memory and addresses", "syntax": "lh t, offset(s)", "description": "Load one 16-bit halfword from memory into t and sign-extend it to 32 bits. Address = s + sign-extended 16-bit byte offset; requires 2-byte alignment.", "example": "lh $t0, 2($a0) # 0xffff becomes 0xffffffff", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 33, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "offset" } ], "immediate": "signed", "note": "The offset is signed and measured in bytes. The rt field identifies the value register, including for stores.", "sourcePattern": "100001 ttttt fffff ssssssssssssssss", "sourceSyntax": "lh $t1,-100($t2)", "mask": 4227858432, "match": 2214592512, "opcode": 33, "funct": null, "fmt": null, "sampleValues": { "rs": 4, "rt": 8, "immediate": 2 }, "exampleWord": 2223505410, "context": "" }, { "name": "lhu", "group": "Memory and addresses", "syntax": "lhu t, offset(s)", "description": "Load one 16-bit halfword from memory into t and zero-extend it to 32 bits. Address = s + sign-extended 16-bit byte offset; requires 2-byte alignment.", "example": "lhu $t0, 2($a0) # 0xffff becomes 0x0000ffff", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 37, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "offset" } ], "immediate": "signed", "note": "The offset is signed and measured in bytes. The rt field identifies the value register, including for stores.", "sourcePattern": "100101 ttttt fffff ssssssssssssssss", "sourceSyntax": "lhu $t1,-100($t2)", "mask": 4227858432, "match": 2483027968, "opcode": 37, "funct": null, "fmt": null, "sampleValues": { "rs": 4, "rt": 8, "immediate": 2 }, "exampleWord": 2491940866, "context": "" }, { "name": "sb", "group": "Memory and addresses", "syntax": "sb t, offset(s)", "description": "Store the low 8 bits of t to one byte of memory. Address = s + sign-extended 16-bit byte offset; no alignment restriction. The register is unchanged.", "example": "sb $t0, 0($a0) # store low byte of t0", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 40, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "offset" } ], "immediate": "signed", "note": "The offset is signed and measured in bytes. The rt field identifies the value register, including for stores.", "sourcePattern": "101000 ttttt fffff ssssssssssssssss", "sourceSyntax": "sb $t1,-100($t2)", "mask": 4227858432, "match": 2684354560, "opcode": 40, "funct": null, "fmt": null, "sampleValues": { "rs": 4, "rt": 8, "immediate": 0 }, "exampleWord": 2693267456, "context": "" }, { "name": "sh", "group": "Memory and addresses", "syntax": "sh t, offset(s)", "description": "Store the low 16 bits of t to a halfword of memory. Address = s + sign-extended 16-bit byte offset; requires 2-byte alignment. The register is unchanged.", "example": "sh $t0, 2($a0) # store low halfword of t0", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 41, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "immediate", "width": 16, "value": null, "role": "offset" } ], "immediate": "signed", "note": "The offset is signed and measured in bytes. The rt field identifies the value register, including for stores.", "sourcePattern": "101001 ttttt fffff ssssssssssssssss", "sourceSyntax": "sh $t1,-100($t2)", "mask": 4227858432, "match": 2751463424, "opcode": 41, "funct": null, "fmt": null, "sampleValues": { "rs": 4, "rt": 8, "immediate": 2 }, "exampleWord": 2760376322, "context": "" }, { "name": "la", "group": "Memory and addresses", "syntax": "la d, label", "description": "Load the address of a label, without reading the contents at that address.", "example": "la $t0, array", "kind": "pseudo", "expansion": { "code": "# Default MARS label form:\nlui $at, upper16(address(label))\nori d, $at, lower16(address(label))\n\n# MARS compact-address alternative:\naddi d, $zero, address(label)", "note": "Default: 2 real instructions and $at is clobbered. The compact alternative applies only to a suitable MARS compact memory configuration and a signed 16-bit address. Other assemblers and relocation models may expand la differently.", "count": "1–2", "sourceForm": "la $t1,label" } }, { "name": "li", "group": "Memory and addresses", "syntax": "li d, value", "description": "Load a constant; may expand to one or several real instructions.", "example": "li $t0, 0x12345678", "kind": "pseudo", "expansion": { "code": "# Signed 16-bit constant:\naddiu d, $zero, imm16\n\n# Unsigned 16-bit constant:\nori d, $zero, imm16\n\n# General 32-bit constant:\nlui $at, upper16(value)\nori d, $at, lower16(value)", "note": "1 or 2 real instructions, depending on the accepted immediate form. upper16 is bits 31:16; lower16 is bits 15:0, used by ori without sign extension. The full-width pinned MARS template clobbers $at.", "count": "1–2", "sourceForm": "li" } }, { "name": "move", "group": "Memory and addresses", "syntax": "move d, s", "description": "Copy a register; commonly implemented as addu d, s, $zero.", "example": "move $s0, $a0", "kind": "pseudo", "expansion": { "code": "addu d, $zero, s", "note": "Pinned MARS expansion for this operand form.", "count": "1", "sourceForm": "move $t1,$t2" } }, { "name": "j", "group": "Jumps and calls", "syntax": "j label", "description": "Jump using a pseudo-direct target encoding; cannot encode every 32-bit address.", "example": "j done", "kind": "real", "format": "J", "fields": [ { "name": "opcode", "width": 6, "value": 2, "role": "" }, { "name": "index", "width": 26, "value": null, "role": "jumpIndex" } ], "jump": true, "note": "Target = {(PC+4)[31:28], index[25:0], 00}. The index is a word index, not a byte address.", "sourcePattern": "000010 ffffffffffffffffffffffffff", "sourceSyntax": "j target", "mask": 4227858432, "match": 134217728, "opcode": 2, "funct": null, "fmt": null, "sampleValues": { "index": 1048584 }, "exampleWord": 135266312, "context": "For this encoded example, assume PC = 0x00400000 and label = 0x00400020. The label in the example is illustrative." }, { "name": "jal", "group": "Jumps and calls", "syntax": "jal label", "description": "Call a function and write the return address to $ra. The saved address depends on delay-slot execution mode.", "example": "jal sum_array", "kind": "real", "format": "J", "fields": [ { "name": "opcode", "width": 6, "value": 3, "role": "" }, { "name": "index", "width": 26, "value": null, "role": "jumpIndex" } ], "jump": true, "note": "Target = {(PC+4)[31:28], index[25:0], 00}. The index is a word index, not a byte address.", "sourcePattern": "000011 ffffffffffffffffffffffffff", "sourceSyntax": "jal target", "mask": 4227858432, "match": 201326592, "opcode": 3, "funct": null, "fmt": null, "sampleValues": { "index": 1048584 }, "exampleWord": 202375176, "context": "For this encoded example, assume PC = 0x00400000 and label = 0x00400020. The label in the example is illustrative." }, { "name": "jr", "group": "Jumps and calls", "syntax": "jr s", "description": "Jump to the address in a register; jr $ra is the usual return sequence.", "example": "jr $ra", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": 0, "role": "" }, { "name": "rd", "width": 5, "value": 0, "role": "" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 8, "role": "" } ], "sourcePattern": "000000 fffff 00000 00000 00000 001000", "sourceSyntax": "jr $t1", "mask": 4229955583, "match": 8, "opcode": 0, "funct": 8, "fmt": null, "sampleValues": { "rs": 31 }, "exampleWord": 65011720, "context": "" }, { "name": "jalr", "group": "Jumps and calls", "syntax": "jalr d, s", "description": "Jump to the address in s and save the return address in d; commonly d = $ra.", "example": "jalr $ra, $t9", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": 0, "role": "" }, { "name": "rd", "width": 5, "value": null, "role": "d" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 9, "role": "" } ], "sourcePattern": "000000 sssss 00000 fffff 00000 001001", "sourceSyntax": "jalr $t1,$t2", "mask": 4229892095, "match": 9, "opcode": 0, "funct": 9, "fmt": null, "sampleValues": { "rs": 25, "rd": 31 }, "exampleWord": 52492297, "context": "" }, { "name": "nop", "group": "Jumps and calls", "syntax": "nop", "description": "Do nothing; identical encoding to sll $zero, $zero, 0. MARS lists nop as a basic instruction.", "example": "nop", "kind": "real", "format": "R", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "rs", "width": 5, "value": 0, "role": "" }, { "name": "rt", "width": 5, "value": 0, "role": "" }, { "name": "rd", "width": 5, "value": 0, "role": "" }, { "name": "shamt", "width": 5, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 0, "role": "" } ], "sourcePattern": "000000 00000 00000 00000 00000 000000", "sourceSyntax": "nop", "mask": 4294967295, "match": 0, "opcode": 0, "funct": 0, "fmt": null, "sampleValues": {}, "exampleWord": 0, "context": "" }, { "name": "syscall", "group": "Jumps and calls", "syntax": "syscall", "description": "Enter a system-service handler. MARS selects a simulated service using $v0; service numbers are not defined by the MIPS ISA.", "example": "syscall", "kind": "real", "format": "SPECIAL / code", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "code", "width": 20, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 12, "role": "" } ], "note": "This no-operand form uses code = 0. MIPS also has encoded code fields; MARS services use $v0, not this field.", "sourcePattern": "000000 ccccc ccccc ccccc ccccc 001100", "sourceSyntax": "syscall", "mask": 4294967295, "match": 12, "opcode": 0, "funct": 12, "fmt": null, "sampleValues": {}, "exampleWord": 12, "context": "" }, { "name": "break", "group": "Jumps and calls", "syntax": "break", "description": "Raise a breakpoint exception; not a general substitute for exiting a program.", "example": "break", "kind": "real", "format": "SPECIAL / code", "fields": [ { "name": "opcode", "width": 6, "value": 0, "role": "" }, { "name": "code", "width": 20, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 13, "role": "" } ], "note": "This no-operand form uses code = 0. MIPS also has encoded code fields; MARS services use $v0, not this field.", "sourcePattern": "000000 ffffffffffffffffffff 001101", "sourceSyntax": "break 100", "mask": 4294967295, "match": 13, "opcode": 0, "funct": 13, "fmt": null, "sampleValues": {}, "exampleWord": 13, "context": "" }, { "name": "lwc1", "group": "Common floating-point instructions", "syntax": "lwc1 ft, offset(s)", "description": "Load a 32-bit word from memory into floating-point register ft. Copy the raw bits without numerical conversion; requires 4-byte alignment.", "example": "lwc1 $f0, 0($a0)", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 49, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "ft" }, { "name": "immediate", "width": 16, "value": null, "role": "offset" } ], "immediate": "signed", "note": "The offset is signed and measured in bytes. The rt field identifies a floating-point register.", "sourcePattern": "110001 ttttt fffff ssssssssssssssss", "sourceSyntax": "lwc1 $f1,-100($t2)", "mask": 4227858432, "match": 3288334336, "opcode": 49, "funct": null, "fmt": null, "sampleValues": { "rs": 4, "rt": 0, "immediate": 0 }, "exampleWord": 3296722944, "context": "" }, { "name": "swc1", "group": "Common floating-point instructions", "syntax": "swc1 ft, offset(s)", "description": "Store the 32-bit bit pattern in floating-point register ft to memory without numerical conversion. Requires 4-byte alignment; ft is unchanged.", "example": "swc1 $f0, 0($a0)", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 57, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "ft" }, { "name": "immediate", "width": 16, "value": null, "role": "offset" } ], "immediate": "signed", "note": "The offset is signed and measured in bytes. The rt field identifies a floating-point register.", "sourcePattern": "111001 ttttt fffff ssssssssssssssss", "sourceSyntax": "swc1 $f1,-100($t2)", "mask": 4227858432, "match": 3825205248, "opcode": 57, "funct": null, "fmt": null, "sampleValues": { "rs": 4, "rt": 0, "immediate": 0 }, "exampleWord": 3833593856, "context": "" }, { "name": "ldc1", "group": "Common floating-point instructions", "syntax": "ldc1 ft, offset(s)", "description": "Load 64 bits from memory into a floating-point register pair. In MARS, ft must be even-numbered and the memory address must be 8-byte aligned.", "example": "ldc1 $f2, 0($a0)", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 53, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "ft" }, { "name": "immediate", "width": 16, "value": null, "role": "offset" } ], "immediate": "signed", "note": "The offset is signed and measured in bytes. The rt field identifies a floating-point register.", "sourcePattern": "110101 ttttt fffff ssssssssssssssss", "sourceSyntax": "ldc1 $f2,-100($t2)", "mask": 4227858432, "match": 3556769792, "opcode": 53, "funct": null, "fmt": null, "sampleValues": { "rs": 4, "rt": 2, "immediate": 0 }, "exampleWord": 3565289472, "context": "" }, { "name": "sdc1", "group": "Common floating-point instructions", "syntax": "sdc1 ft, offset(s)", "description": "Store the 64-bit bit pattern in a floating-point register pair to memory. In MARS, ft must be even-numbered; requires 8-byte alignment. The register pair is unchanged.", "example": "sdc1 $f2, 0($a0)", "kind": "real", "format": "I", "fields": [ { "name": "opcode", "width": 6, "value": 61, "role": "" }, { "name": "rs", "width": 5, "value": null, "role": "s" }, { "name": "rt", "width": 5, "value": null, "role": "ft" }, { "name": "immediate", "width": 16, "value": null, "role": "offset" } ], "immediate": "signed", "note": "The offset is signed and measured in bytes. The rt field identifies a floating-point register.", "sourcePattern": "111101 ttttt fffff ssssssssssssssss", "sourceSyntax": "sdc1 $f2,-100($t2)", "mask": 4227858432, "match": 4093640704, "opcode": 61, "funct": null, "fmt": null, "sampleValues": { "rs": 4, "rt": 2, "immediate": 0 }, "exampleWord": 4102160384, "context": "" }, { "name": "mtc1", "group": "Common floating-point instructions", "syntax": "mtc1 t, fs", "description": "Copy the 32-bit bit pattern in general-purpose register t to floating-point register fs. This is not an integer-to-float numerical conversion.", "example": "mtc1 $t0, $f0", "kind": "real", "format": "COP1 / transfer", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "rs", "width": 5, "value": 4, "role": "" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "reserved", "width": 11, "value": 0, "role": "" } ], "note": "rs selects the transfer direction. There is no floating-point arithmetic funct field in this format.", "sourcePattern": "010001 00100 fffff sssss 00000 000000", "sourceSyntax": "mtc1 $t1,$f1", "mask": 4292872191, "match": 1149239296, "opcode": 17, "funct": null, "fmt": null, "sampleValues": { "rt": 8, "fs": 0 }, "exampleWord": 1149763584, "context": "" }, { "name": "mfc1", "group": "Common floating-point instructions", "syntax": "mfc1 t, fs", "description": "Copy the 32-bit bit pattern in floating-point register fs to general-purpose register t. This is not a float-to-integer numerical conversion.", "example": "mfc1 $t0, $f0", "kind": "real", "format": "COP1 / transfer", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "rs", "width": 5, "value": 0, "role": "" }, { "name": "rt", "width": 5, "value": null, "role": "t" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "reserved", "width": 11, "value": 0, "role": "" } ], "note": "rs selects the transfer direction. There is no floating-point arithmetic funct field in this format.", "sourcePattern": "010001 00000 fffff sssss 00000 000000", "sourceSyntax": "mfc1 $t1,$f1", "mask": 4292872191, "match": 1140850688, "opcode": 17, "funct": null, "fmt": null, "sampleValues": { "rt": 8, "fs": 0 }, "exampleWord": 1141374976, "context": "" }, { "name": "add.s", "group": "Common floating-point instructions", "syntax": "add.s fd, fs, ft", "description": "Add fs and ft using single-precision floating-point arithmetic and write the result to fd.", "example": "add.s $f4, $f0, $f2", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 16, "role": "" }, { "name": "ft", "width": 5, "value": null, "role": "ft" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 0, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10000 ttttt sssss fffff 000000", "sourceSyntax": "add.s $f0,$f1,$f3", "mask": 4292870207, "match": 1174405120, "opcode": 17, "funct": 0, "fmt": 16, "sampleValues": { "ft": 2, "fs": 0, "fd": 4 }, "exampleWord": 1174536448, "context": "" }, { "name": "sub.s", "group": "Common floating-point instructions", "syntax": "sub.s fd, fs, ft", "description": "Subtract ft from fs using single-precision floating-point arithmetic and write the result to fd.", "example": "sub.s $f4, $f0, $f2", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 16, "role": "" }, { "name": "ft", "width": 5, "value": null, "role": "ft" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 1, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10000 ttttt sssss fffff 000001", "sourceSyntax": "sub.s $f0,$f1,$f3", "mask": 4292870207, "match": 1174405121, "opcode": 17, "funct": 1, "fmt": 16, "sampleValues": { "ft": 2, "fs": 0, "fd": 4 }, "exampleWord": 1174536449, "context": "" }, { "name": "mul.s", "group": "Common floating-point instructions", "syntax": "mul.s fd, fs, ft", "description": "Multiply fs by ft using single-precision floating-point arithmetic and write the result to fd.", "example": "mul.s $f4, $f0, $f2", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 16, "role": "" }, { "name": "ft", "width": 5, "value": null, "role": "ft" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 2, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10000 ttttt sssss fffff 000010", "sourceSyntax": "mul.s $f0,$f1,$f3", "mask": 4292870207, "match": 1174405122, "opcode": 17, "funct": 2, "fmt": 16, "sampleValues": { "ft": 2, "fs": 0, "fd": 4 }, "exampleWord": 1174536450, "context": "" }, { "name": "div.s", "group": "Common floating-point instructions", "syntax": "div.s fd, fs, ft", "description": "Divide fs by ft using single-precision floating-point arithmetic and write the result to fd.", "example": "div.s $f4, $f0, $f2", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 16, "role": "" }, { "name": "ft", "width": 5, "value": null, "role": "ft" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 3, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10000 ttttt sssss fffff 000011", "sourceSyntax": "div.s $f0,$f1,$f3", "mask": 4292870207, "match": 1174405123, "opcode": 17, "funct": 3, "fmt": 16, "sampleValues": { "ft": 2, "fs": 0, "fd": 4 }, "exampleWord": 1174536451, "context": "" }, { "name": "add.d", "group": "Common floating-point instructions", "syntax": "add.d fd, fs, ft", "description": "Add fs and ft using double-precision floating-point arithmetic and write the result to fd. In MARS, all operands are register pairs starting at even-numbered registers.", "example": "add.d $f8, $f4, $f6", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 17, "role": "" }, { "name": "ft", "width": 5, "value": null, "role": "ft" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 0, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10001 ttttt sssss fffff 000000", "sourceSyntax": "add.d $f2,$f4,$f6", "mask": 4292870207, "match": 1176502272, "opcode": 17, "funct": 0, "fmt": 17, "sampleValues": { "ft": 6, "fs": 4, "fd": 8 }, "exampleWord": 1176904192, "context": "" }, { "name": "sub.d", "group": "Common floating-point instructions", "syntax": "sub.d fd, fs, ft", "description": "Subtract ft from fs using double-precision floating-point arithmetic and write the result to fd. In MARS, all operands are register pairs starting at even-numbered registers.", "example": "sub.d $f8, $f4, $f6", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 17, "role": "" }, { "name": "ft", "width": 5, "value": null, "role": "ft" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 1, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10001 ttttt sssss fffff 000001", "sourceSyntax": "sub.d $f2,$f4,$f6", "mask": 4292870207, "match": 1176502273, "opcode": 17, "funct": 1, "fmt": 17, "sampleValues": { "ft": 6, "fs": 4, "fd": 8 }, "exampleWord": 1176904193, "context": "" }, { "name": "mul.d", "group": "Common floating-point instructions", "syntax": "mul.d fd, fs, ft", "description": "Multiply fs by ft using double-precision floating-point arithmetic and write the result to fd. In MARS, all operands are register pairs starting at even-numbered registers.", "example": "mul.d $f8, $f4, $f6", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 17, "role": "" }, { "name": "ft", "width": 5, "value": null, "role": "ft" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 2, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10001 ttttt sssss fffff 000010", "sourceSyntax": "mul.d $f2,$f4,$f6", "mask": 4292870207, "match": 1176502274, "opcode": 17, "funct": 2, "fmt": 17, "sampleValues": { "ft": 6, "fs": 4, "fd": 8 }, "exampleWord": 1176904194, "context": "" }, { "name": "div.d", "group": "Common floating-point instructions", "syntax": "div.d fd, fs, ft", "description": "Divide fs by ft using double-precision floating-point arithmetic and write the result to fd. In MARS, all operands are register pairs starting at even-numbered registers.", "example": "div.d $f8, $f4, $f6", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 17, "role": "" }, { "name": "ft", "width": 5, "value": null, "role": "ft" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 3, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10001 ttttt sssss fffff 000011", "sourceSyntax": "div.d $f2,$f4,$f6", "mask": 4292870207, "match": 1176502275, "opcode": 17, "funct": 3, "fmt": 17, "sampleValues": { "ft": 6, "fs": 4, "fd": 8 }, "exampleWord": 1176904195, "context": "" }, { "name": "mov.s", "group": "Common floating-point instructions", "syntax": "mov.s fd, fs", "description": "Copy a single-precision floating-point value from fs to fd.", "example": "mov.s $f12, $f0", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 16, "role": "" }, { "name": "ft", "width": 5, "value": 0, "role": "" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 6, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10000 00000 sssss fffff 000110", "sourceSyntax": "mov.s $f0,$f1", "mask": 4294901823, "match": 1174405126, "opcode": 17, "funct": 6, "fmt": 16, "sampleValues": { "fs": 0, "fd": 12 }, "exampleWord": 1174405894, "context": "" }, { "name": "mov.d", "group": "Common floating-point instructions", "syntax": "mov.d fd, fs", "description": "Copy a double-precision floating-point value from fs to fd. In MARS, source and destination are register pairs starting at even-numbered registers.", "example": "mov.d $f12, $f0", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 17, "role": "" }, { "name": "ft", "width": 5, "value": 0, "role": "" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 6, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10001 00000 sssss fffff 000110", "sourceSyntax": "mov.d $f2,$f4", "mask": 4294901823, "match": 1176502278, "opcode": 17, "funct": 6, "fmt": 17, "sampleValues": { "fs": 0, "fd": 12 }, "exampleWord": 1176503046, "context": "" }, { "name": "cvt.s.w", "group": "Common floating-point instructions", "syntax": "cvt.s.w fd, fs", "description": "Interpret the 32 bits in fs as a signed integer and convert that integer to a single-precision value in fd. The destination is a floating-point register.", "example": "cvt.s.w $f2, $f0", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 20, "role": "" }, { "name": "ft", "width": 5, "value": 0, "role": "" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 32, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10100 00000 sssss fffff 100000", "sourceSyntax": "cvt.s.w $f0,$f1", "mask": 4294901823, "match": 1182793760, "opcode": 17, "funct": 32, "fmt": 20, "sampleValues": { "fs": 0, "fd": 2 }, "exampleWord": 1182793888, "context": "" }, { "name": "cvt.d.w", "group": "Common floating-point instructions", "syntax": "cvt.d.w fd, fs", "description": "Interpret the 32 bits in fs as a signed integer and convert that integer to double precision. In MARS, fd names a register pair starting at an even-numbered register.", "example": "cvt.d.w $f2, $f0", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 20, "role": "" }, { "name": "ft", "width": 5, "value": 0, "role": "" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 33, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10100 00000 sssss fffff 100001", "sourceSyntax": "cvt.d.w $f2,$f1", "mask": 4294901823, "match": 1182793761, "opcode": 17, "funct": 33, "fmt": 20, "sampleValues": { "fs": 0, "fd": 2 }, "exampleWord": 1182793889, "context": "" }, { "name": "cvt.w.s", "group": "Common floating-point instructions", "syntax": "cvt.w.s fd, fs", "description": "Convert the single-precision value in fs to a signed 32-bit integer using the rounding mode. Store the integer bit pattern in fd; use mfc1 to retrieve it.", "example": "cvt.w.s $f2, $f0", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 16, "role": "" }, { "name": "ft", "width": 5, "value": 0, "role": "" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 36, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10000 00000 sssss fffff 100100", "sourceSyntax": "cvt.w.s $f0,$f1", "mask": 4294901823, "match": 1174405156, "opcode": 17, "funct": 36, "fmt": 16, "sampleValues": { "fs": 0, "fd": 2 }, "exampleWord": 1174405284, "context": "" }, { "name": "cvt.w.d", "group": "Common floating-point instructions", "syntax": "cvt.w.d fd, fs", "description": "Convert the double-precision value in fs to a signed 32-bit integer using the rounding mode. Store the integer bit pattern in fd; use mfc1 to retrieve it. In MARS, fs must be even-numbered.", "example": "cvt.w.d $f2, $f0", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 17, "role": "" }, { "name": "ft", "width": 5, "value": 0, "role": "" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 36, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10001 00000 sssss fffff 100100", "sourceSyntax": "cvt.w.d $f1,$f2", "mask": 4294901823, "match": 1176502308, "opcode": 17, "funct": 36, "fmt": 17, "sampleValues": { "fs": 0, "fd": 2 }, "exampleWord": 1176502436, "context": "" }, { "name": "trunc.w.s", "group": "Common floating-point instructions", "syntax": "trunc.w.s fd, fs", "description": "Convert the single-precision value in fs to a signed 32-bit integer by truncating toward zero. Store the integer bit pattern in fd; use mfc1 to retrieve it.", "example": "trunc.w.s $f2, $f0", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 16, "role": "" }, { "name": "ft", "width": 5, "value": 0, "role": "" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 13, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10000 00000 sssss fffff 001101", "sourceSyntax": "trunc.w.s $f0,$f1", "mask": 4294901823, "match": 1174405133, "opcode": 17, "funct": 13, "fmt": 16, "sampleValues": { "fs": 0, "fd": 2 }, "exampleWord": 1174405261, "context": "" }, { "name": "trunc.w.d", "group": "Common floating-point instructions", "syntax": "trunc.w.d fd, fs", "description": "Convert the double-precision value in fs to a signed 32-bit integer by truncating toward zero. Store the integer bit pattern in fd; use mfc1 to retrieve it. In MARS, fs must be even-numbered.", "example": "trunc.w.d $f2, $f0", "kind": "real", "format": "COP1 / arithmetic", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 17, "role": "" }, { "name": "ft", "width": 5, "value": 0, "role": "" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "fd", "width": 5, "value": null, "role": "fd" }, { "name": "funct", "width": 6, "value": 13, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14.", "sourcePattern": "010001 10001 00000 sssss fffff 001101", "sourceSyntax": "trunc.w.d $f1,$f2", "mask": 4294901823, "match": 1176502285, "opcode": 17, "funct": 13, "fmt": 17, "sampleValues": { "fs": 0, "fd": 2 }, "exampleWord": 1176502413, "context": "" }, { "name": "c.eq.s", "group": "Common floating-point instructions", "syntax": "c.eq.s fs, ft", "description": "Compare single-precision fs and ft. Set floating-point condition flag 0 if fs is equal to ft; clear it otherwise.", "example": "c.eq.s $f0, $f2", "kind": "real", "format": "COP1 / compare", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 16, "role": "" }, { "name": "ft", "width": 5, "value": null, "role": "ft" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "cc", "width": 3, "value": 0, "role": "" }, { "name": "reserved", "width": 2, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 50, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14. This two-operand form uses condition code cc = 0.", "sourcePattern": "010001 10000 sssss fffff 00000 110010", "sourceSyntax": "c.eq.s $f0,$f1", "mask": 4292872191, "match": 1174405170, "opcode": 17, "funct": 50, "fmt": 16, "sampleValues": { "ft": 2, "fs": 0 }, "exampleWord": 1174536242, "context": "" }, { "name": "c.lt.s", "group": "Common floating-point instructions", "syntax": "c.lt.s fs, ft", "description": "Compare single-precision fs and ft. Set floating-point condition flag 0 if fs is less than ft; clear it otherwise.", "example": "c.lt.s $f0, $f2", "kind": "real", "format": "COP1 / compare", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 16, "role": "" }, { "name": "ft", "width": 5, "value": null, "role": "ft" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "cc", "width": 3, "value": 0, "role": "" }, { "name": "reserved", "width": 2, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 60, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14. This two-operand form uses condition code cc = 0.", "sourcePattern": "010001 10000 sssss fffff 00000 111100", "sourceSyntax": "c.lt.s $f0,$f1", "mask": 4292872191, "match": 1174405180, "opcode": 17, "funct": 60, "fmt": 16, "sampleValues": { "ft": 2, "fs": 0 }, "exampleWord": 1174536252, "context": "" }, { "name": "c.le.s", "group": "Common floating-point instructions", "syntax": "c.le.s fs, ft", "description": "Compare single-precision fs and ft. Set floating-point condition flag 0 if fs is less than or equal to ft; clear it otherwise.", "example": "c.le.s $f0, $f2", "kind": "real", "format": "COP1 / compare", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 16, "role": "" }, { "name": "ft", "width": 5, "value": null, "role": "ft" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "cc", "width": 3, "value": 0, "role": "" }, { "name": "reserved", "width": 2, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 62, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14. This two-operand form uses condition code cc = 0.", "sourcePattern": "010001 10000 sssss fffff 00000 111110", "sourceSyntax": "c.le.s $f0,$f1", "mask": 4292872191, "match": 1174405182, "opcode": 17, "funct": 62, "fmt": 16, "sampleValues": { "ft": 2, "fs": 0 }, "exampleWord": 1174536254, "context": "" }, { "name": "bc1t", "group": "Common floating-point instructions", "syntax": "bc1t label", "description": "Branch to label if floating-point condition flag 0 is true. This form uses the default condition code.", "example": "bc1t condition_true", "kind": "real", "format": "COP1 / branch", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "rs", "width": 5, "value": 8, "role": "" }, { "name": "cc", "width": 3, "value": 0, "role": "" }, { "name": "nd", "width": 1, "value": 0, "role": "" }, { "name": "tf", "width": 1, "value": 1, "role": "" }, { "name": "offset", "width": 16, "value": null, "role": "branchOffset" } ], "immediate": "signed", "branch": true, "note": "cc = 0 in this form; nd = 0 selects an ordinary delayed branch. tf selects true (1) or false (0). No funct field.", "sourcePattern": "010001 01000 00001 ffffffffffffffff", "sourceSyntax": "bc1t label", "mask": 4294901760, "match": 1157693440, "opcode": 17, "funct": null, "fmt": null, "sampleValues": { "offset": 7 }, "exampleWord": 1157693447, "context": "For this encoded example, assume PC = 0x00400000 and label = 0x00400020. The label in the example is illustrative." }, { "name": "bc1f", "group": "Common floating-point instructions", "syntax": "bc1f label", "description": "Branch to label if floating-point condition flag 0 is false. This form uses the default condition code.", "example": "bc1f condition_false", "kind": "real", "format": "COP1 / branch", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "rs", "width": 5, "value": 8, "role": "" }, { "name": "cc", "width": 3, "value": 0, "role": "" }, { "name": "nd", "width": 1, "value": 0, "role": "" }, { "name": "tf", "width": 1, "value": 0, "role": "" }, { "name": "offset", "width": 16, "value": null, "role": "branchOffset" } ], "immediate": "signed", "branch": true, "note": "cc = 0 in this form; nd = 0 selects an ordinary delayed branch. tf selects true (1) or false (0). No funct field.", "sourcePattern": "010001 01000 00000 ffffffffffffffff", "sourceSyntax": "bc1f label", "mask": 4294901760, "match": 1157627904, "opcode": 17, "funct": null, "fmt": null, "sampleValues": { "offset": 7 }, "exampleWord": 1157627911, "context": "For this encoded example, assume PC = 0x00400000 and label = 0x00400020. The label in the example is illustrative." }, { "name": "c.eq.d", "group": "Common floating-point instructions", "syntax": "c.eq.d fs, ft", "description": "Compare double-precision fs and ft. Set floating-point condition flag 0 if fs is equal to ft; clear it otherwise. In MARS, both operands name register pairs starting at even-numbered registers.", "example": "c.eq.d $f0, $f2", "kind": "real", "format": "COP1 / compare", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 17, "role": "" }, { "name": "ft", "width": 5, "value": null, "role": "ft" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "cc", "width": 3, "value": 0, "role": "" }, { "name": "reserved", "width": 2, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 50, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14. This two-operand form uses condition code cc = 0.", "sourcePattern": "010001 10001 sssss fffff 00000 110010", "sourceSyntax": "c.eq.d $f2,$f4", "mask": 4292872191, "match": 1176502322, "opcode": 17, "funct": 50, "fmt": 17, "sampleValues": { "ft": 2, "fs": 0 }, "exampleWord": 1176633394, "context": "" }, { "name": "c.lt.d", "group": "Common floating-point instructions", "syntax": "c.lt.d fs, ft", "description": "Compare double-precision fs and ft. Set floating-point condition flag 0 if fs is less than ft; clear it otherwise. In MARS, both operands name register pairs starting at even-numbered registers.", "example": "c.lt.d $f0, $f2", "kind": "real", "format": "COP1 / compare", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 17, "role": "" }, { "name": "ft", "width": 5, "value": null, "role": "ft" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "cc", "width": 3, "value": 0, "role": "" }, { "name": "reserved", "width": 2, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 60, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14. This two-operand form uses condition code cc = 0.", "sourcePattern": "010001 10001 sssss fffff 00000 111100", "sourceSyntax": "c.lt.d $f2,$f4", "mask": 4292872191, "match": 1176502332, "opcode": 17, "funct": 60, "fmt": 17, "sampleValues": { "ft": 2, "fs": 0 }, "exampleWord": 1176633404, "context": "" }, { "name": "c.le.d", "group": "Common floating-point instructions", "syntax": "c.le.d fs, ft", "description": "Compare double-precision fs and ft. Set floating-point condition flag 0 if fs is less than or equal to ft; clear it otherwise. In MARS, both operands name register pairs starting at even-numbered registers.", "example": "c.le.d $f0, $f2", "kind": "real", "format": "COP1 / compare", "fields": [ { "name": "opcode", "width": 6, "value": 17, "role": "" }, { "name": "fmt", "width": 5, "value": 17, "role": "" }, { "name": "ft", "width": 5, "value": null, "role": "ft" }, { "name": "fs", "width": 5, "value": null, "role": "fs" }, { "name": "cc", "width": 3, "value": 0, "role": "" }, { "name": "reserved", "width": 2, "value": 0, "role": "" }, { "name": "funct", "width": 6, "value": 62, "role": "" } ], "note": "fmt describes the source representation: S = 0x10, D = 0x11, W = 0x14. This two-operand form uses condition code cc = 0.", "sourcePattern": "010001 10001 sssss fffff 00000 111110", "sourceSyntax": "c.le.d $f2,$f4", "mask": 4292872191, "match": 1176502334, "opcode": 17, "funct": 62, "fmt": 17, "sampleValues": { "ft": 2, "fs": 0 }, "exampleWord": 1176633406, "context": "" } ], "validation": { "encodingsChecked": 84, "source": "Pinned MARS bit patterns; field positions and fixed bits checked during generation." } }