jmug/CS153
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Updated hw6 to a newer version

Browse source 
Signed-off-by: jmug <u.g.a.mariano@gmail.com>
This commit is contained in:
Mariano Uvalle 2025-01-24 21:23:08 -08:00
parent 9224001a22
commit 0c04936ccf
356 changed files with 8408 additions and 4725 deletions
Download patch file Download diff file Expand all files Collapse all files

48
hw6/llprograms/sp22_hw3/armstrong.ll Normal file
View file

@ -0,0 +1,48 @@
%arr = type [3 x i64]
@value = global %arr [ i64 3, i64 7, i64 1]
define i64 @cube(i64 %n) {
%1 = mul i64 %n, %n
%2 = mul i64 %1, %n
ret i64 %2
}
define i64 @value_lookup(i64 %i) {
%ptr = getelementptr %arr, %arr* @value, i64 0, i64 %i
%ret = load i64, i64* %ptr
ret i64 %ret
}
define i64 @sum_three(i64 %0, i64 %1, i64 %2) {
%add1 = add i64 %0, %1
%add2 = add i64 %add1, %2
ret i64 %add2
}
define i64 @number_from_digits(i64 %0, i64 %1, i64 %2) {
%hundreds = mul i64 %0, 100
%tens = mul i64 %1, 10
%ones = mul i64 %2, 1
%res = call i64 @sum_three(i64 %ones, i64 %tens, i64 %hundreds)
ret i64 %res
}
define i64 @main(i64 %argc, i8** %arcv) {
%a = call i64 @value_lookup(i64 0)
%b = call i64 @value_lookup(i64 1)
%c = call i64 @value_lookup(i64 2)
%v = call i64 @number_from_digits(i64 %a, i64 %b, i64 %c)
%a_cubed = call i64 @cube(i64 %a)
%b_cubed = call i64 @cube(i64 %b)
%c_cubed = call i64 @cube(i64 %c)
%sum_cubed = call i64 @sum_three(i64 %a_cubed, i64 %b_cubed, i64 %c_cubed)
%cmp = icmp eq i64 %v, %sum_cubed
br i1 %cmp, label %ret_true, label %ret_false
ret_true:
ret i64 1
ret_false:
ret i64 0
}

49
hw6/llprograms/sp22_hw3/binary_palindrome.ll Normal file
View file

@ -0,0 +1,49 @@
define i64 @reverse(i64 %input_x) {
%rev = alloca i64
store i64 0, i64* %rev
%x = alloca i64
store i64 %input_x, i64 %x
br label %loop
loop:
%x_val_to_comp = load i64, i64* %x
%x_not_zero = icmp ne i64 %x_val_to_comp, 0
br i1 %x_not_zero, label %yes, label %no
yes:
%x_val = load i64, i64* %x
%rev_val = load i64, i64* %rev
%twice_rev = shl i64 %rev_val, 1
%x_val_last_bit = and i64 %x_val, 1
%twice_rev_plus_last_bit = add i64 %twice_rev, %x_val_last_bit
%half_x_val = lshr i64 %x_val, 1
store i64 %half_x_val, i64 %x
store i64 %twice_rev_plus_last_bit, i64 %rev
br label %loop
no:
%ret_val_rev = load i64, i64* %rev
ret i64 %ret_val_rev
}
define i64 @is_binary_palindrome(i64 %input_x) {
%reversed_x = call i64 @reverse(i64 %input_x)
%x_equals_reverse = icmp eq i64 %reversed_x, %input_x
br i1 %x_equals_reverse, label %retyes, label %retno
retyes:
ret i64 1
retno:
ret i64 0
}
define i64 @main(i64 %argc, i8** %argv) {
%res = call i64 @is_binary_palindrome(i64 819)
ret i64 %res
}

48
hw6/llprograms/sp22_hw3/bubble_sort.ll Normal file
View file

@ -0,0 +1,48 @@
@glist = global [6 x i64] [ i64 5, i64 2, i64 4, i64 1, i64 3, i64 0 ]
define void @sort([6 x i64]* %list) {
%i = alloca i64
store i64 0, i64* %i
%j = alloca i64
br label %loop_cnd_i
loop_cnd_i:
store i64 0, i64* %j
%ival = load i64, i64* %i
%cmp1 = icmp eq i64 %ival, 6
br i1 %cmp1, label %exit_i, label %loop_body_i
loop_body_i:
%jval = load i64, i64* %j
%bound = sub i64 6, %ival
%cmp2 = icmp eq i64 %jval, %bound
br i1 %cmp2, label %exit_j, label %loop_body_j
loop_body_j:
%left_indx = load i64, i64* %j
%right_indx = add i64 %left_indx, 1
%left = getelementptr [6 x i64], [6 x i64]* %list, i64 0, i64 %left_indx
%right = getelementptr [6 x i64], [6 x i64]* %list, i64 0, i64 %right_indx
%left_el = load i64, i64* %left
%right_el = load i64, i64* %right
%cmp3 = icmp sgt i64 %left_el, %right_el
br i1 %cmp3, label %swap, label %no_swap
swap:
store i64 %right_el, i64* %left
store i64 %left_el, i64* %right
br label %no_swap
no_swap:
%j_next = add i64 %jval, 1
store i64 %j_next, i64* %j
br label %loop_body_i
exit_j:
%i_next = add i64 %ival, 1
store i64 %i_next, i64* %i
br label %loop_cnd_i
exit_i:
ret void
}
define i64 @main(i64 %argc, i8** %arcv) {
call void @sort([6 x i64]* @glist)
%r = getelementptr [6 x i64], [6 x i64]* @glist, i64 0, i64 0
%1 = load i64, i64* %r
ret i64 %1
}

27
hw6/llprograms/sp22_hw3/collatz.ll Normal file
View file

@ -0,0 +1,27 @@
define i64 @collatz(i64 %n) {
%cmp = icmp sgt i64 %n, 1
br i1 %cmp, label %then, label %ret0
then:
%4 = shl i64 %n, 63
%5 = ashr i64 %4, 63
%6 = icmp eq i64 %5, 0
br i1 %6, label %even, label %odd
ret0:
ret i64 0
even:
%7 = ashr i64 %n, 1
%8 = call i64 @collatz(i64 %7)
%9 = add i64 %8, 1
ret i64 %9
odd:
%7 = mul i64 3, %n
%8 = add i64 1, %7
%9 = call i64 @collatz(i64 %8)
%10 = add i64 1, %9
ret i64 %10
}
define i64 @main(i64 %argc, i8** %arcv) {
%1 = call i64 @collatz(i64 7426)
ret i64 %1
}

49
hw6/llprograms/sp22_hw3/fib.ll Normal file
View file

