代写program、代做c/c++语言编程

日期：2024-03-30 07:55

Contents

Dates.............................................................................................................................................................1

Early: Tuesday, 26-March-2024 at 11:58 PM........................................................................................1

On Time: Thursday, 28-March-2024 at 11:58 PM ................................................................................1

Late Cutoff: Friday, 29-March-2024 at 11:58 PM .................................................................................1

Lab 5: Assembler in Two Functions...............................................................................................................1

The Two Functions and Three Shims............................................................................................................2

Analyze..........................................................................................................................................................3

Middle...........................................................................................................................................................3

Output...........................................................................................................................................................5

For atest:...................................................................................................................................................5

For lab5: ....................................................................................................................................................5

GDB ...............................................................................................................................................................5

Bonus ............................................................................................................................................................6

Register Bonus..........................................................................................................................................6

Main Bonus...............................................................................................................................................6

Register Allocation........................................................................................................................................6

Required Stuff...............................................................................................................................................7

Comments.....................................................................................................................................................7

Readme .........................................................................................................................................................7

Submission....................................................................................................................................................7

Dates

There are no prototypes for assembler labs. It is a very good idea to build a little, test a little as you go.

Early: Tuesday, 26-March-2024 at 11:58 PM

On Time: Thursday, 28-March-2024 at 11:58 PM

Late Cutoff: Friday, 29-March-2024 at 11:58 PM

Lab 5: Assembler in Two Functions

Lab 5 introduces:

? Assembler programming

? Calling functions

? Loops

? Decisions

? Arrays

? Pointers

? Register allocation

? Stack details

The short form of what goes in in lab 5 is: Search an array for a value, return its address (or NULL if not

found). Along the way, track the largest and smallest values. Do this using two functions that you write

and some supporting functions that will be given to you.

The Two Functions and Three Shims

Here are the signatures of the two functions you will write. You will write them in assembler. Your code

will follow all conventions we have gone over. Do not write any C code for this lab. No code that you

write will directly call these two functions.

int *analyze(int value, int count, int array[], int *min_ptr, int *max_ptr);

int *middle( int value, int count, int array[]);

These functions will not be called directly. Instead two “shims” will fit between the caller and the

function called. They have the same signatures as your code. The shims do various forms of error

checking on your behalf.

int *a_shim(int value, int count, int array[], int *min_ptr, int *max_ptr);

int *m_shim( int value, int count, int array[]);

Note the mixture of 32 bit ints and 64 bit pointers. Your assembler code will need to be aware of sizes.

There is also a shim that goes between your code and printf. That shim is called print. Don’t sweat the

signature, you are calling it from assembler code. Do not call printf directly from your assembler code.

Use print just like you use printf.

All of the shims will detect if they were called with the stack meeting the 16-byte boundary rule. They

will print an error if the stack was not correctly aligned. Your code must follow the 16-byte alignment

rule.

These functions are tested by two different make targets. The attest target uses analyze and the lab5

target uses both analyze and middle. Do analyze first.

Analyze

After some initializations, analyze loops through the data in the array. Inside the loop, your code can

only do a single memory touch per location in the array to read the value. Store the current value in a

register. Then make some decisions:

? If the current value is larger than the maximum value, change the current maximum value to the

current value.

? If the current value is smaller than the minimum value, change the current minimum value to

the current value.

? If the current value is the one being sought, record the address so that it can be returned

After the loop is done, store the current min and max values in the correct memory locations. You code

can only touch those locations once each.

The initializations you will need before starting the loop include setting the return value to NULL. That

value clearly wants to be in a register and it is easy to figure out which one. Analyze makes no calls, so

register choices are straightforward. The current min and max values also will be stored in registers.

The middle function protects analyze from being passed an empty array, so you can use a value from the

array to initialize them both. This single additional memory touch is exempt from the rule that you can

only touch memory one time per location. In other words, total memory touches allowed are 1 for the

initialization, n for the reads in the loop, and 2 more to write the min and max. Setting up the stack

