Question

In: Computer Science

I'm trying to code in MIPS (MIPS Assembly Language) to calculate the hamming distance between two...

I'm trying to code in MIPS (MIPS Assembly Language) to calculate the hamming distance between two integers. Ideally, the program would ask for the user to type in the two integers. Then, the program would calculate the hamming distance. Afterward, it would ask if you'd like to find another hamming distance. If the user says yes, it would loop back to the beginning and ask for two new integers.

Below is the code that I've created so far. Guidance with an explanation would be much appreciated! If creating a program from scratch (or if you have a similar program available that would demonstrate hamming distance in assembly), I'd be grateful! I want to examine working code to create my own version, but the code below is not working,

Thank you!

.data #Data section

.data   

prompt1:    .asciiz      "Enter the first number: "

prompt2:    .asciiz      "Enter the second number: "

resultText:    .asciiz      "Hamming Distance is: "

menu:     .asciiz      "Do you want to calculate Hamming Distance again? /n1)Yes /n2)No"   

.text

.globl main

main:

hammingProcess:

#ask the user to provide the first number

li $v0, 4     #command for printing a string

la $a0, prompt1 #loading the string to print into the argument to enable printing

syscall      #executing the command

#read the first number provided by the user

li $v0, 5    #command for reading an integer

syscall      #executing the command for reading an integer

move $t0, $v0     #moving the number read from the user input into the temporary register $t0

#ask the user to provide the second number

li $v0, 4    #command for printing a string

la $a0, prompt2    #loading the string into the argument to enable printing

syscall      #executing the command

#read the second number to be provided to the user

li $v0, 5    #command to read the number provided by the user

syscall      #executing the command for reading an integer

move $t1, $v0    #moving the number read from the user input into the temporary register $t1

xor $t8,$t0,$t1    #this xors the values stored in $t0 and $t1 and assigns them to the temporary register $t8

    la $t8,resultText      

    li $v0,4

    syscall        

       move $a0, $zero    # $a0 will hold the result

loop:

    bgez $t3, skip     # test the most significative bit of $t3

    sll $t3, $t3, 1    # (*) [NOTE below] shift left $t3 one bit

    addiu $a0, $a0, 1 # If bit was set, increment result

skip:   

    bnez $t3, loop     # loop while not done

    li $v0,1

    syscall

    la $a0,resultText2    

    li $v0,4

    syscall        

#The following block of code is to pre-load the integer values for the various instructions into registers for storage

li $t4, 1    #This is to load the immediate value of 1 into the temporary register $t4

li $t5, 2    #This is to load the immediate value of 2 into the temporary register $t5

la $a0, menu    #loading the string into the argument to enable printing

syscall      #executing the command

#the next block of code is to read the number provided by the user

li $v0, 5    #command for reading an integer

syscall      #executing the command

move $t2, $v0    #this command is to move the integer provided into the temporary register $t2

beq $t2,$t3,exitProcess    #Branch to 'exitProcess' if $t2 = 1

beq $t2,$t5,hammingProcess #Branch to 'hammingProcess' if $t2 = 2

exitProcess:

li $v0, 10

syscall

#This is to terminate the program

# END OF PROGRAM

Solutions

Expert Solution

Hi, I have solved your question, and if you need any further assistance do ping me.

My approach

  1. Calculate the XOR of two numbers.
  2. Count the number of set bits
​
 .file "hamming.cpp"
