Home/Instructions/Multiply High Signed×Unsigned
MULHSU

RISC-V MULHSU Instruction Details

Instruction ManualR-type

Signed×unsigned multiply, return upper XLEN bits of product

Instruction Syntax

mulhsu rd, rs1, rs2
Operand Breakdown
Destination rd: register receiving the operation result.
Source rs1: register holding the first operand.
Source rs2: register holding the second operand.
MArithmeticMultiplication

Extension condition: RV32 or RV64 with M or Zmmul.

Instruction Behavior

MULHSU treats rs1 as signed and rs2 as unsigned, multiplies them, and returns the upper XLEN bits of the full product. It is used in multi-word signed multiplication where the most-significant word (which contains the sign bit) of the multiplicand multiplies less-significant, unsigned words of the multiplier. It is defined by M and is also included in Zmmul.

MULHSU Decode And Execute Animation

Starts with machine-code field decoding, then shows operand reads, instruction-specific execution, and ISA-visible state update.

rd
rs1
rs2
mulhsu
,
,
Execution Context

This example uses fixed initial register values and PC=0x2000; instruction fetch succeeds, with no asynchronous interrupt or extra extension checks. Exception branches stop ordinary commit; post-trap PC and handler state are EEI-dependent.

a6(x16)
0xFFFFFFF0
t2(x7)
0x00000007
31..25
24..20
19..15
14..12
11..7
6..0
0000001
funct7
00111
rs2
10000
rs1
010
funct3
00101
rd
0110011
opcode
Execution Data Path
instruction
0x027822B3
opcode
0110011 -> OP
funct3
010 -> MULHSU
funct7
0000001 -> integer multiply selector
rd / rs1 / rs2
t0(x5) / a6(x16)=0xFFFFFFF0 (-16) / t2(x7)=0x00000007 (7)
32-bit multiply
Not computed
x5
t0(x5) = 0x00003001; pc = 0x00002000
Current Step

Concept Step: receive the 32-bit instruction encoding

The machine code is split by the current instruction format; the animation starts from encoding/decode.

encoding: 0x027822B3
syntax : mulhsu t0(x5), a6(x16), t2(x7)
Pending result: Not computed
Current architectural state
t0(x5) = 0x00003001; pc = 0x00002000

This animation shows ISA-visible decode and state changes, not any specific CPU pipeline, cache, prediction, or timing implementation.

Quick Understanding & Search Notes

rd, rs1 and rs2 are three 5-bit integer-register fields, with no immediate. A single instruction allows destination/source overlap and uses source values before writeback.
M and Zmmul use identical encodings; M implies Zmmul. RV32 and RV64 operate at XLEN=32 and XLEN=64 respectively.

Common Usage Scenarios

Multi-word signed multiplication

Understand this scenario with real code like «mulhsu t0, a0, a1 # t0 = upper XLEN bits of signed(a0) * unsigned(a1)».

Pre-Use Checklist

Syntax Check
  • rd, rs1 and rs2 are three x0–x31 register fields (ABI aliases are accepted), with no rs3 or immediate.
  • M or Zmmul is required; MULW is RV64-only, while the other four operate on RV32/RV64.
Semantic Check
  • Signed×unsigned multiply, return upper XLEN bits of product
  • Destination/source overlap uses old source values; rd=x0 discards writeback. A recommended high-half/MUL pair keeps source order and uses a high-half destination different from both sources.

Pitfalls / Common Confusions

Operand order has semantics: rs1 is signed, rs2 is unsigned, not interchangeable

FAQ

May rd overlap a source or be x0?

Yes: sources use old values and x0 discards writes. For both halves, the recommended MULH/MULHSU/MULHU then MUL pair keeps source order and a high-half destination different from both sources. This condition applies to the pair, not single-instruction legality.