remove size from some vec functions

lang/src/vec.asm

@@ -402,9 +402,8 @@ vec_drop:
 
 ;; rdi: pointer to Vec struct
 ;; rsi: poiter to object to find
-;; rdx: size of object to find
+;; rdx: compare function fn(ctx: *const (), a: *const T, b: *const T) -> bool
-;; rcx: compare function fn(ctx: *const (), a: *const T, b: *const T) -> bool
+;; rcx: compare_fn context
-;; r8: compare_fn context
 vec_find:
     push rbp
     mov rbp, rsp
@@ -412,13 +411,10 @@ vec_find:
     sub rsp, 0x28
     mov [rsp], rdi          ; save vec
     mov [rsp + 8], rsi      ; save object ptr
-    mov [rsp + 0x10], rcx     ; save compare fn
+    mov [rsp + 0x10], rdx     ; save compare fn
-    mov [rsp + 0x18], rdx     ; save size
+    mov rax, [rdi + 24]   ; item_size
-    mov [rsp + 0x20], r8      ; save compare fn context
+    mov [rsp + 0x18], rax     ; save size
-
+    mov [rsp + 0x20], rcx      ; save compare fn context
-    mov rcx, [rdi + 24]   ; item_size
-    cmp rdx, rcx
-    jne .panic
 
     xor r12, r12
 .loop:
@@ -454,8 +450,8 @@ vec_find:
     pop r12
     pop rbp
     ret
-.panic:
+
-    call panic
+
 ;; rdi: pointer to Vec struct
 ;; rsi : index
 ;; rdx: pointer to data to insert

lang/tests/vec.rs

@@ -47,6 +47,16 @@ impl<T> VecT<T> {
         }
     }
 
+    fn as_slice(&self) -> &[T] {
+        assert_eq!(self.vec.elem_size, core::mem::size_of::<T>());
+        unsafe { core::slice::from_raw_parts(self.vec.data as *const T, self.vec.len) }
+    }
+
+    fn as_slice_mut(&mut self) -> &mut [T] {
+        assert_eq!(self.vec.elem_size, core::mem::size_of::<T>());
+        unsafe { core::slice::from_raw_parts_mut(self.vec.data as *mut T, self.vec.len) }
+    }
+
     fn push(&mut self, value: T) {
         let value = core::mem::ManuallyDrop::new(value);
         unsafe {
@@ -58,6 +68,20 @@ impl<T> VecT<T> {
         }
     }
 
+    fn insert(&mut self, value: T, index: usize) {
+        if index > self.vec.len {
+            return;
+        }
+        let value = core::mem::ManuallyDrop::new(value);
+        unsafe {
+            vec_insert(
+                &mut self.vec,
+                index,
+                &raw const value as *const T as *const u8,
+            );
+        }
+    }
+
     fn pop(&mut self) -> Option<T> {
         if self.vec.len == 0 {
             return None;
@@ -121,7 +145,6 @@ impl<T> VecT<T> {
             let index = vec_find(
                 &raw const self.vec as *mut _,
                 elem as *const T as *const u8,
-                core::mem::size_of::<T>(),
                 cmp_trampoline::<T, F>,
                 &raw mut cmp as *mut F as *mut (),
             );
@@ -151,6 +174,7 @@ unsafe extern "C" {
         cap: usize,
     );
     unsafe fn vec_push(vec: *mut BlobVec, elem: *const u8, size: usize);
+    unsafe fn vec_insert(vec: *mut BlobVec, index: usize, elem: *const u8);
     unsafe fn vec_pop(vec: *mut BlobVec);
     unsafe fn vec_drop_last(vec: *mut BlobVec);
     unsafe fn vec_get(vec: *mut BlobVec, index: usize) -> *mut u8;
@@ -163,10 +187,16 @@ unsafe extern "C" {
     unsafe fn vec_find(
         vec: *mut BlobVec,
         elem: *const u8,
-        size: usize,
         cmp: extern "C" fn(*const (), *const u8, *const u8) -> bool,
         cmp_data: *mut (),
     ) -> usize;
+
+    unsafe fn vec_binary_search_by(
+        vec: *mut BlobVec,
+        elem: *const u8,
+        cmp: extern "C" fn(*const (), *const u8, *const u8) -> i32,
+        cmp_data: *mut (),
+    ) -> usize;
 }
 
 fn main() {