3

I'm learning the MIPS assembly language and I'm being asked to write a program which does the following:

  1. Accept an integer as user input
  2. Print that integer as a signed binary number
  3. Reverse the bits in that integer
  4. Print the resulting reversed number (also in binary)

Beyond the fact that I obviously need to use shift operations and a logical comparison between two shifted values, I'm pretty lost. My idea was to write a loop that would place the least significant bit of the input integer in a temporary register, shift that value left by 1, shift the input integer right by one, and repeat the process until the input integer is equal to 0. I'm just not sure how to "take" one bit of a number... can someone help me out here?

Peter Cordes
  • 328,167
  • 45
  • 605
  • 847
Or Bairey-Sehayek
  • 193
  • 1
  • 1
  • 8
  • 1
    Hint: look into bitwise `AND` and `OR` – Jester Nov 12 '15 at 16:03
  • Turns out all I needed was some clever shifting. – Or Bairey-Sehayek Nov 13 '15 at 11:04
  • Bit-manipulation algorithms for it: [mirror bits of a 32 bit word](https://stackoverflow.com/q/4245936) including a simple loop using only shifts, ANDs, and ADD or OR that MIPS can do in single instructions. Also [Efficient Algorithm for Bit Reversal (from MSB->LSB to LSB->MSB) in C](https://stackoverflow.com/q/746171) – Peter Cordes Aug 04 '22 at 09:34

1 Answers1

1

I solved it:

.data
    int: .word 0

    pleaseEnter: .asciiz "Please enter an integer: "
    yourIntBin: .asciiz "Your integer in binary code is:        "
    yourIntBinRev: .asciiz "And now in reverse:         "
    nl: .asciiz "\n"
.text
    main:
    # ask the user for an integer
    li $v0, 4
    la $a0, pleaseEnter
    syscall

    # get the user's integer, store in int
    li $v0, 5
    syscall
    sw $v0, int

    # set up temporary reg's
    li $t7, 31 # shamt is in t7

    j loop1

    loop1:
        lw $t0, int # load int to t0
        srlv $t1, $t0, $t7 # shift by counter
        bnez $t1, exit1 # if the bit is 1, exit the loop
        beqz $t7, exit1 # if the counter has reached 0 with no 1s in the int word, exit the loop
        addi $t7, $t7, -1
        j loop1

    exit1: # now t7 is the number of bits that come before the msb

    move $t4, $t7 # save that number for later

    # tell the user what their number in binary is:
    li $v0, 4
    la $a0, nl
    syscall
    li $v0, 4
    la $a0, yourIntBin
    syscall
    li $v0, 1

    # prepare temp reg's
    li $t6, 32 # set t6 to the maximum number of bits in a word
    sub $t7, $t6, $t7 # make t7 the number of bits that come after the msb (from the right)

    j loop2

    loop2:
        # print the current bit
        move $a0, $t1
        syscall

        beq $t7, $t6, exit2 # if t7 is now 32, leave the loop

        lw $t0, int # load the integer
        sllv $t0, $t0, $t7 # shift left by counter
        srl $t1, $t0, 31 # isolate the bit
        addi $t7, $t7, 1 # increment shamt
        j loop2

    exit2:

    li $v0, 4
    la $a0, nl
    syscall
    la $a0, yourIntBinRev
    syscall

    # now it's time to print the binary code in reverse
    addi $t6, $t6, -1 # get t6 to be 31
    move $t7, $t4 # put t7's value after the first loop back in t7
    li $t4, 0 # clear out t4 to save register space
    li $v0, 1 # prepare to print integers ("bits")
    li $t5, 0 # ensure t5 is 0
    lw $t0, int # get the input integer to t0

    loop3:
        sub $t4, $t6, $t5 # get t4 to the desired shamt
        sllv $t1, $t0, $t4 # shift left to eliminate unwanted bits from the left
        srl $a0, $t1, 31 # same, but now for the 31 bits to the right of my desired bit
        syscall # print that bit
        beq $t5, $t7, exit3 # if the reversal is complete, leave the loop
        addi $t4, $t4, 1 # add 1 to the shamt
        addi $t5, $t5, 1 # add 1 to the counter
        j loop3
    exit3:

    li $v0, 4
    la $a0, nl
    syscall

# end of execution
li $v0, 10
syscall
Or Bairey-Sehayek
  • 193
  • 1
  • 1
  • 8
  • You could make the leading-zero count loop much more efficient by not reloading `int` every time (you don't modify `$t0` inside the loop). You could also simplify the loop-exit condition so you have a conditional branch at the bottom. – Peter Cordes Nov 16 '17 at 03:37
  • 2
    Note that you never end up with the bit-reversed integer in a register, you're only printing out its bits in reverse order. – Peter Cordes Nov 16 '17 at 03:39