@ -0,0 +1,49 @@
define i64 @alloca_in_loop(i64 %n) {
%ctr_ptr = alloca i64
store i64 %n, i64* %ctr_ptr
br label %loop_start
loop_start:
%ctr = load i64, i64* %ctr_ptr
%is_base = icmp sle i64 %ctr, 0
br i1 %is_base, label %loop_exit, label %loop_continue
loop_exit:
ret i64 1
loop_continue:
%foo = alloca i64
%ctr_decr = sub i64 %ctr, 1
store i64 %ctr_decr, i64* %ctr_ptr
br label %loop_start
}
define i64 @fib(i64 %n) {
%foo = call i64 @alloca_in_loop(i64 %n)
%is_base = icmp sle i64 %n, 2
br i1 %is_base, label %base, label %recurse
base:
ret i64 1
recurse:
%n1 = sub i64 %n, 1
%n2 = sub i64 %n, 2
%fib1 = call i64 @fib(i64 %n1)
%fib2 = call i64 @fib(i64 %n2)
%sum = add i64 %fib1, %fib2
ret i64 %sum
}
define i64 @main(i64 %argc, i8** %argv) {
%result = call i64 @fib(i64 7)
%is_correct = icmp eq i64 %result, 13
br i1 %is_correct, label %correct, label %incorrect
correct:
%foo = call i64 @alloca_in_loop(i64 100)
ret i64 1
incorrect:
ret i64 0
}

87
hw6/llprograms/sp22_hw3/floyd.ll Normal file
View file

@ -0,0 +1,87 @@
%Node = type { i64, %Node* }
; Small test case with cycle
@test1_n1 = global %Node { i64 1, %Node* @test1_n2 }
@test1_n2 = global %Node { i64 2, %Node* @test1_n3 }
@test1_n3 = global %Node { i64 3, %Node* @test1_n1 }
; Larger test case with cycle
@test2_n1 = global %Node { i64 1, %Node* @test2_n2 }
@test2_n2 = global %Node { i64 2, %Node* @test2_n3 }
@test2_n3 = global %Node { i64 3, %Node* @test2_n4 }
@test2_n4 = global %Node { i64 4, %Node* @test2_n5 }
@test2_n5 = global %Node { i64 5, %Node* @test2_n6 }
@test2_n6 = global %Node { i64 6, %Node* @test2_n7 }
@test2_n7 = global %Node { i64 7, %Node* @test2_n8 }
@test2_n8 = global %Node { i64 8, %Node* @test2_n4 }
; Test case with no cycle
@test3_n1 = global %Node { i64 1, %Node* @test3_n2 }
@test3_n2 = global %Node { i64 2, %Node* @test3_n3 }
@test3_n3 = global %Node { i64 3, %Node* @test3_n4 }
@test3_n4 = global %Node { i64 4, %Node* @test3_n5 }
@test3_n5 = global %Node { i64 5, %Node* @test3_n6 }
@test3_n6 = global %Node { i64 6, %Node* @test3_n7 }
@test3_n7 = global %Node { i64 7, %Node* null }
define i64 @find_cycle(%Node* %head) {
%head_null = icmp eq %Node* %head, null
br i1 %head_null, label %return_false, label %init_pointers
init_pointers:
%tortoise_ptr = alloca %Node*
%hare_ptr = alloca %Node*
store %Node* %head, %Node** %tortoise_ptr
store %Node* %head, %Node** %hare_ptr
br label %check_loop_conds
check_loop_conds:
%tortoise = load %Node*, %Node** %tortoise_ptr
%hare = load %Node*, %Node** %hare_ptr
br label %check_tortoise_next
check_tortoise_next:
%tortoise_link = getelementptr %Node, %Node* %tortoise, i32 0, i32 1
%tortoise_next = load %Node*, %Node** %tortoise_link
%tortoise_next_null = icmp eq %Node* %tortoise_next, null
br i1 %tortoise_next_null, label %return_false, label %check_hare_next
check_hare_next:
%hare_link = getelementptr %Node, %Node* %hare, i32 0, i32 1
%hare_next = load %Node*, %Node** %hare_link
%hare_next_null = icmp eq %Node* %hare_next, null
br i1 %hare_next_null, label %return_false, label %check_hare_next_next
check_hare_next_next:
%hare_next_link = getelementptr %Node, %Node* %hare_next, i32 0, i32 1
%hare_next_next = load %Node*, %Node** %hare_next_link
%hare_next_next_null = icmp eq %Node* %hare_next_next, null
br i1 %hare_next_next_null, label %return_false, label %enter_loop
enter_loop:
%equals = icmp eq %Node* %tortoise_next, %hare_next_next
store %Node* %tortoise_next, %Node** %tortoise_ptr
store %Node* %hare_next_next, %Node** %hare_ptr
br i1 %equals, label %find_first, label %check_loop_conds
find_first:
store %Node* %head, %Node** %tortoise_ptr
br label %check_equals_in_cycle
check_equals_in_cycle:
%tortoise_cycle = load %Node*, %Node** %tortoise_ptr
%hare_cycle = load %Node*, %Node** %hare_ptr
%equals_cycle = icmp eq %Node* %tortoise_cycle, %hare_cycle
br i1 %equals_cycle, label %return_first_cycle_val, label %find_first_loop
find_first_loop:
%tortoise_cycle_link = getelementptr %Node, %Node* %tortoise_cycle, i32 0, i32 1
%tortoise_cycle_next = load %Node*, %Node** %tortoise_cycle_link
store %Node* %tortoise_cycle_next, %Node** %tortoise_ptr
%hare_cycle_link = getelementptr %Node, %Node* %hare_cycle, i32 0, i32 1
%hare_cycle_next = load %Node*, %Node** %hare_cycle_link
store %Node* %hare_cycle_next, %Node** %hare_ptr
br label %check_equals_in_cycle
return_first_cycle_val:
%first_val_ptr = getelementptr %Node, %Node* %tortoise_cycle, i32 0, i32 0
%val = load i64, i64* %first_val_ptr
ret i64 %val
return_false:
ret i64 0
}
define i64 @main(i64 %argc, i8** %arcv) {
%1 = call i64 @find_cycle(%Node* @test2_n1)
ret i64 %1
}

26
hw6/llprograms/sp22_hw3/foldl.ll Normal file
View file

@ -0,0 +1,26 @@
@gbl = global [5 x i64] [ i64 2, i64 3, i64 4, i64 5, i64 6 ]
define i64 @add(i64 %x1, i64 %x2) {
%1 = add i64 %x1, %x2
ret i64 %1
}
define i64 @foldl(i64(i64, i64)* %f, i64 %acc, i64* %argv, i64 %argc) {
%cmp = icmp eq i64 %argc, 0
br i1 %cmp, label %then, label %else
then:
ret i64 %acc
else:
%tail = getelementptr i64, i64* %argv, i32 1
%head = load i64, i64* %argv
%new_acc = call i64 %f(i64 %acc, i64 %head)
%new_argc = sub i64 %argc, 1
%val = call i64 @foldl(i64(i64, i64)* %f, i64 %new_acc, i64* %tail, i64 %new_argc)
ret i64 %val
}
define i64 @main(i64 %argc, i8** %arcv) {
%1 = getelementptr [5 x i64], [5 x i64]* @gbl, i32 0, i32 0
%2 = call i64 @foldl(i64(i64, i64)* @add, i64 0, i64* %1, i64 5)
ret i64 %2
}

55
hw6/llprograms/sp22_hw3/full_bst.ll Normal file
View file

