汇编代写 | assembly代写 – CS 3280 LAB Assignment

汇编代写 | assembly代写 : 这是一个基本的汇编语言代写练习
You are to design, write, assemble, and simulate an assembly language program which will generate
Fibonacci sequence numbers. Giving is a table NARR of byte-long numbers (with a $00 sentinel).
Each element in the table corresponds to the sequence number of a Fibonacci number to be
generated. The actual calculation of the corresponding 4-byte Fibonacci numbers has to be
implemented in a subroutine. The 4-byte Fibonacci numbers have to be passed back to the main
program, which stores them in the RESARR array.
PLEASE NOTE:
1. Your program should work for any N value, not just the ones given in the table.
2. Do NOT use the X or Y registers for storing or manipulating DATA.
Only use the X and Y registers for storing/manipulating ADDRESSES.
3. All multi-byte data items are in Big Endian format (including all program variables)
4. Your program is NOT allowed to change the numbers stored in the NARR table.
5. You have to use the program skeleton provided for Lab4. Do not change the data section or you
will lose points! This means: do not change the ‘ORG $B000’ and ‘ORG $B010’ statements or
the variable names ‘NARR’ and ‘RESARR’. Do NOT change the values assigned to the NARR
table. If you need to define additional variables, please add them in the appropriate places.
6. You are allowed to declare static variables in your subroutine (through RMB).
7. Your subroutine does not have to be transparent. This means that your subroutine does not
have to restore the original content of registers (the content of registers when entering the
subroutine) before exiting the subroutine.
8. Your subroutine should only have one exit point. This means that only a single RTS instruction
at the end of the subroutine is allowed.
9. Initialize any additional variables that your program (main program and subroutine) needs
within the program, NOT with a FCB or FDB in the data section
10. You must terminate your main program correctly using an infinite loop structure.
11. You do not have to optimize your algorithm or your assembly program for speed.
12. You have to provide a pseudo-code solution for your main program AND your subroutine. In
your pseudo code, do NOT use a for loop, but either a while or a do-until construct to
implement a loop. Also, do NOT use any “goto”, “break”, or “exit” statements in your
pseudocode.
13. The structure of your assembly program should match the structure of your pseudo code 1-to-1.
14. You are allowed to use parts of your LAB3 or parts of the official LAB3 solution.
15. The main program should be a WHILE structure which goes through the NARR table and sends
an N value to the subroutine during each iteration. The while structure will also check for the
Sentinel (which is the $00 at the end of the table) at each iteration. The Sentinel is NOT one of
the data items and it should NOT be processed by the subroutine. The main program must end
the while loop when the $00 is encountered. For each subroutine call, the subroutine will send
back a 4-byte result that has to be stored consecutively in the RESARR array in Big-Endian
format.
– You are not allowed to just manually count the number of elements in the table and set up a
fixed number in memory as a count variable.
– Your program should still work if the arrays (NARR and RESARR) are moved to different
places in memory (do not use any fixed offsets).
– You don’t have to copy the sentinel to the end of the RESARR array.
– Your program should work for any number of elements in the table. Thus, there could be more
than 255 elements in the table. Using the B-register as an offset and the ABX/ABY
instructions to point into the array will therefore not work.
16. For each iteration, the main program should take one number from the NARR table and pass it
to the subroutine in a REGISTER (call-by-value in register). The subroutine performs the
calculation and produces the corresponding 4-byte Fibonacci number. The resulting 4-byte
number must be passed back to the main program OVER THE STACK (call-by-value over
the stack) in Big Endian format. The main program then retrieves the 4 bytes from the stack
and stores them in the RESARR array in Big Endian format. Thus, if the NARR table has 8
data items (excluding the sentinel), the RESARR array should consist of 32 bytes (8 4-
byte Fibonacci numbers) after program execution.
– ALL of the number processing must be done inside a single subroutine.
– Make sure that your program will not generate a stack underflow or overflow.
17. You do not have to check for overflow when calculating the Fibonacci numbers.
18. Any assembler or simulator error/warning messages appearing when assembling/simulating
your submitted program will result in 50 points lost.
!!! NOTE !!! – ONLY LOCAL VARIABLES ARE ALLOWED (LOCAL TO THE MAIN
PROGRAM AND THE SUBROUTINE). INSIDE THE SUBROUTINE YOU CAN ONLY
ACCESS LOCAL VARIABLES AND ITEMS PASSED IN FROM THE MAIN PROGRAM!!!
YOU MUST NOT ACCESS MAIN PROGRAM VARIABLES (SUCH AS NARR and RESARR,
OR ANY OTHER VARIABLE DECLARED IN THE MAIN PROGRAM) FROM WITHIN THE
SUBROUTINE!!! ALSO, THE MAIN PROGRAM IS NOT ALLOWED TO ACCESS ANY
LOCAL SUBROUTINE VARIABLES!!!
-> IF YOU HAVE A QUESTION AS TO WHETHER YOUR PROGRAM OR SUBROUTINE
VIOLATES ANY OF THE SPECIFIC REQUIREMENTS, ASK THE INSTRUCTOR.
—————————————————————————–
Your program should include a header containing your name, student number, the date you wrote
the program, and the lab assignment number. Furthermore, the header should include the purpose of
the program and the pseudocode solution of the problem. At least 85% of the instructions should
have meaningful comments included – not just what the instruction does; e.g., don’t say “increment
the register A” which is obvious from the INCA instruction; say something like “increment the loop
counter” or whatever this incrementing does in your program. You can ONLY use branch labels
related to structured programming, i.e., labels like IF, IF1, THEN, ELSE, ENDIF, WHILE,
ENDWHL, DOUNTL, DONE, etc. DO NOT use labels like LOOP, JOE, etc.
YOU ARE TO DO YOUR OWN WORK IN WRITING THIS PROGRAM!!! While you can
discuss the problem in general terms with the instructor and fellow students, when you get to the
specifics of designing and writing the code, you are to do it yourself. Re-read the section on
academic dishonesty in the class syllabus. If there is any question, consult with the instructor.
——————————————————————————–
Submission:
Electronically submit your .ASM file on Canvas by 1:00pm on the due date. Late submissions or resubmissions
(with a 10% grade penalty) are allowed for up to 24 hours (please see the policy on late
submission in the course syllabus).
Note:
Because of some inherent lack of reliability designed into computers, and Murphy’s law by which
this design feature manifests itself in the least convenient moment, you should start your work early.
Excuses of the form:
“my memory stick went bad,”
“I could not submit my program,”
“my computer froze up, and I lost all my work;”
should be directed to the memory stick manufacturer, Canvas system administrator, and your local
Microsoft vendor respectively.
Grade Requirements and Breakdown
Requirements Point Value
Program must produce correct answers 50 pts
Program implements correct parameter passing 30 pts
Program must have good structure 20 pts
Total Points 100 pts
Penalties:
Program does not assemble or is incomplete -50 pts (No partial credit)
Any assembler or simulator error/warning messages -50 pts (No partial credit)
No comments at all -20 pts (No partial credit)
Wrong algorithm implemented -50 pts (No partial credit)
Main program variables accessed directly in
subroutine or subroutine variables accessed directly
in main program
-50 pts (No partial credit)
Insufficient program comments (including
incomplete program header) or incorrect/incomplete
pseudo code
-20 pts