Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-sonnet-4-20250514-thinking-32k· AnthropicHugging Face LMArena Human Preference 140K

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

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Kimikimi-k2-0711-preview’s answer.
  1. User

    68000 function to multiply two 32-bit signed 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. Claude Assistant

    Here's a 68000 assembly function to multiply two 32-bit signed numbers without using shift-and-add, with the middle terms added together first as requested:

    ; 32-bit signed multiplication
    ; Input: D0.L = first 32-bit signed number
    ;        D1.L = second 32-bit signed number  
    ; Output: D0.L = low 32 bits of 64-bit result
    ;         D1.L = high 32 bits of 64-bit result
    
    multiply_32bit:
        movem.l d2-d7, -(sp)
        
        ; Split operands into 16-bit parts
        ; A = A_hi:A_lo, B = B_hi:B_lo
        move.l  d0, d2      ; Save A
        move.l  d1, d3      ; Save B
        
        move.w  d0, d4      ; D4 = A_lo (bits 15-0)
        move.w  d1, d5      ; D5 = B_lo (bits 15-0)
        swap    d0
        swap    d1
        move.w  d0, d6      ; D6 = A_hi (bits 31-16)
        move.w  d1, d7      ; D7 = B_hi (bits 31-16)
        
        ; Calculate A_lo * B_lo (unsigned multiplication)
        move.w  d4, d0
        mulu    d5, d0      ; D0 = A_lo * B_lo
        
        ; Calculate A_hi * B_lo (signed * unsigned)
        move.w  d6, d1
        ext.l   d1          ; Sign extend A_hi to 32 bits
        move.w  d5, d2      ; B_lo (treated as unsigned)
        tst.l   d1          ; Check sign of A_hi
        bpl.s   .a_hi_pos1
        neg.l   d1          ; Make A_hi positive
        mulu    d2, d1      ; Multiply positive values
        neg.l   d1          ; Negate result
        bra.s   .done1
    .a_hi_pos1:
        mulu    d2, d1      ; A_hi positive, multiply normally
    .done1:
        ; D1 = A_hi * B_lo
        
        ; Calculate A_lo * B_hi (unsigned * signed)  
        move.w  d4, d2      ; A_lo (unsigned)
        move.w  d7, d3
        ext.l   d3          ; Sign extend B_hi to 32 bits
        tst.l   d3          ; Check sign of B_hi
        bpl.s   .b_hi_pos
        neg.l   d3          ; Make B_hi positive
        mulu    d2, d3      ; Multiply positive values
        neg.l   d3          ; Negate result
        bra.s   .done2
    .b_hi_pos:
        mulu    d2, d3      ; B_hi positive, multiply normally
    .done2:
        ; D3 = A_lo * B_hi
        
        ; Add the two middle terms together first (as requested)
        add.l   d1, d3      ; D3 = A_hi * B_lo + A_lo * B_hi
        
        ; Calculate A_hi * B_hi (signed multiplication)
        muls    d7, d6      ; D6 = A_hi * B_hi
        
        ; Combine partial products:
        ; Result = A_hi*B_hi*2^32 + (A_hi*B_lo + A_lo*B_hi)*2^16 + A_lo*B_lo
        ; D0 = A_lo * B_lo
        ; D3 = middle terms sum  
        ; D6 = A_hi * B_hi
        
        ; Add high 16 bits of middle sum to high result
        move.l  d3, d1      ; Copy middle sum
        swap    d1          ; Get high 16 bits
        ext.l   d1          ; Sign extend to 32 bits
        add.l   d1, d6      ; Add to high part of result
        
        ; Add low 16 bits of middle sum (shifted left 16) to low result
        swap    d3          ; Move low 16 bits to high position
        clr.w   d3          ; Clear low 16 bits (effectively << 16)
        add.l   d3, d0      ; Add to low part of result
        bcc.s   .no_carry   ; Check for carry
        addq.l  #1, d6      ; Propagate carry to high part
    .no_carry:
        
        ; Final result: D0 = low 32 bits, D6 = high 32 bits
        move.l  d6, d1      ; Move high result to D1
        
        movem.l (sp)+, d2-d7
        rts
    

    This function:

    1. Splits each 32-bit input into high and low 16-bit parts
    2. Calculates four partial products using the appropriate signed/unsigned multiplication
    3. Adds the two middle terms together first as you requested (A_hi × B_lo + A_lo × B_hi)
    4. Combines all terms using the standard multiplication formula: A×B = A_hi×B_hi×2³² + (middle_sum)×2¹⁶ + A_lo×B_lo
    5. Handles carry propagation from the low to high 32-bit result
    6. Returns the 64-bit result in D0 (low) and D1 (high)

    The function properly handles signed multiplication by treating the low parts as unsigned 16-bit values and the high parts as signed 16-bit values, using manual sign handling for mixed signed/unsigned operations.

  3. User

    rewrite to only multiply unsigned numbers instead

  4. Claude Assistant

    Here's the rewritten 68000 assembly function using only unsigned multiplications:

    ; 32-bit signed multiplication using only unsigned operations
    ; Input: D0.L = first 32-bit signed number
    ;        D1.L = second 32-bit signed number  
    ; Output: D0.L = low 32 bits of 64-bit result
    ;         D1.L = high 32 bits of 64-bit result
    
    multiply_32bit:
        movem.l d2-d7, -(sp)
        
        ; Determine result sign and convert operands to positive
        moveq   #0, d2      ; D2 = sign flag (0=positive, 1=negative)
        
        ; Check and convert first operand
        tst.l   d0
        bpl.s   .first_pos
        neg.l   d0          ; Convert to positive
        not.b   d2          ; Flip sign flag
    .first_pos:
        
        ; Check and convert second operand  
        tst.l   d1
        bpl.s   .second_pos
        neg.l   d1          ; Convert to positive
        not.b   d2          ; Flip sign flag
    .second_pos:
        
        ; Now both operands are positive, split into 16-bit parts
        ; A = A_hi:A_lo, B = B_hi:B_lo
        move.w  d0, d3      ; D3 = A_lo (bits 15-0)
        move.w  d1, d4      ; D4 = B_lo (bits 15-0)
        swap    d0
        swap    d1
        move.w  d0, d5      ; D5 = A_hi (bits 31-16)
        move.w  d1, d6      ; D6 = B_hi (bits 31-16)
        
        ; Calculate A_lo * B_lo (unsigned)
        move.w  d3, d0
        mulu    d4, d0      ; D0 = A_lo * B_lo
        
        ; Calculate A_hi * B_lo (unsigned)
        move.w  d5, d1
        mulu    d4, d1      ; D1 = A_hi * B_lo
        
        ; Calculate A_lo * B_hi (unsigned)
        move.w  d3, d7
        mulu    d6, d7      ; D7 = A_lo * B_hi
        
        ; Add the two middle terms together first (as requested)
        add.l   d1, d7      ; D7 = A_hi * B_lo + A_lo * B_hi
        
        ; Calculate A_hi * B_hi (unsigned)
        mulu    d6, d5      ; D5 = A_hi * B_hi
        
        ; Combine partial products:
        ; Result = A_hi*B_hi*2^32 + (middle_sum)*2^16 + A_lo*B_lo
        ; D0 = A_lo * B_lo
        ; D7 = middle terms sum  
        ; D5 = A_hi * B_hi
        
        ; Add high 16 bits of middle sum to high result
        move.l  d7, d1      ; Copy middle sum
        swap    d1          ; Get high 16 bits in low position
        clr.w   d1          ; Clear low 16 bits
        swap    d1          ; Move back to high position (effectively >> 16)
        add.l   d1, d5      ; Add to high part of result
        
        ; Add low 16 bits of middle sum (shifted left 16) to low result
        swap    d7          ; Move low 16 bits to high position
        clr.w   d7          ; Clear low 16 bits (effectively << 16)
        add.l   d7, d0      ; Add to low part of result
        bcc.s   .no_carry   ; Check for carry
        addq.l  #1, d5      ; Propagate carry to high part
    .no_carry:
        
        ; Apply sign correction if result should be negative
        tst.b   d2
        beq.s   .positive_result
        
        ; Negate 64-bit result (2's complement)
        not.l   d0          ; Invert low part
        not.l   d5          ; Invert high part
        addq.l  #1, d0      ; Add 1 to low part
        bcc.s   .done_negate
        addq.l  #1, d5      ; Propagate carry to high part
    .done_negate:
    
    .positive_result:
        ; Final result: D0 = low 32 bits, D5 = high 32 bits
        move.l  d5, d1      ; Move high result to D1
        
        movem.l (sp)+, d2-d7
        rts
    

    This simplified version:

    1. Determines the final result sign by checking if an odd number of operands are negative
    2. Converts both operands to positive using 2's complement if necessary
    3. Performs all multiplications using MULU (unsigned multiply) since both operands are now positive
    4. Adds the two middle terms together first as requested
    5. Combines the partial products using the standard formula
    6. Applies 2's complement to the entire 64-bit result if the final result should be negative
    7. Returns the result in D0 (low) and D1 (high)

    This approach is much cleaner since it avoids the complexity of mixed signed/unsigned arithmetic and uses only unsigned multiplications throughout the calculation phase.

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