@ -0,0 +1,55 @@
%Node = type { %Node*, %Node*, i64 }
@n1 = global %Node { %Node* null, %Node* null, i64 1 }
@n2 = global %Node { %Node* null, %Node* null, i64 1 }
@n3 = global %Node { %Node* null, %Node* null, i64 1 }
@n4 = global %Node { %Node* null, %Node* null, i64 1 }
@n5 = global %Node { %Node* @n1, %Node* @n2, i64 1 }
@n6 = global %Node { %Node* @n3, %Node* @n4, i64 1 }
@root1 = global %Node { %Node* @n5, %Node* @n6, i64 1 }
@n5_2 = global %Node { %Node* @n1, %Node* null, i64 1 }
@root2 = global %Node { %Node* @n5_2, %Node* @n6, i64 1 }
define i1 @bst_full(%Node* %n) {
%1 = icmp eq %Node* %n, null
br i1 %1, label %full, label %check_leaf
check_leaf:
%nlptr = getelementptr %Node, %Node* %n, i64 0, i32 0
%nl = load %Node*, %Node** %nlptr
%cmp1 = icmp eq %Node* %nl, null
%nrptr = getelementptr %Node, %Node* %n, i64 0, i32 1
%nr = load %Node*, %Node** %nrptr
%cmp2 = icmp eq %Node* %nr, null
%and = and i1 %cmp1, %cmp2
br i1 %and, label %full, label %check_one_is_null
check_one_is_null:
%xor = xor i1 %cmp1, %cmp2
br i1 %xor, label %not_full, label %check_subtrees
check_subtrees:
%left = call i1 @bst_full(%Node* %nl)
%right = call i1 @bst_full(%Node* %nr)
%result = and i1 %left, %right
br i1 %result, label %full, label %not_full
full:
ret i1 1
not_full:
ret i1 0
}
define i64 @main(i64 %argc, i8** %argv) {
%2 = call i1 @bst_full(%Node* @root1)
ret i1 %2
}

175
hw6/llprograms/sp22_hw3/heap.ll Normal file
View file

@ -0,0 +1,175 @@
%Node = type { %Node*, %Node*, i64 }
@n6 = global %Node { %Node* null, %Node* null, i64 67 }
@n5 = global %Node { %Node* null, %Node* null, i64 -42 }
@n4 = global %Node { %Node* null, %Node* null, i64 12 }
@n3 = global %Node { %Node* null, %Node* null, i64 1 }
@n2 = global %Node { %Node* @n5, %Node* @n6, i64 -5 }
@n1 = global %Node { %Node* @n3, %Node* @n4, i64 -9 }
@root = global %Node { %Node* @n1, %Node* @n2, i64 15 }
define void @swap(%Node* %n1, %Node* %n2) {
%n1l.p = getelementptr %Node, %Node* %n1, i32 0, i32 0
%temp_l = load %Node*, %Node** %n1l.p
%n1r.p = getelementptr %Node, %Node* %n1, i32 0, i32 1
%temp_r = load %Node*, %Node** %n1r.p
%n1v.p = getelementptr %Node, %Node* %n1, i32 0, i32 2
%temp_v = load i64, i64* %n1v.p
%n2l.p = getelementptr %Node, %Node* %n2, i32 0, i32 0
%t2_l = load %Node*, %Node** %n2l.p
store %Node* %t2_l, %Node** %n1l.p
%n2r.p = getelementptr %Node, %Node* %n2, i32 0, i32 1
%t2_r = load %Node*, %Node** %n2r.p
store %Node* %t2_r, %Node** %n1r.p
%n2v.p = getelementptr %Node, %Node* %n2, i32 0, i32 2
%t2_v = load i64, i64* %n2v.p
store i64 %t2_v, i64* %n1v.p
store %Node* %temp_l, %Node** %n2l.p
store %Node* %temp_r, %Node** %n2r.p
store i64 %temp_v, i64* %n2v.p
ret void
}
define void @heapify(%Node* %0) {
%2 = alloca %Node*
%3 = alloca %Node*
%4 = alloca %Node*
%5 = alloca %Node*
store %Node* %0, %Node** %2
%6 = load %Node*, %Node** %2
%7 = getelementptr %Node, %Node* %6, i32 0, i32 0
%8 = load %Node*, %Node** %7
store %Node* %8, %Node** %3
%9 = load %Node*, %Node** %2
%10 = getelementptr %Node, %Node* %9, i32 0, i32 1
%11 = load %Node*, %Node** %10
store %Node* %11, %Node** %4
%12 = load %Node*, %Node** %2
store %Node* %12, %Node** %5
%13 = load %Node*, %Node** %3
%14 = icmp ne %Node* %13, null
br i1 %14, label %l15, label %l25
l15:
%16 = load %Node*, %Node** %3
%17 = getelementptr %Node, %Node* %16, i32 0, i32 2
%18 = load i64, i64* %17
%19 = load %Node*, %Node** %2
%20 = getelementptr %Node, %Node* %19, i32 0, i32 2
%21 = load i64, i64* %20
%22 = icmp sgt i64 %18, %21
br i1 %22, label %l23, label %l25
l23:
%24 = load %Node*, %Node** %3
store %Node* %24, %Node** %5
br label %l25
l25:
%26 = load %Node*, %Node** %4
%27 = icmp ne %Node* %26, null
br i1 %27, label %l28, label %l38
l28:
%29 = load %Node*, %Node** %4
%30 = getelementptr %Node, %Node* %29, i32 0, i32 2
%31 = load i64, i64* %30
%32 = load %Node*, %Node** %2
%33 = getelementptr %Node, %Node* %32, i32 0, i32 2
%34 = load i64, i64* %33
%35 = icmp sgt i64 %31, %34
br i1 %35, label %l36, label %l38
l36:
%37 = load %Node*, %Node** %4
store %Node* %37, %Node** %5
br label %l38
l38:
%39 = load %Node*, %Node** %5
%40 = load %Node*, %Node** %2
%41 = icmp ne %Node* %39, %40
br i1 %41, label %l42, label %l46
l42:
%43 = load %Node*, %Node** %2
%44 = load %Node*, %Node** %5
call void @swap(%Node* %43, %Node* %44)
%45 = load %Node*, %Node** %2
call void @heapify(%Node* %45)
br label %l46
l46:
ret void
}
define void @heapify_total(%Node* %0) {
%2 = alloca %Node*
store %Node* %0, %Node** %2
%3 = load %Node*, %Node** %2
%4 = getelementptr %Node, %Node* %3, i32 0, i32 0
%5 = load %Node*, %Node** %4
%6 = icmp eq %Node* %5, null
br i1 %6, label %l7, label %l13
l7:
%8 = load %Node*, %Node** %2
%9 = getelementptr %Node, %Node* %8, i32 0, i32 1
%10 = load %Node*, %Node** %9
%11 = icmp eq %Node* %10, null
br i1 %11, label %l12, label %l13
l12:
br label %l51
l13:
%14 = load %Node*, %Node** %2
%15 = getelementptr %Node, %Node* %14, i32 0, i32 0
%16 = load %Node*, %Node** %15
%17 = icmp ne %Node* %16, null
br i1 %17, label %l18, label %l31
l18:
%19 = load %Node*, %Node** %2
%20 = getelementptr %Node, %Node* %19, i32 0, i32 1
%21 = load %Node*, %Node** %20
%22 = icmp ne %Node* %21, null
br i1 %22, label %l23, label %l31
l23:
%24 = load %Node*, %Node** %2
%25 = getelementptr %Node, %Node* %24, i32 0, i32 0
%26 = load %Node*, %Node** %25
call void @heapify_total(%Node* %26)
%27 = load %Node*, %Node** %2
%28 = getelementptr %Node, %Node* %27, i32 0, i32 1
%29 = load %Node*, %Node** %28
call void @heapify_total(%Node* %29)
%30 = load %Node*, %Node** %2
call void @heapify(%Node* %30)
br label %l51
l31:
%32 = load %Node*, %Node** %2
%33 = getelementptr %Node, %Node* %32, i32 0, i32 0
%34 = load %Node*, %Node** %33
%35 = icmp eq %Node* %34, null
br i1 %35, label %l36, label %l41
l36:
%37 = load %Node*, %Node** %2
%38 = getelementptr %Node, %Node* %37, i32 0, i32 1
%39 = load %Node*, %Node** %38
call void @heapify_total(%Node* %39)
%40 = load %Node*, %Node** %2
call void @heapify(%Node* %40)
br label %l51
l41:
%42 = load %Node*, %Node** %2
%43 = getelementptr %Node, %Node* %42, i32 0, i32 1
%44 = load %Node*, %Node** %43
%45 = icmp eq %Node* %44, null
br i1 %45, label %l46, label %l51
l46:
%47 = load %Node*, %Node** %2
%48 = getelementptr %Node, %Node* %47, i32 0, i32 0
%49 = load %Node*, %Node** %48
call void @heapify_total(%Node* %49)
%50 = load %Node*, %Node** %2
call void @heapify(%Node* %50)
br label %l51
l51:
ret void
}
define i64 @main() {
call void @heapify_total(%Node* @root)
%max_val_ptr = getelementptr %Node, %Node* @root, i32 0, i32 2
%max_val = load i64, i64* %max_val_ptr
ret i64 %max_val
}

