fix the implementation

Author: HarshitaKalani

pydatastructs/linear_data_structures/_backend/cpp/algorithms/llvm_algorithms.py

@@ -139,7 +139,6 @@ def get_insertion_sort_ptr(dtype: str) -> int:
     return _materialize(dtype, "insertion")
 
 def _build_insertion_sort_ir(dtype: str) -> str:
-    """Generate LLVM IR for insertion sort for the given dtype."""
     if dtype not in _SUPPORTED:
         raise ValueError(f"Unsupported dtype '{dtype}'. Supported: {list(_SUPPORTED)}")
 
@@ -156,10 +155,13 @@ def _build_insertion_sort_ir(dtype: str) -> str:
     arr, n = fn.args
     arr.name, n.name = "arr", "n"
 
+    # Basic blocks
     b_entry = fn.append_basic_block("entry")
     b_outer = fn.append_basic_block("outer")
-    b_inner = fn.append_basic_block("inner")
-    b_latch = fn.append_basic_block("latch")
+    b_inner_cond = fn.append_basic_block("inner.cond")
+    b_inner_body = fn.append_basic_block("inner.body")
+    b_inner_latch = fn.append_basic_block("inner.latch")
+    b_outer_latch = fn.append_basic_block("outer.latch")
     b_exit = fn.append_basic_block("exit")
 
     b = ir.IRBuilder(b_entry)
@@ -169,69 +171,46 @@ def _build_insertion_sort_ir(dtype: str) -> str:
 
     b.position_at_end(b_outer)
     i_phi = b.phi(i32, name="i")
-    i_phi.add_incoming(ir.Constant(i32, 1), b_entry)
+    i_phi.add_incoming(ir.Constant(i32, 1), b_entry)  # start from 1 for insertion sort
 
     cond_outer = b.icmp_signed("<", i_phi, n)
-    b.cbranch(cond_outer, b_inner, b_exit)
-
-    b.position_at_end(b_inner)
-    i64_cast = b.sext(i_phi, i64)
+    b.cbranch(cond_outer, b_inner_cond, b_exit)
 
-    # key = arr[i]
-    ptr_i = b.gep(arr, [i64_cast])
-    key = b.load(ptr_i, name="key")
+    b.position_at_end(b_inner_cond)
+    key_ptr = b.gep(arr, [i_phi])
+    key_val = b.load(key_ptr, name="key_val")
 
-    # j = i - 1
-    j = b.sub(i_phi, ir.Constant(i32, 1), name="j")
-
-    # while j >= 0 and arr[j] > key
-    loop_cond = fn.append_basic_block("loop_cond")
-    loop_body = fn.append_basic_block("loop_body")
-    loop_exit = fn.append_basic_block("loop_exit")
+    j_phi = b.phi(i32, name="j")
+    j_phi.add_incoming(i_phi, b_outer)  # j = i
 
-    b.branch(loop_cond)
-    b.position_at_end(loop_cond)
+    inner_cond = b.icmp_signed(">", j_phi, ir.Constant(i32, 0))
+    b.cbranch(inner_cond, b_inner_body, b_outer_latch)
 
-    j64 = b.sext(j, i64)
-    ptr_j = b.gep(arr, [j64])
-    val_j = b.load(ptr_j, name="val_j")
+    b.position_at_end(b_inner_body)
+    j_minus_1 = b.sub(j_phi, ir.Constant(i32, 1))
+    ptr_j_minus_1 = b.gep(arr, [j_minus_1])
+    val_j_minus_1 = b.load(ptr_j_minus_1)
 
-    if isinstance(T, ir.IntType):
-        cmp1 = b.icmp_signed(">=", j, ir.Constant(i32, 0))
-        cmp2 = b.icmp_signed(">", val_j, key)
-    else:
-        cmp1 = b.icmp_signed(">=", j, ir.Constant(i32, 0))
-        cmp2 = b.fcmp_ordered(">", val_j, key)
+    cmp = b.icmp_signed(">", val_j_minus_1, key_val) if isinstance(T, ir.IntType) else b.fcmp_ordered(">", val_j_minus_1, key_val)
+    b.cbranch(cmp, b_inner_latch, b_outer_latch)
 
-    cond = b.and_(cmp1, cmp2)
-    b.cbranch(cond, loop_body, loop_exit)
-
-    # loop body
-    b.position_at_end(loop_body)
-    jp1 = b.add(j, ir.Constant(i32, 1))
-    jp1_64 = b.sext(jp1, i64)
-    ptr_jp1 = b.gep(arr, [jp1_64])
-    b.store(val_j, ptr_jp1)
-
-    j_next = b.sub(j, ir.Constant(i32, 1))
-    j = j_next
-    b.branch(loop_cond)
+    b.position_at_end(b_inner_latch)
+    ptr_j = b.gep(arr, [j_phi])
+    b.store(val_j_minus_1, ptr_j)
 
-    # after loop: arr[j + 1] = key
-    b.position_at_end(loop_exit)
-    jp1_final = b.add(j, ir.Constant(i32, 1))
-    jp1_final_64 = b.sext(jp1_final, i64)
-    ptr_jp1_final = b.gep(arr, [jp1_final_64])
-    b.store(key, ptr_jp1_final)
+    j_next = b.sub(j_phi, ir.Constant(i32, 1))
+    j_phi.add_incoming(j_next, b_inner_latch)
+    b.branch(b_inner_cond)
 
-    b.branch(b_latch)
+    b.position_at_end(b_outer_latch)
+    ptr_j = b.gep(arr, [j_phi])
+    b.store(key_val, ptr_j)
 
-    # outer latch
-    b.position_at_end(b_latch)
     i_next = b.add(i_phi, ir.Constant(i32, 1))
-    i_phi.add_incoming(i_next, b_latch)
+    i_phi.add_incoming(i_next, b_outer_latch)
     b.branch(b_outer)
 
+    # Exit
     b.position_at_end(b_exit)
     b.ret_void()