$1.(30$ points$)$ Using the echo$\_$nsl$.$s program below, write an assembly program that inputs a single

character from stdin and then prints the character before it to stdout. For example, if you enter a $$D$,$

your program will output a $$C$.$ In order for your character to be passed to your program, you will

have to press the enter key to flush the input buffer. Your program will output only one character.

Name your program pred$\_$nsl$.$s$.$

$2.(60$ points$)$ Read two decimal digits from stdin and interpret that input as an integer between $0$ an

$99,$ inclusive. Compute $27$x $+17,$ where x is the provided integer. Print the input value, the result in

decimal and hexadecimal like this:

x $=19$ : f$($x$)=530$ or $0$x$212$

Spacing matters. You can get the integer value of an ASCII digit by subtracting $0$ from it$.$ The

appendix has an example of using

Name your program fx$.$s$.$

$3.10$ points Write prompts for the two programs above and submit them to the LLM of your choice. Save

the resulting code $($not any explanation that came with it$)$ into pred$\_$prom.s and fx$\_$prom.s$.$ Include

the prompt as a comment at the top of the source file. Also include a critique of the geneated code in

the introductory comments as well.

Appendix

The following program reads a single character and outputs the character following it in the ASCII encoding.

It uses Linux system calls to perform I?O with sys$\_$read and sys$\_$write. It uses the $\_$start label and is in

conflict with C$$s stdlib library. The $-$nostdlib directive must be added for linking to succeed.

# echo$\_$nsl$.$s

# Read one character from stdio, add one to the ASCII value, and write

# it on stdout.

# gcc $-$nostdlib $-$no$-$pie echo$\_$nsl$.$s $-$o echo$\_$nsl

# this line prevents a loader warning

$.$section $.$note.GNU$-$stack,"",@progbits

$.$section $.$data

$.$comm buffer, $1$ # Allocate $1$ byte for the input character

$.$section $.$text

$.$global $\_$start

# This program does not use stdlib. The linker recognizes $\_$start

# as the beginning of execution.

$\_$start:

# Read a single character from stdin

movq $$0,\%$rax # syscall number for sys$\_$read $(0)$

movq $$0,\%$rdi # file descriptor for stdin $(0)$

movq $buffer, $\%$rsi # pointer to the buffer

movq $$1,\%$rdx # number of bytes to read

syscall

# Add $1$ to the ASCII value of the character

movb buffer, $\%$al # Load the byte from buffer into AL

addb $$1,\%$al # Increment the ASCII value by $1$

movb $\%$al$,$ buffer # Store the result back to buffer

# Write the modified character to stdout

$1$

movq $$1,\%$rax movq $$1,\%$rdi movq $buffer, $\%$rsi movq $$1,\%$rdx syscall

# Exit the program

movq $$60,\%$rax movq $$0,\%$rdi syscall

# syscall number for sys$\_$write $(1)$

# file descriptor for stdout $(1)$

# pointer to the buffer

# number of bytes to write

# syscall number for sys$\_$exit $(60)$

# status $=0$

The following program does some computation and then uses printf to output the values. It requires stdlib.

Since stdlib defines $\_$start, the entry point for this program will be main.

# printf.s

# This program adds $48$ and $29$ and then outputs the sum in hex. It

# uses stdlib.

# gcc $-$no$-$pie echo.s $-$o echo

# prevents missing $.$note.GNU$-$stack error

$.$section $.$note.GNU$-$stack,"",@progbits

#$.$extern putchar

$.$section $.$data

num$1$: $.$word $48$

num$2$: $.$word $29$

# The h in the format specifier is a length parameter.

# Printf expects a unsigned short int.

format: $.$string "result $=\%04$hx

$\backslash 0"$

$.$section $.$text

$.$global main

main:

# Load the values into registers

movl num$1,\%$eax

movl num$2,\%$ebx

# Add the values

addl $\%$ebx, $\%$eax

# save the callee of main, call to printf will wipe it out

push $\%$rbp

# Call printf to print the result:

# printf$("\%04$hx

$",$ sum$)$

# loads effective address of format string

# into first argument register

lea format, $\%$rdi

# move value we want to print into the

# second argument register

movl $\%$eax, $\%$esi

call printf

# Restore the callee that was overwritten by

# call to printf

pop $\%$rbp

ret

Here$$s a makefile to help you out. The gcc lines are preceded by tabs$,$ not spaces.

$\%\_$nsl: $\%\_$nsl$.$s

gcc $-$nostdlib $-$no$-$pie $$<-$o $\%$@

$\%$: $\%.$s

gcc $-$no$-$pie $$<-$o $@