.text
.section .rdata,"dr"
__ZStL19piecewise_construct:
.space 1
__ZStL13allocator_arg:
.space 1
__ZStL6ignore:
.space 1
.lcomm __ZStL8__ioinit,1,1
.align 4
__ZN9__gnu_cxxL21__default_lock_policyE:
.long 2
__ZStL10defer_lock:
.space 1
__ZStL11try_to_lock:
.space 1
__ZStL10adopt_lock:
.space 1
.align 4
__ZNSt15regex_constantsL5icaseE:
.long 1
.align 4
__ZNSt15regex_constantsL6nosubsE:
.long 2
.align 4
__ZNSt15regex_constantsL8optimizeE:
.long 4
.align 4
__ZNSt15regex_constantsL7collateE:
.long 8
.align 4
__ZNSt15regex_constantsL10ECMAScriptE:
.long 16
.align 4
__ZNSt15regex_constantsL5basicE:
.long 32
.align 4
__ZNSt15regex_constantsL8extendedE:
.long 64
.align 4
__ZNSt15regex_constantsL3awkE:
.long 128
.align 4
__ZNSt15regex_constantsL4grepE:
.long 256
.align 4
__ZNSt15regex_constantsL5egrepE:
.long 512
.align 4
__ZNSt15regex_constantsL12__polynomialE:
.long 1024
.align 4
__ZNSt15regex_constantsL13match_defaultE:
.space 4
.align 4
__ZNSt15regex_constantsL13match_not_bolE:
.long 1
.align 4
__ZNSt15regex_constantsL13match_not_eolE:
.long 2
.align 4
__ZNSt15regex_constantsL13match_not_bowE:
.long 4
.align 4
__ZNSt15regex_constantsL13match_not_eowE:
.long 8
.align 4
__ZNSt15regex_constantsL9match_anyE:
.long 16
.align 4
__ZNSt15regex_constantsL14match_not_nullE:
.long 32
.align 4
__ZNSt15regex_constantsL16match_continuousE:
.long 64
.align 4
__ZNSt15regex_constantsL16match_prev_availE:
.long 128
.align 4
__ZNSt15regex_constantsL14format_defaultE:
.space 4
.align 4
__ZNSt15regex_constantsL10format_sedE:
.long 256
.align 4
__ZNSt15regex_constantsL14format_no_copyE:
.long 512
.align 4
__ZNSt15regex_constantsL17format_first_onlyE:
.long 1024
.align 4
__ZNSt15regex_constantsL13error_collateE:
.space 4
.align 4
__ZNSt15regex_constantsL11error_ctypeE:
.long 1
.align 4
__ZNSt15regex_constantsL12error_escapeE:
.long 2
.align 4
__ZNSt15regex_constantsL13error_backrefE:
.long 3
.align 4
__ZNSt15regex_constantsL11error_brackE:
.long 4
.align 4
__ZNSt15regex_constantsL11error_parenE:
.long 5
.align 4
__ZNSt15regex_constantsL11error_braceE:
.long 6
.align 4
__ZNSt15regex_constantsL14error_badbraceE:
.long 7
.align 4
__ZNSt15regex_constantsL11error_rangeE:
.long 8
.align 4
__ZNSt15regex_constantsL11error_spaceE:
.long 9
.align 4
__ZNSt15regex_constantsL15error_badrepeatE:
.long 10
.align 4
__ZNSt15regex_constantsL16error_complexityE:
.long 11
.align 4
__ZNSt15regex_constantsL11error_stackE:
.long 12
.align 4
__ZNSt8__detailL19_S_invalid_state_idE:
.long -1
.text
.globl __Z15hammingDistanceii
.def __Z15hammingDistanceii; .scl 2; .type 32; .endef
__Z15hammingDistanceii:
LFB7825:
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
subl $16, %esp
movl 8(%ebp), %eax
xorl 12(%ebp), %eax
movl %eax, -4(%ebp)
movl $0, -8(%ebp)
L3:
cmpl $0, -4(%ebp)
jle L2
movl -4(%ebp), %eax
andl $1, %eax
addl %eax, -8(%ebp)
sarl -4(%ebp)
jmp L3
L2:
movl -8(%ebp), %eax
leave
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
LFE7825:
.def ___main; .scl 2; .type 32; .endef
.section .rdata,"dr"
LC0:
.ascii "Enter the first number: \0"
LC1:
.ascii "Enter the second number: \0"
LC2:
.ascii "Hamming Distance is: \0"
.align 4
LC3:
.ascii "Do you want to calculate Hamming Distance again? \12\0"
LC4:
.ascii "1. Yes\12 2. No\12\0"
LC5:
.ascii "Yes\0"
LC6:
.ascii "yes\0"
LC7:
.ascii "YES\0"
.text
.globl _main
.def _main; .scl 2; .type 32; .endef
_main:
LFB7826:
.cfi_startproc
.cfi_personality 0,___gxx_personality_v0
.cfi_lsda 0,LLSDA7826
leal 4(%esp), %ecx
.cfi_def_cfa 1, 0
andl $-16, %esp
pushl -4(%ecx)
pushl %ebp
.cfi_escape 0x10,0x5,0x2,0x75,0
movl %esp, %ebp
pushl %ebx
pushl %ecx
.cfi_escape 0xf,0x3,0x75,0x78,0x6
.cfi_escape 0x10,0x3,0x2,0x75,0x7c
subl $48, %esp
call ___main
leal -40(%ebp), %eax
movl %eax, %ecx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev
L10:
movl $LC0, 4(%esp)
movl $__ZSt4cout, (%esp)
LEHB0:
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
leal -12(%ebp), %eax
movl %eax, (%esp)
movl $__ZSt3cin, %ecx
call __ZNSirsERi
subl $4, %esp
movl $LC1, 4(%esp)
movl $__ZSt4cout, (%esp)
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
leal -16(%ebp), %eax
movl %eax, (%esp)
movl $__ZSt3cin, %ecx
call __ZNSirsERi
subl $4, %esp
movl $LC2, 4(%esp)
movl $__ZSt4cout, (%esp)
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
movl $14, 4(%esp)
movl $9, (%esp)
call __Z15hammingDistanceii
movl %eax, (%esp)
movl $__ZSt4cout, %ecx
call __ZNSolsEi
subl $4, %esp
movl $__ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_, (%esp)
movl %eax, %ecx
call __ZNSolsEPFRSoS_E
subl $4, %esp
movl $LC3, 4(%esp)
movl $__ZSt4cout, (%esp)
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
movl $LC4, 4(%esp)
movl $__ZSt4cout, (%esp)
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
leal -40(%ebp), %eax
movl %eax, 4(%esp)
movl $__ZSt3cin, (%esp)
call __ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE
LEHE0:
movl $LC5, 4(%esp)
leal -40(%ebp), %eax
movl %eax, (%esp)
call __ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_
testb %al, %al
jne L6
movl $LC6, 4(%esp)
leal -40(%ebp), %eax
movl %eax, (%esp)
call __ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_
testb %al, %al
jne L6
movl $LC7, 4(%esp)
leal -40(%ebp), %eax
movl %eax, (%esp)
call __ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_
testb %al, %al
je L7
L6:
movl $1, %eax
jmp L8
L7:
movl $0, %eax
L8:
testb %al, %al
je L9
jmp L10
L9:
movl $0, %ebx
leal -40(%ebp), %eax
movl %eax, %ecx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev
movl %ebx, %eax
jmp L14
L13:
movl %eax, %ebx
leal -40(%ebp), %eax
movl %eax, %ecx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev
movl %ebx, %eax
movl %eax, (%esp)
LEHB1:
call __Unwind_Resume
LEHE1:
L14:
leal -8(%ebp), %esp
popl %ecx
.cfi_restore 1
.cfi_def_cfa 1, 0
popl %ebx
.cfi_restore 3
popl %ebp
.cfi_restore 5
leal -4(%ecx), %esp
.cfi_def_cfa 4, 4
ret
.cfi_endproc
LFE7826:
.def ___gxx_personality_v0; .scl 2; .type 32; .endef
.section .gcc_except_table,"w"
LLSDA7826:
.byte 0xff
.byte 0xff
.byte 0x1
.uleb128 LLSDACSE7826-LLSDACSB7826
LLSDACSB7826:
.uleb128 LEHB0-LFB7826
.uleb128 LEHE0-LEHB0
.uleb128 L13-LFB7826
.uleb128 0
.uleb128 LEHB1-LFB7826
.uleb128 LEHE1-LEHB1
.uleb128 0
.uleb128 0
LLSDACSE7826:
.text
.section .text$_ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_,"x"
.linkonce discard
.globl __ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_
.def __ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; .scl 2; .type 32; .endef
__ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_:
LFB8231:
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
subl $24, %esp
movl 12(%ebp), %eax
movl %eax, (%esp)
movl 8(%ebp), %ecx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc
subl $4, %esp
testl %eax, %eax
sete %al
leave
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
LFE8231:
.text
.def ___tcf_0; .scl 3; .type 32; .endef
___tcf_0:
LFB8524:
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
subl $8, %esp
movl $__ZStL8__ioinit, %ecx
call __ZNSt8ios_base4InitD1Ev
leave
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
LFE8524:
.def __Z41__static_initialization_and_destruction_0ii; .scl 3; .type 32; .endef
__Z41__static_initialization_and_destruction_0ii:
LFB8523:
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
subl $24, %esp
cmpl $1, 8(%ebp)
jne L20
cmpl $65535, 12(%ebp)
jne L20
movl $__ZStL8__ioinit, %ecx
call __ZNSt8ios_base4InitC1Ev
movl $___tcf_0, (%esp)
call _atexit
L20:
nop
leave
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
LFE8523:
.def __GLOBAL__sub_I__Z15hammingDistanceii; .scl 3; .type 32; .endef
__GLOBAL__sub_I__Z15hammingDistanceii:
LFB8525:
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
subl $24, %esp
movl $65535, 4(%esp)
movl $1, (%esp)
call __Z41__static_initialization_and_destruction_0ii
leave
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
LFE8525:
.section .ctors,"w"
.align 4
.long __GLOBAL__sub_I__Z15hammingDistanceii
.ident "GCC: (MinGW.org GCC Build-2) 9.2.0"
.def __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; .scl 2; .type 32; .endef
.def __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; .scl 2; .type 32; .endef
.def __ZNSirsERi; .scl 2; .type 32; .endef
.def __ZNSolsEi; .scl 2; .type 32; .endef
.def __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; .scl 2; .type 32; .endef
.def __ZNSolsEPFRSoS_E; .scl 2; .type 32; .endef
.def __ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE; .scl 2; .type 32; .endef
.def __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; .scl 2; .type 32; .endef
.def __Unwind_Resume; .scl 2; .type 32; .endef
.def __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; .scl 2; .type 32; .endef
.def __ZNSt8ios_base4InitD1Ev; .scl 2; .type 32; .endef
.def __ZNSt8ios_base4InitC1Ev; .scl 2; .type 32; .endef
.def _atexit; .scl 2; .type 32; .endef


