---
# System prepended metadata

title: LAB 4

---

## LAB 4
##### Name: Aseem Anand
##### Roll No. : CS22B008
# Question 1
## Code
.data
arr:
    .word 1,2,3,4,5,6,7,8,9,10,11
.text
main:
    la s0 arr
    li s1 3
    li s2 10
    li s3 -1
    loop1:
        beq s2 s3 exit
        lw s4 40(s0)
        add s4 s4 s1
        sw s4 40(s0)
        addi s2 s2 -1
        addi s0 s0 -4
    exit:
        li a7 10
# Question 2
## Code
.data
arr:
    .word 1,2,34,3,4,5,7,23,12
str1:.string "true"
str2:.string "false"
space:.string " "
.text
main:
la s0 arr
li s1 0
li s2 8
loop:
lw s3 0(s0)
bge s1 s2 done
lw s4 4(s0)
lw s5 8(s0)
isODD:
blt s3 zero firstOdd
beq s3 zero Even
li s6 2
sub s3 s3 s6
j isODD
Even:
addi s0 s0 4
addi s1 s1 1
j loop
firstOdd:
blt s4 zero secondOdd
beq s4 zero Even
li s6 2
sub s4 s4 s6
j firstOdd
secondOdd:
blt s5 zero Ptrue
beq s5 zero Even
li s6 2
sub s5 s5 s6
j secondOdd
done:
la a0 str2
li a7 4
ecall
Exit:
li a7 10
ecall
Ptrue:
la a0 str1
li a7 4
ecall
Exit1:
li a7 10
ecall
# Question 3
## Code
.data
arr:
    .word 2,5,1,3,4,7
arr1:
    .word 0,0,0
arr2:
    .word 0,0,0
space:.string " "
.text
main:
    la s0 arr
    la s1 arr1
    la s2 arr2
    li s3 0
    li s6 3
    li s4 6
    loop:
        beq s3 s6 loop1
        lw s5 0(s0)
        sw s5 0(s1)
        addi s3 s3 1
        addi s1 s1 4
        addi s0 s0 4
        j loop
    loop1:
        beq s3 s4 halt1
        lw s5 0(s0)
        sw s5 0(s2)
        addi s3 s3 1
        addi s0 s0 4
        addi s2 s2 4
        j loop1
    halt1:
        li s3 0
        addi s0  s0 -24
        addi s1 s1 -12
        addi s2 s2 -12
    loop2:
        beq s3 s6 halt2
        lw s5 0(s1)
        sw s5 0(s0)
        addi s1 s1 4
        addi s0 s0 4
        lw s5 0(s2)
        sw s5 0(s0)
        addi s3 s3 1
        addi s2 s2 4
        addi s0 s0 4
        j loop2
    halt2:
        li s3 0
        addi s0  s0 -24
    done:
        beq s3 s4 exit
        lw a0 0(s0)
        li a7 1
        ecall
        la a0 space
        li a7 4
        ecall
        addi s0 s0 4
        addi s3 s3 1
        j done
    exit:
        li a7 10
        ecall
# Question 4
## Code
.data
arr:
    .word 2,7,11,15
space: .string " "
.text
main:
    li s0 9 #target loaded
    la s1 arr
    li s2 0
    li s3 0
    li s4 4 #size of array
    loop:
        bne s2 s4 halt1
        halt1:
            addi s3 s2 1
            lw s5 0(s1)
            sub s7 s0 s5
        loop1:
            addi s8 s1 4
            beq s3 s4 halt
            if:
                lw s6 0(s8)
                beq s7 s6 print
                addi s3 s3 1
                addi s8 s8 4
                j loop1
            halt:
                addi s2 s2 1
                addi s1 s1 4
                j loop
 
 print:
     add a0 a0 s2
     li a7 1
     ecall
     la a0 space
     li a7 4
     ecall
     li a0 0
     add a0 a0 s3
     li a7 1
     ecall
 exit:
     li a7 10
     ecall 
# Question 5
## PseudoCode
.data
node:
    .word 0      # data field
    .word 0      # next pointer field

head: 
    .word 0      # head pointer
newline:
        .string " "
str:
    .string "->"
.text
main:
    # Initialize head pointer to null
    la x10, head
    li x11, 0
    sw x11, 0(x10) 
    # Insert nodes into the linked list
    li x12, 5        # Number of nodes to insert
    li x13, 1        # Initial data value
    li x14, 0        # Counter
insert_loop:
    bge x14, x12, end_insert_loop
    # Insert node with data value x13
    mv a0, x13       # Argument: data value
    jal insert_node
    # Increment data value for next node
    addi x13, x13, 1
    # Increment counter
    addi x14, x14, 1
    j insert_loop
end_insert_loop:
    # Print the linked list
    la a0, head      # Load head pointer
    jal print_list   
    # Exit
    li a0, 10        # Exit code
    ecall            # System call to exit
#Function to insert a node with given data value
insert_node:
    # Arguments:
    #   a0 = data value
    # Allocate memory for the new node
    li a7, 9          # syscall 9 - sbrk (allocate heap memory)
    li a1, 8          # Allocate space for two words (data and next pointer)
    ecall
    # Store the data value in the new node
    sw a0, 0(a7)
    # Load the old head's address
    la a1, head
    lw a2, 0(a1)
    # Store the old head's address in the next pointer field of the new node
    sw a2, 4(a7)
    # Update the head pointer to point to the new node
    sw a7, 0(a1)
    ret
#Function to print the linked list
print_list:
    # Argument:
    #   a0 = address of head pointer

loop:
    lw a1, 0(a0)        # Load data field of current node
    lw a2, 4(a0)        # Load next pointer field of current node

#Print data value
    mv a0, a1
    li a7, 1            # syscall 1 - print integer
    ecall
#Print arrow to indicate the next node
    la a0, str
    li a7, 4            # syscall 4 - print string
    ecall

#Check if we have reached the end of the list
    beqz a2, end_loop

#Move to the next node
    mv a0, a2
    j loop

end_loop:
    la a0 newline         # Print newline
    li a7 4            # syscall 4 - print string
    ecall
    ret
# Question 6
### PseudoCode
  void free(void* ptr) {
    // Do nothing if the pointer is null
    if (ptr == NULL) {
        return;
    }

    // Step 1: Determine the size of the memory block pointed to by ptr
    // This could be stored in a header before the memory block itself

    // Step 2: Optionally, validate that ptr points to a valid memory block
    // This could involve checking if ptr falls within the range of the allocated heap memory

    // Step 3: Perform any necessary bookkeeping to track freed memory
    // This could involve marking the memory block as free or updating data structures

    // Step 4: Coalesce adjacent free memory blocks if needed
    // This could involve merging the freed block with neighboring free blocks to avoid fragmentation

    // Step 5: Optionally, release memory back to the system if certain conditions are met
    // This could involve checking if releasing memory is beneficial and calling brk() or munmap()

    // Step 6: Update heap-related pointers or data structures
    // This could involve updating pointers to indicate the freed memory block is available

    // Step 7: Optionally, perform any additional cleanup or optimization tasks
    // This could involve defragmentation, memory compaction, or other memory management techniques
}
}