38
hw6/llprograms/sp22_hw3/index_match.ll Normal file
View file

@ -0,0 +1,38 @@
@glist = global [7 x i64] [ i64 -1, i64 1, i64 4, i64 5, i64 6, i64 10, i64 11 ]
define i64 @indexmatch(i64 %lo, i64 %hi, [7 x i64]* %list) {
%cmp1 = icmp eq i64 %lo, %hi
br i1 %cmp1, label %base_case, label %check
base_case:
%a_lo_addr = getelementptr [7 x i64], [7 x i64]* %list, i32 0, i64 %lo
%a_lo = load i64, i64* %a_lo_addr
%cmp2 = icmp eq i64 %lo, %a_lo
br i1 %cmp2, label %true, label %false
true:
ret i64 1
false:
ret i64 0
check:
%m2 = add i64 %lo, %hi
%m = ashr i64 %m2, 1
%a_m_addr = getelementptr [7 x i64], [7 x i64]* %list, i32 0, i64 %m
%a_m = load i64, i64* %a_m_addr
%cmp3 = icmp eq i64 %m, %a_m
br i1 %cmp3, label %true, label %recurse
recurse:
%cmp4 = icmp slt i64 %m, %a_m
br i1 %cmp4, label %recurse_left, label %recurse_right
recurse_left:
%new_hi = sub i64 %m, 1
%left_ans = call i64 @indexmatch(i64 %lo, i64 %new_hi, [7 x i64]* %list)
ret i64 %left_ans
recurse_right:
%new_lo = add i64 %m, 1
%right_ans = call i64 @indexmatch(i64 %new_lo, i64 %hi, [7 x i64]* %list)
ret i64 %right_ans
}
define i64 @main(i64 %argc, i8** %arcv) {
%ans = call i64 @indexmatch(i64 0, i64 6, [7 x i64]* @glist)
ret i64 %ans
}

57
hw6/llprograms/sp22_hw3/is_bst.ll Normal file
View file

@ -0,0 +1,57 @@
%Node = type { %Node*, %Node*, i64 }
@test1 = global %Node { %Node* null, %Node* null, i64 1 }
@test2 = global %Node { %Node* null, %Node* null, i64 4 }
@test3 = global %Node { %Node* null, %Node* null, i64 6 }
@test4 = global %Node { %Node* @test1, %Node* null, i64 2 }
@test5 = global %Node { %Node* @test2, %Node* @test3, i64 5 }
@test = global %Node { %Node* @test4, %Node* @test5, i64 3 }
define i1 @is_bst(%Node* %n, i64* %min, i64* %max) {
; if (n == null) return true;
%1 = icmp eq %Node* %n, null
br i1 %1, label %bst, label %process_min
process_min:
%n.val.ptr = getelementptr %Node, %Node* %n, i64 0, i32 2
%n.val = load i64, i64* %n.val.ptr
; if (min && n->val < *min) return false
%min.null = icmp eq i64* %min, null
br i1 %min.null, label %process_max, label %process_min_2
process_min_2:
%2 = load i64, i64* %min
%3 = icmp slt i64 %n.val, %2
br i1 %3, label %not_bst, label %process_max
process_max:
; if (max && n->val > *max) return false;
%max.null = icmp eq i64* %max, null
br i1 %max.null, label %recur_left, label %process_max_2
process_max_2:
%4 = load i64, i64* %max
%5 = icmp sgt i64 %n.val, %4
br i1 %5, label %not_bst, label %recur_left
recur_left:
; if (!is_bst(n->l, min, &n->val)) return false;
%n.l.ptr = getelementptr %Node, %Node* %n, i64 0, i32 0
%n.l = load %Node*, %Node** %n.l.ptr
%l = call i1 @is_bst(%Node* %n.l, i64* %min, i64* %n.val.ptr)
br i1 %l, label %recur_right, label %not_bst
recur_right:
; return is_bst(n->r, &n->val, max);
%n.r.ptr = getelementptr %Node, %Node* %n, i64 0, i32 1
%n.r = load %Node*, %Node** %n.r.ptr
%r = call i1 @is_bst(%Node* %n.r, i64* %n.val.ptr, i64* %max)
br i1 %r, label %bst, label %not_bst
not_bst:
ret i1 0
bst:
ret i1 1
}
define i64 @main(i64 %argc, i8** %argv) {
%1 = call i1 @is_bst(%Node* @test, i64* null, i64* null)
br i1 %1, label %succ, label %fail
succ:
ret i64 0
fail:
ret i64 1
}

93
hw6/llprograms/sp22_hw3/is_square.ll Normal file
View file