frame is not subject to this rule.

Analyze has 5 parameters and numerous things to keep track of whilst it does its work. There are 9

caller saved registers and you might run out of them. This is called register pressure, which can be a

global thing as it is here or a focused thing such as when rdi or rax need to used numerous different

ways in the same function. If you do run out of caller saved registers, resort to as many callee saved

registers as you need to keep everything in register. One bonus point is available if your code comes in

at 8 registers or fewer without resorting to inappropriate trickery like trying to stuff two C ints into the

upper and lower half of a 64 bit register.

Use the atest target in the makefile to test your code. You don’t need to write middle to write analyze.

Note that the array holds 32 bit C ints. Make sure that you address memory correctly.

Middle

The function middle exists mostly to teach you about callee saved registers, stack allocation, and just

what hog printf happens to be. Here is what middle should do, expressed in C code:

Do not transcribe this C code as C code!

The presence of a middle.c file is an indicator of academic misconduct. All mercy rule zeroes will be

reinstated without discussion and you can expect to wind up in front of CoAM. This is also true of

analyze; an analyze.c file will be treated as academic misconduct.

While we are here, the presence of GitHub co-pilot will also reinstate all mercy rule zeros and subject

all of your labs to careful examination with the intent of putting you in front of CoAM. Your lab scores

will be compared against your performance on the midterm and final exam coding problems.

Uninstall it now if you have it installed.

This code gives a clear an unambiguous set of requirements for what the function middle is expected to

do. Decompose the C code and the implications of every single line and use it to guide you as you write

your middle.s file. Doing this is practice for something you will be expected to do on the final exam.

Note that min and max are local variables. So is rval, but it is handled differently. The code takes the

address of min and max and passes that to analyze via a_shim. Registers do not have an address, so you

can’t store them in registers. None of the code ever exposes the address of rval, so it could go into a

register. You know where rval has to wind up by the time ret executes but look carefully before

deciding if it can stay there the whole time.

About this time you might review register allocation and the rules and guidance on what goes where

and why. Along with that a refresher on how we lay out the stack might be in order.

Use the lab5 target in the makefile to test your middle code. You will need a working analyze.

Middle is where you find out if your code follows the 16-byte alignment rule. If need be, you can grow

the stack using subtract. Be sure that you understand where to do this and by how much.

Output

You might get different pointer values.

For atest:

[kirby.249@cse-sl4 instructor]$ atest

Run: looking for -300 in 4 ints

Found -300 at 0x601058

Min is -400, max is -100

Run: looking for 0 in 5 ints

Did not find 0

Min is 16, max is 2048

Run: looking for 0 in 3 ints

Found 0 at 0x7ffdf2f79660

Min is -1, max is 1

For lab5:

[kirby.249@cse-sl4 instructor]$ lab5

lab5: looking for -300 in 4 ints

Middle: Looking for -300 in array of 4 ints

Middle: min is -400, max is -100, pointer is 0x601058

lab5: Found -300 at 0x601058

lab5: looking for 0 in 5 ints

Middle: Looking for 0 in array of 5 ints

Middle: min is 16, max is 2048, pointer is (nil)

lab5: Did not find 0

lab5: looking for 0 in 3 ints

Middle: Looking for 0 in array of 3 ints

Middle: min is -1, max is 1, pointer is 0x7ffc2886bfe0

lab5: Found 0 at 0x7ffc2886bfe0

GDB

The first time atest builds, run it under gdb and step through your code. Invoke tui reg general and

predict how each register will change before you take each step. Watch the values appear (in hex) in

the various registers. Go back to lab 1 and look at all of the gdb commands you were required to use

there and refresh them in your memory.

Probable bugs: Reversing the sense of a condition runs very high on the list!

Probable bugs: Mixing up two register names. This language is hot revenge for all those times you might

have slacked off and picked a less-than-stellar variable name when you had 32 characters at your

disposal.

DO NOT CALL PRINTF TO DEBUG! Trying to debug with printf is negative progress; it makes things

