Hello, i am new at assembly language and i just got started with this stuff. I have this assignment which doesn't make any sense to me.
Can someone please help?
I am using Kip Irvine's, Assembly Language for x86 Processors, 6th edition.
These are the instructions to assignment:
1. I have to write a program that defines 3 WORD(DW) variables and initializes each of these to 0.
2. I have to use authors DumpMem procedure to dump all the three variables.
3. Into register ax put -3
4. Into register bx put 64000
5. Into register dx put -64000
6. Store each of these into the variable that you defined. You may decide which register goes into which memory variable.
7. Use the authors DumRegs procedure to display the content of the registers.
8. Use the DumpMem again to look at the 3 variables in memory
9. Use the visual studio debugger and display the registers.
Can someone please explain what to do with an example, any help is appreciated.
Thanks
Sure! I can help you with your assignment. Let's break it down step by step.
1. To begin, you need to define three WORD (DW) variables and initialize them to 0. This can be done in assembly language by using the `.data` section to define the variables and then assigning the value 0 to each of them. Here's an example of how you can do this:
```assembly
.data
variable1 WORD 0
variable2 WORD 0
variable3 WORD 0
```
2. Next, you need to use the `DumpMem` procedure to dump all three variables. The `DumpMem` procedure is provided by the author, so you can simply call it in your program. Here's an example:
```assembly
.code
main PROC
call DumpMem
; You can also use specific parameters to only dump a range of memory addresses
; For example: call DumpMem, ADDR variable1, ADDR variable3
; This will dump the memory from variable1 to variable3
; If you don't provide any parameters, it will dump the entire memory.
main ENDP
```
3. Now, let's put the value -3 into the `ax` register. In assembly language, you can use the `mov` instruction to move values between registers and memory. Here's an example:
```assembly
.code
main PROC
mov ax, -3
main ENDP
```
4. Similarly, you can put the value 64000 into the `bx` register:
```assembly
.code
main PROC
mov ax, -3
mov bx, 64000
main ENDP
```
5. And put the value -64000 into the `dx` register:
```assembly
.code
main PROC
mov ax, -3
mov bx, 64000
mov dx, -64000
main ENDP
```
6. Now, you need to store the values from the registers into the variables you defined earlier. You can use the `mov` instruction for this as well. Here's an example:
```assembly
.code
main PROC
mov ax, -3
mov bx, 64000
mov dx, -64000
mov variable1, ax
mov variable2, bx
mov variable3, dx
main ENDP
```
7. To display the content of the registers, you can use the `DumpRegs` procedure provided by the author. Simply call it in your program. Here's an example:
```assembly
.code
main PROC
mov ax, -3
mov bx, 64000
mov dx, -64000
mov variable1, ax
mov variable2, bx
mov variable3, dx
call DumpRegs
main ENDP
```
8. Finally, you can use the `DumpMem` procedure again to look at the values stored in memory. Call the procedure with the appropriate parameters to dump the range of memory addresses you're interested in. Here's an example:
```assembly
.code
main PROC
mov ax, -3
mov bx, 64000
mov dx, -64000
mov variable1, ax
mov variable2, bx
mov variable3, dx
call DumpRegs
call DumpMem, ADDR variable1, ADDR variable3
main ENDP
```
9. To display the registers using the Visual Studio debugger, you can run your program in debug mode. Set breakpoints at appropriate locations in your code and inspect the registers in the debugger. You can use the "Registers" window to view the values of registers like `ax`, `bx`, `dx`, etc.
I hope this explanation helps you understand the steps involved in completing your assignment. Remember to include the necessary includes and define any required procedures from the author's library for your code to work correctly. Good luck!