@ -0,0 +1,93 @@
%point = type [2 x i64]
@pt1 = global %point [ i64 10, i64 20 ]
@pt2 = global %point [ i64 10, i64 10 ]
@pt3 = global %point [ i64 20, i64 10 ]
@pt4 = global %point [ i64 20, i64 20 ]
define i64 @distance(%point* %fst, %point* %snd) {
%one = getelementptr %point, %point* %fst, i32 0, i64 0
%two = getelementptr %point, %point* %fst, i32 0, i64 1
%thre = getelementptr %point, %point* %snd, i32 0, i64 0
%four = getelementptr %point, %point* %snd, i32 0, i64 1
%x1 = load i64, i64* %one
%y1 = load i64, i64* %two
%x2 = load i64, i64* %thre
%y2 = load i64, i64* %four
%1 = sub i64 %x1, %x2
%2 = mul i64 %1, %1
%3 = sub i64 %y1, %y2
%4 = mul i64 %3, %3
%5 = add i64 %2, %4
ret i64 %5
}
define i64 @is_square(%point* %p1, %point* %p2, %point* %p3, %point* %p4) {
%d2 = call i64 @distance(%point* %p1, %point* %p2)
%d3 = call i64 @distance(%point* %p1, %point* %p3)
%d4 = call i64 @distance(%point* %p1, %point* %p4)
%part1c1 = icmp eq i64 %d2, 0
%part1c2 = icmp eq i64 %d3, 0
%part1c3 = icmp eq i64 %d4, 0
%b1tmp = or i1 %part1c1, %part1c2
%b1 = or i1 %b1tmp, %part1c3
br i1 %b1, label %end, label %part2
part2:
%c1 = icmp eq i64 %d2, %d3
%1 = mul i64 %d2, 2
%c2 = icmp eq i64 %1, %d4
%d5 = call i64 @distance(%point* %p2, %point* %p4)
%d6 = call i64 @distance(%point* %p2, %point* %p3)
%2 = mul i64 %d5, 2
%c3 = icmp eq i64 %2, %d6
%cmp1 = and i1 %c1, %c2
%b2 = and i1 %c3, %cmp1
br i1 %b2, label %exitT, label %part3
part3:
%3 = mul i64 %d3, 2
%d7 = call i64 @distance(%point* %p3, %point* %p2)
%d8 = call i64 @distance(%point* %p3, %point* %p4)
%4 = mul i64 %d7, 2
%part3c1 = icmp eq i64 %d3, %d4
%part3c2 = icmp eq i64 %3, %d2
%part3c3 = icmp eq i64 %4, %d8
%cmp3_1 = and i1 %part3c1, %part3c2
%b3 = and i1 %cmp3_1, %part3c3
br i1 %b3, label %exitT, label %part4
part4:
%5 = mul i64 %d2, 2
%d9 = call i64 @distance(%point* %p2, %point* %p3)
%d10 = call i64 @distance(%point* %p2, %point* %p4)
%6 = mul i64 %d9, 2
%part4c1 = icmp eq i64 %d2, %d4
%part4c2 = icmp eq i64 %5, %d3
%part4c3 = icmp eq i64 %6, %d10
%cmp4_1 = and i1 %part4c1, %part4c2
%b4 = and i1 %cmp4_1, %part4c3
br i1 %b4, label %exitT, label %end
exitT:
ret i64 1
end:
ret i64 0
}
define i64 @main(i64 %argc, i8** %argv) {
%ans = call i64 @is_square(%point* @pt1, %point* @pt2, %point* @pt3, %point* @pt4)
ret i64 %ans
}

32
hw6/llprograms/sp22_hw3/kadane.ll Normal file
View file

@ -0,0 +1,32 @@
@gbl = global [9 x i64] [ i64 -2, i64 1, i64 -3, i64 4, i64 -1, i64 2, i64 1, i64 -5, i64 4 ]
define i64 @kadane([0 x i64]* %arr, i64 %max_so_far, i64 %max_here, i64 %size, i64 %i) {
%done = icmp slt i64 %i, %size
br i1 %done, label %start_iter, label %exit
start_iter:
%addr = getelementptr [0 x i64], [0 x i64]* %arr, i64 0, i64 %i
%new_i = add i64 1, %i
%v = load i64, i64* %addr
%curr = add i64 %max_here, %v
br label %check_positive
check_positive:
%is_pos = icmp sge i64 %curr, 0
br i1 %is_pos, label %pos, label %not_pos
pos:
%is_max = icmp sge i64 %curr, %max_so_far
br i1 %is_max, label %max, label %no_max
max:
%rec_max = call i64 @kadane([0 x i64]* %arr, i64 %curr, i64 %curr, i64 %size, i64 %new_i)
ret i64 %rec_max
no_max:
%rec_no_max = call i64 @kadane([0 x i64]* %arr, i64 %max_so_far, i64 %curr, i64 %size, i64 %new_i)
ret i64 %rec_no_max
not_pos:
%rec_no_pos = call i64 @kadane([0 x i64]* %arr, i64 %max_so_far, i64 0, i64 %size, i64 %new_i)
ret i64 %rec_no_pos
exit:
ret i64 %max_so_far
}
define i64 @main(i64 %argc, i8** %arcv) {
%out = call i64 @kadane([0 x i64]* @gbl, i64 0, i64 0, i64 9, i64 0)
ret i64 %out
}

59
hw6/llprograms/sp22_hw3/knapsack.ll Normal file
View file

@ -0,0 +1,59 @@
@gbl_values = global [9 x i64] [ i64 12, i64 1, i64 33, i64 4, i64 1, i64 2, i64 1, i64 59, i64 4 ]
@gbl_weights = global [9 x i64] [ i64 2, i64 10, i64 34, i64 9, i64 20, i64 26, i64 14, i64 5, i64 4 ]
define i64 @max(i64 %item1, i64 %item2) {
%one_bigger = icmp sge i64 %item1, %item2
br i1 %one_bigger, label %ret_item_one, label %ret_item_two
ret_item_one:
ret i64 %item1
ret_item_two:
ret i64 %item2
}
define i64 @knapsack([9 x i64]* %value_arr, [9 x i64]* %weight_arr, i64 %current_item_index, i64 %remaining_weight) {
%full = icmp eq i64 0, %remaining_weight
%no_items = icmp slt i64 %current_item_index, 0
%full_or_no_items = or i1 %full, %no_items
br i1 %full_or_no_items, label %no_more_space, label %check_weight_neg
check_weight_neg:
%done = icmp slt i64 %remaining_weight, 0
br i1 %done, label %no_more_weight, label %continue
no_more_space:
ret i64 0
no_more_weight:
ret i64 -99999999
continue:
%new_index = add i64 -1, %current_item_index
%value_array_i_ptr = getelementptr [9 x i64], [9 x i64]* %value_arr, i32 0, i64 %current_item_index
%value_array_i_value = load i64, i64* %value_array_i_ptr
%weight_array_i_ptr = getelementptr [9 x i64], [9 x i64]* %weight_arr, i32 0, i64 %current_item_index
%weight_array_i_value = load i64, i64* %weight_array_i_ptr
%sub_ready_weight_value = mul i64 -1, %weight_array_i_value
%inlcude_weight_limit = add i64 %sub_ready_weight_value, %remaining_weight
%include_item_rec_subsolution = call i64 @knapsack([9 x i64]* %value_arr, [9 x i64]* %weight_arr, i64 %new_index, i64 %inlcude_weight_limit)
%include_item_solution = add i64 %value_array_i_value, %include_item_rec_subsolution
%exclude_item_solution = call i64 @knapsack([9 x i64]* %value_arr, [9 x i64]* %weight_arr, i64 %new_index, i64 %remaining_weight)
%best_option = call i64 @max(i64 %include_item_solution, i64 %exclude_item_solution)
ret i64 %best_option
}
define i64 @main(i64 %argc, i8** %arcv) {
%out = call i64 @knapsack([9 x i64]* @gbl_values, [9 x i64]* @gbl_weights, i64 8, i64 30)
ret i64 %out
}

