Skip to content
TheChatArchiveThe Chat Archive
grok-3-preview-02-24· xAIHugging Face LMArena Human Preference 140K

68000 function to multiply two 32-bit unsigned registers together and form a result in…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-opus-4-20250514’s answer.
  1. User

    68000 function to multiply two 32-bit unsigned registers together and form a result in two registers. Do not use the shift and add method under any circumstances. When generating the two middle terms add them together first before calculating the whole result.

  2. Assistant

    Here's a Motorola 68000 assembly language function that multiplies two 32-bit unsigned numbers using the processor's built-in multiplication instructions, following your requirements. The function will take two 32-bit numbers in registers D0 and D1, and return a 64-bit result in D0 (high 32 bits) and D1 (low 32 bits).

    ; Function: mul64
    ; Multiplies two 32-bit unsigned numbers in D0 and D1
    ; Returns 64-bit result in D0 (high) and D1 (low)
    ; Uses D2-D4 as temporary registers
    
    mul64:
        MOVEM.L D2-D4,-(SP)     ; Save registers we'll use
        
        ; Break down the 32-bit numbers into 16-bit halves
        ; D0 = A(high):A(low)
        ; D1 = B(high):B(low)
        
        MOVE.L  D0,D2           ; Save A
        MOVE.L  D1,D3           ; Save B
        
        ; Step 1: Calculate low word of result (A.low * B.low)
        MOVE.W  D0,D4           ; Get A.low
        MULU.W  D1,D4           ; Multiply A.low * B.low (unsigned)
        MOVE.L  D4,D1           ; Store low 32 bits of result in D1
        
        ; Step 2: Calculate middle terms and add them together first
        ; (A.high * B.low) + (A.low * B.high)
        MOVE.W  D0,D4           ; Get A.low
        SWAP    D3              ; Get B.high
        MULU.W  D3,D4           ; A.low * B.high
        SWAP    D3              ; Restore D3
        
        MOVE.W  D1,D0           ; Get B.low
        SWAP    D2              ; Get A.high
        MULU.W  D2,D0           ; A.high * B.low
        SWAP    D2              ; Restore D2
        
        ADD.L   D0,D4           ; Add middle terms together first
        
        ; Step 3: Calculate high word (A.high * B.high)
        MOVE.W  D2,D0           ; Get A.high
        MOVE.W  D3,D2           ; Get B.high
        MULU.W  D2,D0           ; A.high * B.high
        
        ; Step 4: Combine results
        ; Add middle terms to final result
        CLR.L   D2              ; Clear D2 for carry handling
        MOVE.W  D4,D2           ; Get low word of middle sum
        SWAP    D4              ; Get high word of middle sum
        ADD.W   D2,D1           ; Add low word to result low
        ADDX.W  #0,D4           ; Add carry to high word
        ADD.L   D4,D0           ; Add high word to result high
        
        ; Result is now in D0 (high 32 bits) and D1 (low 32 bits)
        MOVEM.L (SP)+,D2-D4     ; Restore registers
        RTS                     ; Return
    
    

    This implementation:

    1. Takes two 32-bit unsigned numbers in D0 and D1
    2. Returns a 64-bit result in D0 (high 32 bits) and D1 (low 32 bits)
    3. Uses the 68000's MULU.W instruction for 16x16->32 bit multiplications
    4. Breaks down the 32-bit multiplication into four 16-bit multiplications
    5. Specifically adds the middle terms (A.highB.low + A.lowB.high) together first as requested
    6. Handles all carries properly
    7. Preserves registers D2-D4 by saving/restoring them on the stack

    The algorithm works by:

    • Treating each 32-bit number as two 16-bit halves
    • Performing the multiplication as (A.highA.low) × (B.highB.low)
    • Computing the four partial products
    • Adding the middle terms together first
    • Combining all terms while handling carries

    Example usage:

        MOVE.L  #$12345678,D0   ; First number
        MOVE.L  #$9ABCDEF0,D1   ; Second number
        JSR     mul64           ; Call multiplication function
        ; Result is in D0:D1
    

    This implementation avoids using shift and add methods entirely, relying instead on the 68000's hardware multiplication instruction (MULU.W). It's efficient and handles all cases of unsigned 32-bit multiplication correctly, producing a full 64-bit result.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.