​

venereology answered 7 months ago
Next > < Previous

Related Solutions

MIPS ASSEMBLY LANGUAGE (I'm using MARS) Can you provide me with the code of this, without...
MIPS ASSEMBLY LANGUAGE (I'm using MARS) Can you provide me with the code of this, without using DIV (4a-b)%[(2+c)/d] (a,b,c,d are user inputs)
This is to be done with MIPS assembly language. Write MIPS code which is equivalent to...
This is to be done with MIPS assembly language. Write MIPS code which is equivalent to the follow java program: int day = (int)(Math.random() * 7); switch (day) { case 1: System.out.println(“Monday”); break case 2: System.out.println(“Tuesday”); break case 3: System.out.println(“Wednesday”); break case 4: System.out.println(“Thursday”); break case 5: System.out.println(“Friday”); break case 6: System.out.println(“Saturday”); break case 0: System.out.println(“Sunday”); break }
Write a MIPS assembly language to transpose a square integer matrix in code
Write a MIPS assembly language to transpose a square integer matrix in code
MIPS Assembly LanguageWrite a MIPS assembly language program that asks the user toinput an...
MIPS Assembly LanguageWrite a MIPS assembly language program that asks the user to input an integer and then prints out a string that shows how that integer should be encoded using 16 bits. Your program should handle both positive and negative valued inputs. Your program should also print out an error message if the given input cannot be expressed as a 16 bit signed integer.As an example, if the input is 12, your program should output “0000000000001100”. If the input...
Write a MIPS assembly language program that implements the following pseudo-code operation: result = x +...
Write a MIPS assembly language program that implements the following pseudo-code operation: result = x + y – z + A[j] x and y should be in reserved memory words using the .word directive and labeled as x and y. Initialize x=10 and y=200. Read in z from the console. Input the value -8. This is the value for z, not for –z. Store this value in memory with the label z. To begin, you could just initialize z to...
Use MIPS assembly language program to swap two of the integers in an integer array. The...
Use MIPS assembly language program to swap two of the integers in an integer array. The program should include the Swap function to swap the integers and the main function to call the Swap function. The main function should: • Pass the starting address of the array in $a0. • Pass the indices of the two elements to swap in $a1 and $a2. • Preserve (i.e. push onto the stack) any T registers that it uses. • Call the Swap...
Write a mips assembly language program to ask the user to enter two integers A and...
Write a mips assembly language program to ask the user to enter two integers A and B and then display the result of computing the expression: A + 2B - 5.
Translate following pseudo-code to MIPS assembly language cout << “\n Please input a number for $s0”;...
Translate following pseudo-code to MIPS assembly language cout << “\n Please input a number for $s0”; cin >> $s0; cout << “\n Please input a number for $s1”; cin >> $s1; cout << “\n Please input a number for $s2”; cin >> $s2; $t0 = $s0 / 8 - 2 * $s1 + $s2; cout << “\n the Value of the expression “$s0 / 8 - 2 * $s1 + $s2” is ”; cout >> $t0; return;
Assemby language - MIPS Your assembly should implement the C code directly – i.e.,do not ’optimize’...
Assemby language - MIPS Your assembly should implement the C code directly – i.e.,do not ’optimize’ the C code to change the order of operations or reduce computations. Write MIPS assembly code implementing the following C/C++ statement: y = 13 - 11*x; One way of doing the multiply without a multiply instruction is by using many add instructions (x+x+...+x). For this problem you should do it with fewer additions. Hint: We know how to express any integer as a sum...
need a code MIPS assembly language program to implement algorithms of an 8-bit integer "positive integer"...
need a code MIPS assembly language program to implement algorithms of an 8-bit integer "positive integer" to calculate the square root for an-8 bit integer using The Radix-2 SRT-Redundant and Non-Redundant Algorithm to approximate square root
ADVERTISEMENT
Subjects
ADVERTISEMENT
Latest Questions
ADVERTISEMENT