48
hw6/llprograms/sp22_hw3/lcm.ll Normal file
View file

@ -0,0 +1,48 @@
define i64 @gcd(i64 %x, i64 %y) {
%basecnd = icmp eq i64 %x, %y
br i1 %basecnd, label %base, label %recurse
base:
ret i64 %x
recurse:
%lessthan = icmp slt i64 %x, %y
br i1 %lessthan, label %if, label %else
if:
%diff1 = sub i64 %y, %x
%retif = call i64 @gcd(i64 %x, i64 %diff1)
ret i64 %retif
else:
%diff2 = sub i64 %x, %y
%retelse = call i64 @gcd(i64 %diff2, i64 %y)
ret i64 %retelse
}
define i64 @div(i64 %a, i64 %b) {
%maskhigh = shl i64 1, 63
%ahigh = and i64 %a, %maskhigh
%pbit = lshr i64 %maskhigh, 63
%pend = and i64 0, %pbit
%pfin = sub i64 %pend, %b
%isneg = icmp slt i64 %pfin, 0
%ans2 = sub i64 54, 4
br i1 %isneg, label %if, label %else
if:
%masklow = shl i64 1, 63
%ans1 = sub i64 64, 14
%masklow2 = ashr i64 %masklow, 62
%aret = and i64 %a, %masklow2
ret i64 %ans1
else:
ret i64 %ans2
}
define i64 @lcm(i64 %a, i64 %b) {
%product = mul i64 %a, %b
%gcdans = call i64 @gcd(i64 %a, i64 %b)
%val = call i64 @div(i64 %product, i64 %gcdans)
ret i64 %val
}
define i64 @main() {
%ans = call i64 @lcm(i64 10, i64 25)
ret i64 %ans
}

9
hw6/llprograms/sp22_hw3/longboi.ll Normal file
View file

@ -0,0 +1,9 @@
define i64 @longboi(i64 %x1, i64 %x2, i64 %x3, i64 %x4, i64 %x5, i64 %x6, i64 %x7, i64 %x8) {
%1 = sub i64 %x7, %x8
ret i64 %1
}
define i64 @main(i64 %argc, i8** %arcv) {
%1 = call i64 @longboi(i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 9, i64 5)
ret i64 %1
}

13
hw6/llprograms/sp22_hw3/ltoatest.ll Normal file
View file

@ -0,0 +1,13 @@
declare void @ll_puts(i8*)
declare i8* @ll_ltoa(i64)
declare i8* @ll_strcat(i8*, i8*)
@sum = global [6 x i8] c"Sum: \00"
define i64 @main(i64 %argc, i8** %argv) {
%1 = add i64 5, 9
%ps = call i8* @ll_ltoa(i64 %1)
%p = call i8* @ll_strcat(i8* @sum, i8* %ps)
call void @ll_puts(i8* %p)
ret i64 0
}

54
hw6/llprograms/sp22_hw3/map.ll Normal file
View file

@ -0,0 +1,54 @@
@gbl1 = global [3 x i64] [i64 1, i64 2, i64 3]
@gbl2 = global [3 x i64] [i64 1, i64 2, i64 3]
define i64 @square(i64 %x1) {
%1 = mul i64 %x1, %x1
ret i64 %1
}
define i64 @cube(i64 %x1) {
%1 = mul i64 %x1, %x1
%2 = mul i64 %1, %x1
ret i64 %2
}
define void @map(i64(i64)* %fn, i64* %ptr, i64 %size) {
%1 = icmp eq i64 %size, 0
br i1 %1, label %then, label %else
then:
ret void
else:
%2 = getelementptr i64, i64* %ptr, i64 0
%3 = load i64, i64* %2
%4 = call i64 %fn(i64 %3)
store i64 %4, i64* %2
%5 = sub i64 %size, 1
%6 = getelementptr i64, i64* %ptr, i64 1
%7 = sub i64 %size, 1
call void @map(i64(i64)* %fn, i64* %6, i64 %7)
ret void
}
define i64 @main(i64 %argc, i8** %argv) {
%1 = getelementptr [3 x i64], [3 x i64]* @gbl1, i64 0, i64 0
%2 = getelementptr [3 x i64], [3 x i64]* @gbl1, i64 0, i64 1
%3 = getelementptr [3 x i64], [3 x i64]* @gbl1, i64 0, i64 2
call void @map(i64(i64)* @square, i64* %1, i64 3)
%4 = load i64, i64* %1
%5 = load i64, i64* %2
%6 = load i64, i64* %3
%7 = add i64 %4, %5
%8 = add i64 %7, %6
%9 = getelementptr [3 x i64], [3 x i64]* @gbl2, i64 0, i64 0
%10 = getelementptr [3 x i64], [3 x i64]* @gbl2, i64 0, i64 1
%11 = getelementptr [3 x i64], [3 x i64]* @gbl2, i64 0, i64 2
call void @map(i64(i64)* @cube, i64* %9, i64 3)
%12 = load i64, i64* %9
%13 = load i64, i64* %10
%14 = load i64, i64* %11
%15 = add i64 %12, %13
%16 = add i64 %15, %14
%17 = add i64 %8, %16
ret i64 %17
}

99
hw6/llprograms/sp22_hw3/merge_two_sorted.ll Normal file
View file