worse.

Imagine a grainy blue hologram: “Help me, GDB. You’re my only hope.”

https://www.youtube.com/watch?v=5cc_h5Ghuj4

We might need more than the ability to see what is in the registers, we might need to be able to

examine memory.

https://ftp.gnu.org/old-gnu/Manuals/gdb/html_node/gdb_55.html

Run gdb on atest. Set a breakpoint. Then issue the run command. Issue the tui reg general

command. Let’s look at memory. To do that, we need an address. The memory we want to examine is

in the stack. RSP and RBP point into the stack but in the case of analyze, so do rcx (min pointer) and r8

(max pointer). Let’s look at the int that rcx currently points to. Use this gdb command:

x/1iw $rcx

It examines 1 integer format “word” (which here means 32 bit) starting at the address in rcx. It will print

the address where it started, a colon, and then the value. The i between the 1 and the w makes sure

that it displays in decimal. Use g for the size “giant” and x for the format to look at an address in hex).

Poking at memory this way lets us see the values that get written at the end of the loop.

Bonus

Register Bonus

One bonus point for bringing in analyze in 8 caller saved registers.

Main Bonus

One bonus point for implementing the main function given in lab5.c in assembler. This takes some

doing. You do not have to implement the function run in assembler to get this point. Note that some of

the arrays are static and one is not. You will need to create main.s for your main function and use the

bonus target in the supplied makefile.

Register Allocation

Register allocation policy is graded.

One of the required functions is leaf-level and the other is not. This guides your register allocation

policy.

You really do want a firm grasp on register allocation before you take the final exam, so work it out here

and in lab 6. Before you write any code, figure out how many “variables” you will need and assign them

to registers of the appropriate type.

Required Stuff

All of your functions must create a stack frame upon entry and tear it down upon exit.

The first usage of any register in a function must have a comment telling what that register means. For

example:

xorq %rax, %rax # rax is both a subscript and return value at the same time.

This is usually near the top of your function. It is your pocket guide to the registers. In your comments

you should refer to the registers not by name but by what they mean.

Comments

Comment your code. Comments should say things that are not obvious from the code. In assembler

you almost always have something to say for every line of code. You could easily have more comment

lines than code lines. Comment what each register holds. Comment about how the operation has a

higher level meaning. Try to avid comments that say the exact same thing as the code – this might get

you points off.

Put your name and the assignment number in your initial comments. Also add the statement that says

that you wrote all of the code in the file (see below). Or you can forget it and get a zero on the lab.

Readme

As always, create a text README file, and submit it with your code. All labs require a readme file.

Include:

? Your name

? Hours worked on the lab

? Short description of any concerns, interesting problems, or discoveries encountered. General

comments about the lab are welcome.

Submission

No surprises here. Your zip file needs:

? A readme file

? All of your .s files

? Makefile, modified to add a zip target and your name

? The supplied files needed to make lab5 and atest build (plus any others for the second bonus)

Be sure that the zip target in the makefile self-tests all executables from the contents of the zip file. Any

zip file that fails to build gets a zero. Any makefile that doesn’t self-test the zip is marked late regardless

of when it was turned in.

Be sure to add this text to ALL of your .s files:

# BY SUBMITTING THIS FILE AS PART OF MY LAB ASSIGNMENT, I CERTIFY THAT

# ALL OF THE CODE FOUND WITHIN THIS FILE WAS CREATED BY ME WITH NO

# ASSISTANCE FROM ANY PERSON OTHER THAN THE INSTRUCTOR OF THIS COURSE

# OR ONE OF OUR UNDERGRADUATE GRADERS. I WROTE THIS CODE BY HAND,

# IT IS NOT MACHINE GENRATED OR TAKEN FROM MACHINE GENERATED CODE.

If you omit a required file, you get zero points.

If you fail to add the above comment you get zero points

If the make command as given generates any warnings or errors you get zero points

Every file you hand edit needs your name in it.

This is one of the easiest labs to get full marks on, don’t blow it.