@ -0,0 +1,99 @@
%vec1 = type [5 x i64]
%vec2 = type [7 x i64]
%vecresult = type [12 x i64]
@g_vec1_n = global i64 5
@g_vec2_n = global i64 7
@g_vec1 = global %vec1 [i64 0, i64 2, i64 3, i64 3, i64 10]
@g_vec2 = global %vec2 [i64 2, i64 3, i64 8, i64 9, i64 9, i64 10, i64 15]
@g_vecresult = global %vecresult [i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0]
define void @merge(%vec1* %vec_1, %vec2* %vec_2, %vecresult* %vec_result, i64 %i, i64 %j, i64 %k) {
%vec1_n = load i64, i64* @g_vec1_n
%vec2_n = load i64, i64* @g_vec2_n
%vec1_remaining = icmp slt i64 %i, %vec1_n
%vec2_remaining = icmp slt i64 %j, %vec2_n
%vec1_and_vec2_remaining = and i1 %vec1_remaining, %vec2_remaining
%vec1_or_vec2_remaining = or i1 %vec1_remaining, %vec2_remaining
br i1 %vec1_or_vec2_remaining, label %non_base_case, label %base_case
base_case:
ret void
non_base_case:
%vec_result_elem_addr = getelementptr %vecresult, %vecresult* %vec_result, i32 0, i64 %k
br i1 %vec1_and_vec2_remaining, label %both_remaining, label %one_remaining
both_remaining:
%vec1_elem_addr = getelementptr %vec1, %vec1* %vec_1, i32 0, i64 %i
%vec2_elem_addr = getelementptr %vec2, %vec2* %vec_2, i32 0, i64 %j
%vec1_elem = load i64, i64* %vec1_elem_addr
%vec2_elem = load i64, i64* %vec2_elem_addr
%vec1_lt_vec2 = icmp slt i64 %vec1_elem, %vec2_elem
br i1 %vec1_lt_vec2, label %push_vec1, label %push_vec2
one_remaining:
br i1 %vec1_remaining, label %get_vec1_elem, label %get_vec2_elem
get_vec1_elem:
%vec1_elem_addr = getelementptr %vec1, %vec1* %vec_1, i32 0, i64 %i
%vec1_elem = load i64, i64* %vec1_elem_addr
br label %push_vec1
get_vec2_elem:
%vec2_elem_addr = getelementptr %vec2, %vec2* %vec_2, i32 0, i64 %j
%vec2_elem = load i64, i64* %vec2_elem_addr
br label %push_vec2
push_vec1:
store i64 %vec1_elem, i64* %vec_result_elem_addr
%i_new = add i64 %i, 1
%j_new = add i64 %j, 0
br label %recurse
push_vec2:
store i64 %vec2_elem, i64* %vec_result_elem_addr
%i_new = add i64 %i, 0
%j_new = add i64 %j, 1
br label %recurse
recurse:
%k_new = add i64 %k, 1
call void @merge(%vec1* @g_vec1, %vec2* @g_vec2, %vecresult* @g_vecresult, i64 %i_new, i64 %j_new, i64 %k_new)
ret void
}
define i1 @isSorted(%vecresult* %vec_result) {
%vec1_n = load i64, i64* @g_vec1_n
%vec2_n = load i64, i64* @g_vec2_n
%vec_result_n = add i64 %vec1_n, %vec2_n
%i_addr = alloca i64
store i64 0, i64* %i_addr
br label %begin_is_sorted
begin_is_sorted:
%i_val = load i64, i64* %i_addr
%i_incr_val = add i64 %i_val, 1
%done = icmp sge i64 %i_incr_val, %vec_result_n
br i1 %done, label %exit_true, label %examine_next
examine_next:
%elem_i_addr = getelementptr %vecresult, %vecresult* %vec_result, i32 0, i64 %i_val
%elem_i_incr_addr = getelementptr %vecresult, %vecresult* %vec_result, i32 0, i64 %i_incr_val
%elem_i = load i64, i64* %elem_i_addr
%elem_i_incr = load i64, i64* %elem_i_incr_addr
store i64 %i_incr_val, i64* %i_addr
%in_order = icmp sle i64 %elem_i, %elem_i_incr
br i1 %in_order, label %begin_is_sorted, label %exit_false
exit_false:
ret i1 0
exit_true:
ret i1 1
}
define i64 @main(i64 %argc, i8** %arcv) {
call void @merge(%vec1* @g_vec1, %vec2* @g_vec2, %vecresult* @g_vecresult, i64 0, i64 0, i64 0)
%is_sorted = call i1 @isSorted(%vecresult* @g_vecresult)
ret i1 %is_sorted
}

49
hw6/llprograms/sp22_hw3/politeness.ll Normal file
View file

@ -0,0 +1,49 @@
define i64 @politeness(i64 %n) {
%i = alloca i64
%counter = alloca i64
store i64 0, i64* %i
store i64 0, i64* %counter
br label %start
start:
%1 = load i64, i64* %i
%t = add i64 %1, 1
store i64 %t, i64* %i
%2 = icmp slt i64 %t, %n
br i1 %2, label %outer, label %end
outer:
%sum = alloca i64 ; sum of inner loop
store i64 0, i64* %sum
%j = alloca i64; inner loop
%3 = load i64, i64* %i
store i64 %3, i64* %j
br label %inner
inner:
%4 = load i64, i64* %j ; j
%5 = load i64, i64* %sum ; sum
%6 = add i64 %4, %5 ; j + sum
store i64 %6, i64* %sum ; sum = j + sum
%7 = add i64 %4, 1 ; j + 1
store i64 %7, i64* %j ; j = j + 1
%8 = icmp eq i64 %6, %n ; sum = n
br i1 %8, label %increment, label %next
increment:
%9 = load i64, i64* %counter
%10 = add i64 %9, 1
store i64 %10, i64* %counter ; counter = counter + 1
br label %start
next:
%11 = load i64, i64* %sum ; sum
%12 = icmp sgt i64 %11, %n ; sum > n
br i1 %12, label %start, label %inner
end:
%13 = load i64, i64* %counter
ret i64 %13 ; return counter
}
define i64 @main(i64 %argc, i8** %arcv) {
%1 = call i64 @politeness(i64 15)
ret i64 %1
}

113
hw6/llprograms/sp22_hw3/qsort.ll Normal file
View file

@ -0,0 +1,113 @@
@array1 = global [10 x i64] [i64 4, i64 9, i64 9, i64 9, i64 -1, i64 3, i64 3, i64 5, i64 8, i64 1]
define i64 @is_sorted([0 x i64]* %arr, i64 %index, i64 %prev, i64 %n) {
%1 = icmp slt i64 %index, %n
br i1 %1, label %check, label %exit_t
check:
%addr = getelementptr [0 x i64], [0 x i64]* %arr, i32 0, i64 %index
%value = load i64, i64*%addr
%2 = icmp sge i64 %value, %prev
br i1 %2, label %recurse, label %exit_f
recurse:
%next = add i64 1, %index
%rec = call i64 @is_sorted([0 x i64]* %arr, i64 %next, i64 %value, i64 %n)
ret i64 %rec
exit_t:
ret i64 1
exit_f:
ret i64 0
}
define i64 @partition([0 x i64]* %arr, i64 %left, i64 %right) {
%l_mut = alloca i64
%r_mut = alloca i64
store i64 %left, i64* %l_mut
store i64 %right, i64* %r_mut
%sum = add i64 %left, %right
%pivot_i = ashr i64 %sum, 1
%pivot_addr = getelementptr [0 x i64], [0 x i64]* %arr, i32 0, i64 %pivot_i
%pivot = load i64, i64* %pivot_addr
br label %body
body:
br label %check_l
incr_l:
%l_i = load i64, i64* %l_mut
%next = add i64 %l_i, 1
store i64 %next, i64* %l_mut
br label %check_l
check_l:
%l_index = load i64, i64* %l_mut
%l_arr_ptr = getelementptr [0 x i64], [0 x i64]* %arr, i32 0, i64 %l_index
%l_val = load i64, i64* %l_arr_ptr
%l_cmp = icmp slt i64 %l_val, %pivot
br i1 %l_cmp, label %incr_l, label %check_r
incr_r:
%r_i = load i64, i64* %r_mut
%next_r = add i64 %r_i, -1
store i64 %next_r, i64* %r_mut
br label %check_r
check_r:
%r_index = load i64, i64* %r_mut
%r_arr_ptr = getelementptr [0 x i64], [0 x i64]* %arr, i32 0, i64 %r_index
%r_val = load i64, i64* %r_arr_ptr
%r_cmp = icmp sgt i64 %r_val, %pivot
br i1 %r_cmp, label %incr_r, label %check_body
check_body:
%index_l = load i64, i64* %l_mut
%index_r = load i64, i64* %r_mut
%cmp_l_r = icmp sge i64 %index_l, %index_r
br i1 %cmp_l_r, label %exit, label %swap
exit:
%r_index1 = load i64, i64* %r_mut
ret i64 %r_index1
swap:
%l_arr_ptr1 = getelementptr [0 x i64], [0 x i64]* %arr, i32 0, i64 %index_l
%r_arr_ptr1 = getelementptr [0 x i64], [0 x i64]* %arr, i32 0, i64 %index_r
%l_val1 = load i64, i64* %l_arr_ptr1
%r_val1 = load i64, i64* %r_arr_ptr1
store i64 %r_val1, i64* %l_arr_ptr1
store i64 %l_val1, i64* %r_arr_ptr1
%l_i1 = load i64, i64* %l_mut
%next1 = add i64 %l_i1, 1
store i64 %next1, i64* %l_mut
%r_i1 = load i64, i64* %r_mut
%next_r1 = add i64 %r_i1, -1
store i64 %next_r1, i64* %r_mut
br label %body
}
define void @quicksort([0 x i64]* %arr, i64 %left, i64 %right) {
%1 = icmp sge i64 %left, 0
%2 = icmp sge i64 %right, 0
%3 = icmp slt i64 %left, %right
%4 = and i1 %1, %2
%5 = and i1 %3, %4
br i1 %5, label %body, label %exit
body:
%p = call i64 @partition([0 x i64]* %arr, i64 %left, i64 %right)
call void @quicksort([0 x i64]* %arr, i64 %left, i64 %p)
%6 = add i64 %p, 1
call void @quicksort([0 x i64]* %arr, i64 %6, i64 %right)
ret void
exit:
ret void
}
define i64 @main() {
%a = bitcast [10 x i64]* @array1 to [0 x i64]*
call void @quicksort([0 x i64]* %a, i64 0, i64 9)
%1 = call i64 @is_sorted([0 x i64]* %a, i64 0, i64 -5, i64 10)
ret i64 %1
}

29
hw6/llprograms/sp22_hw3/search.ll Normal file
View file

@ -0,0 +1,29 @@
@unsorted = global [7 x i64] [i64 74, i64 3, i64 5, i64 8, i64 2, i64 50, i64 9]
define i64 @search(i64 %lo, i64 %hi, i64 %target, [7 x i64]* %list) {
%cmp1 = icmp eq i64 %lo, %hi
br i1 %cmp1, label %base_case, label %check
base_case:
%lo_addr = getelementptr [7 x i64], [7 x i64]* %list, i32 0, i64 %lo
%lo_val = load i64, i64* %lo_addr
%cmp2 = icmp eq i64 %target, %lo_val
br i1 %cmp2, label %true, label %false
true:
ret i64 1
false:
ret i64 0
check:
%lo_addr_check = getelementptr [7 x i64], [7 x i64]* %list, i32 0, i64 %lo
%lo_val_check = load i64, i64* %lo_addr_check
%cmp3 = icmp eq i64 %target, %lo_val_check
br i1 %cmp3, label %true, label %recurse
recurse:
%new_lo = add i64 %lo, 1
%ans_rec = call i64 @search(i64 %new_lo, i64 %hi, i64 %target, [7 x i64]* %list)
ret i64 %ans_rec
}
define i64 @main(i64 %argc, i8** %arcv) {
%ans = call i64 @search(i64 0, i64 6, i64 54, [7 x i64]* @unsorted)
ret i64 %ans
}

62
hw6/llprograms/sp22_hw3/select_sort.ll Normal file
View file

@ -0,0 +1,62 @@
@arr = global [5 x i64] [ i64 4, i64 2, i64 3, i64 10, i64 6 ]
define void @swap(i64 * %p1, i64 * %p2) {
%temp1 = load i64, i64* %p1
%temp2 = load i64,i64* %p2
store i64 %temp2, i64* %p1
store i64 %temp1, i64* %p2
ret void
}
define i64 @getminidx(i64 %curr, i64 %indvar, i64 %arrsize){
%1 = icmp eq i64 %indvar, %arrsize
br i1 %1, label %fin, label %calc
fin:
ret i64 0
calc:
%curr_val_ptr = getelementptr [5 x i64], [5 x i64]* @arr, i64 0, i64 %curr
%curr_val = load i64, i64* %curr_val_ptr
%cmp_val_ptr = getelementptr [5 x i64], [5 x i64]* @arr, i64 0, i64 %indvar
%cmp_val = load i64, i64* %cmp_val_ptr
%cmp_bool = icmp sgt i64 %curr_val, %cmp_val
br i1 %cmp_bool, label %returnval, label %nextloop
returnval:
ret i64 %indvar
nextloop:
%nextindvar = add i64 %indvar, 1
%res = call i64 @getminidx(i64 %curr, i64 %nextindvar, i64 %arrsize)
ret i64 %res
}
define i64 @selectsort(i64 %curridx, i64 %acc, i64 %arrsize) {
%1 = icmp eq i64 %curridx, %arrsize
br i1 %1, label %donesorting, label %nextsort
donesorting:
ret i64 %acc
nextsort:
%indvar = add i64 %curridx, 1
%minidx = call i64 @getminidx(i64 %curridx, i64 %indvar, i64 %arrsize)
%idxcmp = icmp sgt i64 %minidx, 0
br i1 %idxcmp, label %swappos, label %donothing
donothing:
%currvalptr = getelementptr [5 x i64], [5 x i64]* @arr, i64 0, i64 %curridx
%currval = load i64, i64* %currvalptr
%newacc = add i64 %acc, %currval
%nextidx = add i64 %curridx, 1
%res = call i64 @selectsort(i64 %nextidx, i64 %newacc, i64 %arrsize)
ret i64 %res
swappos:
%currvalptr = getelementptr [5 x i64], [5 x i64]* @arr, i64 0, i64 %curridx
%swapvalptr = getelementptr [5 x i64], [5 x i64]* @arr, i64 0, i64 %minidx
%newval = load i64, i64* %swapvalptr
%newacc = add i64 %acc, %newval
call void @swap(i64 * %currvalptr, i64 * %swapvalptr)
%nextidx1 = add i64 %curridx, 1
%res1 = call i64 @selectsort(i64 %nextidx1, i64 %newacc, i64 %arrsize)
ret i64 %res1
}
define i64 @main(i64 %argc, i8** %arcv) {
%1 = call i64 @selectsort(i64 0, i64 0, i64 5)
ret i64 %1
}