From ca2ed2321515a02da334e91436d33560e1a15ea3 Mon Sep 17 00:00:00 2001 From: Gavrilikhin Daniil Date: Thu, 16 May 2024 20:48:45 +0800 Subject: [PATCH] Array-print (#169) * Fix array a little * Fix array --- ppl/src/array.ppl | 9 +- ppl/src/memory.ppl | 17 +- src/runtime/src/memory.rs | 28 +- src/tests/array/src/main.ppl | 9 +- .../snapshots/ppl__tests__address_of.hir.snap | 4 +- .../snapshots/ppl__tests__address_of.ir.snap | 7 +- .../snapshots/ppl__tests__array.hir.snap | 207 ++--- src/tests/snapshots/ppl__tests__array.ir.snap | 735 ++++++++---------- .../snapshots/ppl__tests__array.run.snap | 11 + .../snapshots/ppl__tests__memory.hir.snap | 4 +- .../snapshots/ppl__tests__memory.ir.snap | 7 +- .../snapshots/ppl__tests__references.hir.snap | 6 +- .../snapshots/ppl__tests__references.ir.snap | 12 +- 13 files changed, 531 insertions(+), 525 deletions(-) diff --git a/ppl/src/array.ppl b/ppl/src/array.ppl index e1181af8..854aeccd 100644 --- a/ppl/src/array.ppl +++ b/ppl/src/array.ppl @@ -35,21 +35,20 @@ fn push to >: let new_data = allocate new_capacity T let mut i = 0 while i < array.size: - let value = T at (new_data + i * bytes) - value = array[i] + let offset = i * bytes + copy bytes bytes from (array.data + offset) to (new_data + offset) i += 1 free array.data array.data = new_data array.capacity = new_capacity - let value = T at (array.data + array.size * bytes) - value = x + copy bytes bytes from (address of x) to (array.data + array.size * bytes) array.size += 1 fn > is empty => array.size == 0 fn > is not empty => array.size > 0 -fn String from > -> String: +fn String from > -> String: let mut str = "[" if array is not empty: str += (String from array[0]) diff --git a/ppl/src/memory.ppl b/ppl/src/memory.ppl index 7ed00255..a82c95e8 100644 --- a/ppl/src/memory.ppl +++ b/ppl/src/memory.ppl @@ -28,13 +28,24 @@ fn allocate <:Type> => allocate n * (size of T) bytes /// Free previously allocated memory @mangle_as("free_memory") -fn free +fn free // TODO: use `@` instead of `at` /// Value of specific type at memory address @mangle_as("read_memory") -fn > at -> ReferenceMut +fn > at -> ReferenceMut /// Get memory address of a reference @mangle_as("address_of") -fn address of -> MemoryAddress \ No newline at end of file +fn address of -> MemoryAddress + +/// Copy `n` bytes from `src` to `dst` +@mangle_as("copy_bytes") +fn copy bytes from to + +/// Copy `T` from `src` to `dst` +fn copy <:Type> from to : + copy (size of T) bytes from src to dst + +fn copy to : + copy T from (address of src) to (address of dst) diff --git a/src/runtime/src/memory.rs b/src/runtime/src/memory.rs index 0cd263e1..6a6f1a6e 100644 --- a/src/runtime/src/memory.rs +++ b/src/runtime/src/memory.rs @@ -1,4 +1,4 @@ -use libc::{c_void, malloc}; +use libc::{c_void, malloc, memcpy, size_t}; use crate::{integer_from_i64, integer_from_u64, Integer, String, Type}; @@ -47,10 +47,10 @@ pub extern "C" fn allocate_n_bytes(n: Integer) -> MemoryAddress { /// # PPL /// ```no_run -/// fn free +/// fn free /// ``` #[no_mangle] -pub extern "C" fn free_memory(address: MemoryAddress) { +pub extern "C" fn free_memory(address: &MemoryAddress) { let address = unsafe { address.value.data.as_ref().unwrap() }; let address = address.to_u64(); @@ -66,12 +66,14 @@ pub extern "C" fn free_memory(address: MemoryAddress) { /// # PPL /// ```no_run -/// fn > at -> Reference +/// fn > at -> Reference /// ``` #[no_mangle] -pub extern "C" fn read_memory(ty: Type, address: MemoryAddress) -> *mut c_void { - let _ = ty; +pub extern "C" fn read_memory(_ty: Type, address: &MemoryAddress) -> *mut c_void { + read_memory_impl(address) +} +fn read_memory_impl(address: &MemoryAddress) -> *mut c_void { let address = unsafe { address.value.data.as_ref().unwrap() }; let address = address.to_u64().unwrap(); @@ -93,3 +95,17 @@ pub extern "C" fn address_of(ptr: *const c_void) -> MemoryAddress { value: integer_from_u64(address as u64), } } + +/// # PPL +/// ```no_run +/// /// Copy `n` bytes from `src` to `dst` +/// @mangle_as("copy_bytes") +/// fn copy bytes from to +/// ``` +#[no_mangle] +pub extern "C" fn copy_bytes(n: &Integer, src: &MemoryAddress, dst: &MemoryAddress) { + let dest = read_memory_impl(dst); + let src = read_memory_impl(src); + let n = unsafe { n.data.as_ref().unwrap() }.to_usize().unwrap() as size_t; + unsafe { memcpy(dest, src, n) }; +} diff --git a/src/tests/array/src/main.ppl b/src/tests/array/src/main.ppl index 110569f7..d3babd4a 100644 --- a/src/tests/array/src/main.ppl +++ b/src/tests/array/src/main.ppl @@ -8,7 +8,8 @@ if arr is not empty: println "Not empty" println arr[0] -let mut it = iterator for arr -while it exists: - println (value from it) - advance it \ No newline at end of file +let mut i = 2 +while i <= 10: + push i to arr + i += 1 + println arr diff --git a/src/tests/snapshots/ppl__tests__address_of.hir.snap b/src/tests/snapshots/ppl__tests__address_of.hir.snap index ceadbc8a..a6043477 100644 --- a/src/tests/snapshots/ppl__tests__address_of.hir.snap +++ b/src/tests/snapshots/ppl__tests__address_of.hir.snap @@ -4,7 +4,7 @@ expression: hir --- let x: Integer = 0 let address: MemoryAddress = `address of <:Reference>`((&x:Reference)) -let x_mut_ref: ReferenceMut = `<:Type> at <:MemoryAddress>`((Type:Type), (address:MemoryAddress)) +let x_mut_ref: ReferenceMut = `<:Type> at <:Reference>`((Type:Type), (&address:Reference)) `println <:Integer>`(`clone <:Reference>`((x:Integer))) (x_mut_ref:ReferenceMut) = 1 `println <:Integer>`(`clone <:Reference>`((x:Integer))) @@ -17,7 +17,7 @@ let x_mut_ref: ReferenceMut = `<:Type> at <:MemoryAddress>`((T fn address of > -> MemoryAddress @mangle_as("read_memory") -fn > at -> ReferenceMut +fn > at > -> ReferenceMut @mangle_as("integer_as_string") fn String from <$arg0: Integer> -> String diff --git a/src/tests/snapshots/ppl__tests__address_of.ir.snap b/src/tests/snapshots/ppl__tests__address_of.ir.snap index db1ee28d..3b1411a2 100644 --- a/src/tests/snapshots/ppl__tests__address_of.ir.snap +++ b/src/tests/snapshots/ppl__tests__address_of.ir.snap @@ -97,16 +97,15 @@ declare %MemoryAddress @address_of(ptr) define private void @initialize.4() !dbg !26 { %1 = load %"Type", ptr @"Type", align 8, !dbg !27 - %2 = load %MemoryAddress, ptr @address, align 8, !dbg !28 - %3 = call ptr @read_memory(%"Type" %1, %MemoryAddress %2), !dbg !28 - store ptr %3, ptr @x_mut_ref, align 8, !dbg !28 + %2 = call ptr @read_memory(%"Type" %1, ptr @address), !dbg !28 + store ptr %2, ptr @x_mut_ref, align 8, !dbg !28 br label %return, !dbg !28 return: ; preds = %0 ret void } -declare ptr @read_memory(%"Type", %MemoryAddress) +declare ptr @read_memory(%"Type", ptr) define private void @"println <:Integer>"(%Integer %0) !dbg !29 { %x = alloca %Integer, align 8 diff --git a/src/tests/snapshots/ppl__tests__array.hir.snap b/src/tests/snapshots/ppl__tests__array.hir.snap index 55e439af..6dcd006d 100644 --- a/src/tests/snapshots/ppl__tests__array.hir.snap +++ b/src/tests/snapshots/ppl__tests__array.hir.snap @@ -3,7 +3,7 @@ source: src/tests/mod.rs expression: hir --- let mut arr: Array = `<:Type> [ ]`((Type:Type)) -let mut it: Iterator = `iterator for <:Reference>>`((&arr:ReferenceMut>)) +let mut i: Integer = 2 `println <:Array>`((arr:Array)) if `<:Reference>> is empty`((&arr:ReferenceMut>)): `println <:String>`("Empty") @@ -14,10 +14,12 @@ if `<:Reference>> is not empty`((&arr:ReferenceMut `println <:String>`("Not empty") `println <:Integer>`(`clone <:Reference>`((*`<:Reference>> [ <:Integer> ]`((&arr:ReferenceMut>), 0):Integer))) -while `<:Reference>> exists`((&it:ReferenceMut>)): - `println <:Integer>`(`clone <:Reference>`((*`value from <:Reference>>`((&it:ReferenceMut>)):Integer))) - `advance <:ReferenceMut>>`((&it:ReferenceMut>)) +while `<:Integer> <= <:Integer>`(`clone <:Reference>`((i:Integer)), 10): + `push <:Integer> to <:ReferenceMut>>`(`clone <:Reference>`((i:Integer)), (&arr:ReferenceMut>)) + `<:ReferenceMut> += <:Integer>`((&i:ReferenceMut), 1) + `println <:Array>`((arr:Array)) +`destroy <:ReferenceMut>`((i:Integer)) ==MONOMORPHIZED== @@ -41,38 +43,33 @@ fn <$arg0: Type> [ ] -> Array: return ($tmp@260:Array) -fn iterator for >> -> Iterator: - let $tmp@1687: Iterator = Iterator { array: (array:Reference>), index: 0 } - return ($tmp@1687:Iterator) - - -fn String from >> -> String: +fn String from > -> String: let mut str: String = "[" - if `<:Reference>> is not empty`((array:Reference>)): - `<:ReferenceMut> += <:String>`((&str:ReferenceMut), `String from <:Integer>`((*`<:Reference>> [ <:Integer> ]`((array:Reference>), 0):Integer))) + if `<:Reference>> is not empty`((&array:Reference>)): + `<:ReferenceMut> += <:String>`((&str:ReferenceMut), `String from <:Integer>`((*`<:Reference>> [ <:Integer> ]`((&array:Reference>), 0):Integer))) let mut i: Integer = 1 - while `<:Integer> < <:Integer>`(`clone <:Reference>`((i:Integer)), `clone <:Reference>`((*array:Array).size)): + while `<:Integer> < <:Integer>`(`clone <:Reference>`((i:Integer)), `clone <:Reference>`((array:Array).size)): `<:ReferenceMut> += <:String>`((&str:ReferenceMut), ", ") - `<:ReferenceMut> += <:String>`((&str:ReferenceMut), `String from <:Integer>`((*`<:Reference>> [ <:Integer> ]`((array:Reference>), `clone <:Reference>`((i:Integer))):Integer))) + `<:ReferenceMut> += <:String>`((&str:ReferenceMut), `String from <:Integer>`((*`<:Reference>> [ <:Integer> ]`((&array:Reference>), `clone <:Reference>`((i:Integer))):Integer))) `<:ReferenceMut> += <:Integer>`((&i:ReferenceMut), 1) `destroy <:ReferenceMut>`((i:Integer)) `<:ReferenceMut> += <:String>`((&str:ReferenceMut), "]") - let $tmp@1462: String = `clone <:Reference>`((str:String)) + let $tmp@1530: String = `clone <:Reference>`((str:String)) `destroy <:ReferenceMut>`((str:String)) - return ($tmp@1462:String) + return ($tmp@1530:String) fn println > -> None: - let $tmp@176: None = `println <:String>`(`String from <:Reference>>`((x:Array))) + let $tmp@176: None = `println <:String>`(`String from <:Array>`((x:Array))) return ($tmp@176:None) fn >> is empty -> Bool: - let $tmp@1137: Bool = `<:Integer> == <:Integer>`(`clone <:Reference>`((*array:Array).size), 0) - return ($tmp@1137:Bool) + let $tmp@1206: Bool = `<:Integer> == <:Integer>`(`clone <:Reference>`((*array:Array).size), 0) + return ($tmp@1206:Bool) fn size of > -> Integer: @@ -80,88 +77,75 @@ fn size of > -> Integer: return ($tmp@4399:Integer) -fn allocate <$arg1: Type> -> MemoryAddress: - let $tmp@760: MemoryAddress = `allocate <:Integer> bytes`(`<:Integer> * <:Integer>`(`clone <:Reference>`((n:Integer)), `size of <:Type>`((Type:Type)))) - `destroy <:ReferenceMut>`((n:Integer)) - return ($tmp@760:MemoryAddress) - - -@mangle_as("read_memory") -fn > at -> ReferenceMut - -@mangle_as("read_memory") -fn > at -> ReferenceMut - fn size of > -> Integer: let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) return ($tmp@4399:Integer) -@mangle_as("read_memory") -fn > at -> ReferenceMut - -fn >> [ ] -> Reference: - let address: MemoryAddress = `<:MemoryAddress> + <:Integer>`((*array:Array).data, `<:Integer> * <:Integer>`((i:Integer), `size of <:Type>`((Type:Type)))) - return `<:Type> at <:MemoryAddress>`((Type:Type), (address:MemoryAddress)) - +fn allocate <$arg1: Type> -> MemoryAddress: + let $tmp@760: MemoryAddress = `allocate <:Integer> bytes`(`<:Integer> * <:Integer>`(`clone <:Reference>`((n:Integer)), `size of <:Type>`((Type:Type)))) + `destroy <:ReferenceMut>`((n:Integer)) + return ($tmp@760:MemoryAddress) -@mangle_as("read_memory") -fn > at -> ReferenceMut -@mangle_as("read_memory") -fn > at -> ReferenceMut +@mangle_as("address_of") +fn address of > -> MemoryAddress fn push to >> -> None: + let bytes: Integer = `size of <:Type>`((Type:Type)) if `<:Integer> == <:Integer>`(`clone <:Reference>`((*array:Array).size), `clone <:Reference>`((*array:Array).capacity)): let new_capacity: Integer = `<:Integer> * <:Integer>`(`clone <:Reference>`((*array:Array).capacity), 2) let new_data: MemoryAddress = `allocate <:Integer> <:Type>`(`clone <:Reference>`((new_capacity:Integer)), (Type:Type)) let mut i: Integer = 0 while `<:Integer> < <:Integer>`(`clone <:Reference>`((i:Integer)), `clone <:Reference>`((*array:Array).size)): - let value: ReferenceMut = `<:Type> at <:MemoryAddress>`((Type:Type), `<:MemoryAddress> + <:Integer>`((new_data:MemoryAddress), `clone <:Reference>`((i:Integer)))) - (value:ReferenceMut) = (*`<:Reference>> [ <:Integer> ]`((array:ReferenceMut>), `clone <:Reference>`((i:Integer))):Integer) - `destroy <:ReferenceMut>`((i:Integer)) - (i:Integer) = `<:Integer> + <:Integer>`(`clone <:Reference>`((i:Integer)), 1) + let offset: Integer = `<:Integer> * <:Integer>`(`clone <:Reference>`((i:Integer)), `clone <:Reference>`((bytes:Integer))) + let $tmp@947: MemoryAddress = `<:MemoryAddress> + <:Integer>`((*array:Array).data, `clone <:Reference>`((offset:Integer))) + let $tmp@972: MemoryAddress = `<:MemoryAddress> + <:Integer>`((new_data:MemoryAddress), `clone <:Reference>`((offset:Integer))) + `copy <:Reference> bytes from <:Reference> to <:Reference>`((&bytes:Reference), (&$tmp@947:Reference), (&$tmp@972:Reference)) + `<:ReferenceMut> += <:Integer>`((&i:ReferenceMut), 1) + `destroy <:ReferenceMut>`((offset:Integer)) - `free <:MemoryAddress>`((*array:Array).data) + `free <:Reference>`((&(*array:Array).data:ReferenceMut)) (*array:Array).data = (new_data:MemoryAddress) `destroy <:ReferenceMut>`((*array:Array).capacity) (*array:Array).capacity = `clone <:Reference>`((new_capacity:Integer)) `destroy <:ReferenceMut>`((new_capacity:Integer)) `destroy <:ReferenceMut>`((i:Integer)) - let value: ReferenceMut = `<:Type> at <:MemoryAddress>`((Type:Type), `<:MemoryAddress> + <:Integer>`((*array:Array).data, `clone <:Reference>`((*array:Array).size))) - (value:ReferenceMut) = (x:Integer) - `destroy <:ReferenceMut>`((*array:Array).size) - (*array:Array).size = `<:Integer> + <:Integer>`(`clone <:Reference>`((*array:Array).size), 1) + let $tmp@1100: MemoryAddress = `address of <:Reference>`((&x:Reference)) + let $tmp@1118: MemoryAddress = `<:MemoryAddress> + <:Integer>`((*array:Array).data, `<:Integer> * <:Integer>`(`clone <:Reference>`((*array:Array).size), `clone <:Reference>`((bytes:Integer)))) + `copy <:Reference> bytes from <:Reference> to <:Reference>`((&bytes:Reference), (&$tmp@1100:Reference), (&$tmp@1118:Reference)) + `<:ReferenceMut> += <:Integer>`((&(*array:Array).size:ReferenceMut), 1) + `destroy <:ReferenceMut>`((bytes:Integer)) -fn String from >> -> String: +fn String from > -> String: let mut str: String = "[" - if `<:Reference>> is not empty`((array:Reference>)): - `<:ReferenceMut> += <:String>`((&str:ReferenceMut), `String from <:Integer>`((*`<:Reference>> [ <:Integer> ]`((array:Reference>), 0):Integer))) + if `<:Reference>> is not empty`((&array:Reference>)): + `<:ReferenceMut> += <:String>`((&str:ReferenceMut), `String from <:Integer>`((*`<:Reference>> [ <:Integer> ]`((&array:Reference>), 0):Integer))) let mut i: Integer = 1 - while `<:Integer> < <:Integer>`(`clone <:Reference>`((i:Integer)), `clone <:Reference>`((*array:Array).size)): + while `<:Integer> < <:Integer>`(`clone <:Reference>`((i:Integer)), `clone <:Reference>`((array:Array).size)): `<:ReferenceMut> += <:String>`((&str:ReferenceMut), ", ") - `<:ReferenceMut> += <:String>`((&str:ReferenceMut), `String from <:Integer>`((*`<:Reference>> [ <:Integer> ]`((array:Reference>), `clone <:Reference>`((i:Integer))):Integer))) + `<:ReferenceMut> += <:String>`((&str:ReferenceMut), `String from <:Integer>`((*`<:Reference>> [ <:Integer> ]`((&array:Reference>), `clone <:Reference>`((i:Integer))):Integer))) `<:ReferenceMut> += <:Integer>`((&i:ReferenceMut), 1) `destroy <:ReferenceMut>`((i:Integer)) `<:ReferenceMut> += <:String>`((&str:ReferenceMut), "]") - let $tmp@1462: String = `clone <:Reference>`((str:String)) + let $tmp@1530: String = `clone <:Reference>`((str:String)) `destroy <:ReferenceMut>`((str:String)) - return ($tmp@1462:String) + return ($tmp@1530:String) fn println > -> None: - let $tmp@176: None = `println <:String>`(`String from <:Reference>>`((x:Array))) + let $tmp@176: None = `println <:String>`(`String from <:Array>`((x:Array))) return ($tmp@176:None) fn >> is not empty -> Bool: - let $tmp@1194: Bool = `<:Integer> > <:Integer>`(`clone <:Reference>`((*array:Array).size), 0) - return ($tmp@1194:Bool) + let $tmp@1263: Bool = `<:Integer> > <:Integer>`(`clone <:Reference>`((*array:Array).size), 0) + return ($tmp@1263:Bool) fn size of > -> Integer: @@ -170,14 +154,14 @@ fn size of > -> Integer: @mangle_as("read_memory") -fn > at -> ReferenceMut +fn > at > -> ReferenceMut @mangle_as("read_memory") -fn > at -> ReferenceMut +fn > at > -> ReferenceMut fn >> [ ] -> Reference: let address: MemoryAddress = `<:MemoryAddress> + <:Integer>`((*array:Array).data, `<:Integer> * <:Integer>`(`clone <:Reference>`((i:Integer)), `size of <:Type>`((Type:Type)))) - let mut $tmp@467: ReferenceMut = `<:Type> at <:MemoryAddress>`((Type:Type), (address:MemoryAddress)) + let mut $tmp@467: ReferenceMut = `<:Type> at <:Reference>`((Type:Type), (&address:Reference)) `destroy <:ReferenceMut>`((i:Integer)) return ($tmp@467:ReferenceMut) @@ -191,22 +175,19 @@ fn println -> None: -fn >> exists -> Bool: - let $tmp@1755: Bool = `<:Integer> < <:Integer>`(`clone <:Reference>`((*it:Iterator).index), `clone <:Reference>`((*(*it:Iterator).array:Array).size)) - return ($tmp@1755:Bool) +@mangle_as("integer_less_integer") +fn <$arg0: Integer> < <$arg1: Integer> -> Bool +fn > -> Bool: + let $tmp@1032: Bool = `<:Integer> < <:Integer>`((y:Integer), (x:Integer)) + return ($tmp@1032:Bool) -fn size of > -> Integer: - let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) - return ($tmp@4399:Integer) -@mangle_as("read_memory") -fn > at -> ReferenceMut +fn <= -> Bool: + let $tmp@1068: Bool = `not <:Bool>`(`<:Integer> > <:Integer>`((x:Integer), (y:Integer))) + return ($tmp@1068:Bool) -fn >> [ ] -> Reference: - let address: MemoryAddress = `<:MemoryAddress> + <:Integer>`((*array:Array).data, `<:Integer> * <:Integer>`((i:Integer), `size of <:Type>`((Type:Type)))) - return `<:Type> at <:MemoryAddress>`((Type:Type), (address:MemoryAddress)) fn size of > -> Integer: @@ -214,27 +195,73 @@ fn size of > -> Integer: return ($tmp@4399:Integer) -@mangle_as("read_memory") -fn > at -> ReferenceMut +fn size of > -> Integer: + let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) + return ($tmp@4399:Integer) -fn >> [ ] -> Reference: - let address: MemoryAddress = `<:MemoryAddress> + <:Integer>`((*array:Array).data, `<:Integer> * <:Integer>`((i:Integer), `size of <:Type>`((Type:Type)))) - return `<:Type> at <:MemoryAddress>`((Type:Type), (address:MemoryAddress)) + +fn allocate <$arg1: Type> -> MemoryAddress: + let $tmp@760: MemoryAddress = `allocate <:Integer> bytes`(`<:Integer> * <:Integer>`(`clone <:Reference>`((n:Integer)), `size of <:Type>`((Type:Type)))) + `destroy <:ReferenceMut>`((n:Integer)) + return ($tmp@760:MemoryAddress) -fn value from >> -> Reference: - let $tmp@1886: Reference = `<:Reference>> [ <:Integer> ]`((*it:Iterator).array, `clone <:Reference>`((*it:Iterator).index)) - return ($tmp@1886:Reference) +@mangle_as("address_of") +fn address of > -> MemoryAddress +fn push to >> -> None: + let bytes: Integer = `size of <:Type>`((Type:Type)) + if `<:Integer> == <:Integer>`(`clone <:Reference>`((*array:Array).size), `clone <:Reference>`((*array:Array).capacity)): + let new_capacity: Integer = `<:Integer> * <:Integer>`(`clone <:Reference>`((*array:Array).capacity), 2) + let new_data: MemoryAddress = `allocate <:Integer> <:Type>`(`clone <:Reference>`((new_capacity:Integer)), (Type:Type)) + let mut i: Integer = 0 + while `<:Integer> < <:Integer>`(`clone <:Reference>`((i:Integer)), `clone <:Reference>`((*array:Array).size)): + let offset: Integer = `<:Integer> * <:Integer>`(`clone <:Reference>`((i:Integer)), `clone <:Reference>`((bytes:Integer))) + let $tmp@947: MemoryAddress = `<:MemoryAddress> + <:Integer>`((*array:Array).data, `clone <:Reference>`((offset:Integer))) + let $tmp@972: MemoryAddress = `<:MemoryAddress> + <:Integer>`((new_data:MemoryAddress), `clone <:Reference>`((offset:Integer))) + `copy <:Reference> bytes from <:Reference> to <:Reference>`((&bytes:Reference), (&$tmp@947:Reference), (&$tmp@972:Reference)) + `<:ReferenceMut> += <:Integer>`((&i:ReferenceMut), 1) + `destroy <:ReferenceMut>`((offset:Integer)) -@mangle_as("integer_as_string") -fn String from <$arg0: Integer> -> String + `free <:Reference>`((&(*array:Array).data:ReferenceMut)) + (*array:Array).data = (new_data:MemoryAddress) + `destroy <:ReferenceMut>`((*array:Array).capacity) + (*array:Array).capacity = `clone <:Reference>`((new_capacity:Integer)) + `destroy <:ReferenceMut>`((new_capacity:Integer)) + `destroy <:ReferenceMut>`((i:Integer)) -fn println -> None: - let $tmp@176: None = `println <:String>`(`String from <:Integer>`((x:Integer))) - return ($tmp@176:None) + let $tmp@1100: MemoryAddress = `address of <:Reference>`((&x:Reference)) + let $tmp@1118: MemoryAddress = `<:MemoryAddress> + <:Integer>`((*array:Array).data, `<:Integer> * <:Integer>`(`clone <:Reference>`((*array:Array).size), `clone <:Reference>`((bytes:Integer)))) + `copy <:Reference> bytes from <:Reference> to <:Reference>`((&bytes:Reference), (&$tmp@1100:Reference), (&$tmp@1118:Reference)) + `<:ReferenceMut> += <:Integer>`((&(*array:Array).size:ReferenceMut), 1) + `destroy <:ReferenceMut>`((bytes:Integer)) + + +@mangle_as("integer_plus_integer") +fn <$arg0: Integer> + <$arg1: Integer> -> Integer + +fn > += -> None: + (self:ReferenceMut) = `<:Integer> + <:Integer>`((*self:Integer), (other:Integer)) + + +fn String from > -> String: + let mut str: String = "[" + if `<:Reference>> is not empty`((&array:Reference>)): + `<:ReferenceMut> += <:String>`((&str:ReferenceMut), `String from <:Integer>`((*`<:Reference>> [ <:Integer> ]`((&array:Reference>), 0):Integer))) + let mut i: Integer = 1 + while `<:Integer> < <:Integer>`(`clone <:Reference>`((i:Integer)), `clone <:Reference>`((array:Array).size)): + `<:ReferenceMut> += <:String>`((&str:ReferenceMut), ", ") + `<:ReferenceMut> += <:String>`((&str:ReferenceMut), `String from <:Integer>`((*`<:Reference>> [ <:Integer> ]`((&array:Reference>), `clone <:Reference>`((i:Integer))):Integer))) + `<:ReferenceMut> += <:Integer>`((&i:ReferenceMut), 1) + `destroy <:ReferenceMut>`((i:Integer)) + + `<:ReferenceMut> += <:String>`((&str:ReferenceMut), "]") + let $tmp@1530: String = `clone <:Reference>`((str:String)) + `destroy <:ReferenceMut>`((str:String)) + return ($tmp@1530:String) -fn advance >> -> None: - `<:ReferenceMut> += <:Integer>`((&(*it:Iterator).index:ReferenceMut), 1) +fn println > -> None: + let $tmp@176: None = `println <:String>`(`String from <:Array>`((x:Array))) + return ($tmp@176:None) diff --git a/src/tests/snapshots/ppl__tests__array.ir.snap b/src/tests/snapshots/ppl__tests__array.ir.snap index 99216449..9ee934d4 100644 --- a/src/tests/snapshots/ppl__tests__array.ir.snap +++ b/src/tests/snapshots/ppl__tests__array.ir.snap @@ -11,14 +11,13 @@ source_filename = "src/main.ppl" %"Type" = type { %String, %Integer } %"Array" = type { %Integer, %Integer, %MemoryAddress } %MemoryAddress = type { %Integer } -%"Iterator" = type { ptr, %Integer } @"Type" = private global %"Type" zeroinitializer @0 = private unnamed_addr constant [7 x i8] c"String\00", align 1 @"Type" = private global %"Type" zeroinitializer @1 = private unnamed_addr constant [8 x i8] c"Integer\00", align 1 @arr = global %"Array" zeroinitializer -@it = global %"Iterator" zeroinitializer +@i = global %Integer zeroinitializer @2 = private unnamed_addr constant [2 x i8] c"[\00", align 1 @3 = private unnamed_addr constant [3 x i8] c", \00", align 1 @4 = private unnamed_addr constant [2 x i8] c"]\00", align 1 @@ -79,7 +78,7 @@ if.body: ; preds = %if.condition call void @"println <:String>"(%String %3), !dbg !17 br label %4, !dbg !17 -return: ; preds = %16 +return: ; preds = %19 ret void 4: ; preds = %if.condition, %if.body @@ -106,82 +105,87 @@ if.body1: ; preds = %if.condition2 br label %while.condition, !dbg !24 while.condition: ; preds = %while.body, %9 - %13 = call i1 @"<:Reference>> exists"(ptr @it), !dbg !25 - br i1 %13, label %while.body, label %16, !dbg !25 + %13 = call %Integer @clone_integer(ptr @i), !dbg !25 + %14 = call %Integer @integer_from_i64(i64 10), !dbg !26 + %15 = call i1 @"<:Integer> <= <:Integer>"(%Integer %13, %Integer %14), !dbg !26 + br i1 %15, label %while.body, label %19, !dbg !26 while.body: ; preds = %while.condition - %14 = call ptr @"value from <:Reference>>"(ptr @it), !dbg !26 - %15 = call %Integer @clone_integer(ptr %14), !dbg !26 - call void @"println <:Integer>"(%Integer %15), !dbg !26 - call void @"advance <:ReferenceMut>>"(ptr @it), !dbg !27 - br label %while.condition, !dbg !27 - -16: ; preds = %while.condition - br label %return, !dbg !25 + %16 = call %Integer @clone_integer(ptr @i), !dbg !27 + call void @"push <:Integer> to <:ReferenceMut>>"(%Integer %16, ptr @arr), !dbg !28 + %17 = call %Integer @integer_from_i64(i64 1), !dbg !29 + call void @"<:ReferenceMut> += <:Integer>"(ptr @i, %Integer %17), !dbg !29 + %18 = load %"Array", ptr @arr, align 8, !dbg !30 + call void @"println <:Array>"(%"Array" %18), !dbg !30 + br label %while.condition, !dbg !30 + +19: ; preds = %while.condition + call void @destroy_integer(ptr @i), !dbg !31 + br label %return, !dbg !31 } -define private void @initialize.2() !dbg !28 { - %1 = load %"Type", ptr @"Type", align 8, !dbg !29 - %2 = call %"Array" @"<:Type> [ ]"(%"Type" %1), !dbg !29 - store %"Array" %2, ptr @arr, align 8, !dbg !29 - br label %return, !dbg !29 +define private void @initialize.2() !dbg !32 { + %1 = load %"Type", ptr @"Type", align 8, !dbg !33 + %2 = call %"Array" @"<:Type> [ ]"(%"Type" %1), !dbg !33 + store %"Array" %2, ptr @arr, align 8, !dbg !33 + br label %return, !dbg !33 return: ; preds = %0 ret void } -define private %"Array" @"<:Type> [ ]"(%"Type" %0) !dbg !30 { +define private %"Array" @"<:Type> [ ]"(%"Type" %0) !dbg !34 { %return_value = alloca %"Array", align 8 %"$arg0" = alloca %"Type", align 8 store %"Type" %0, ptr %"$arg0", align 8 - %2 = call %Integer @integer_from_i64(i64 8), !dbg !31 - %capacity = alloca %Integer, align 8, !dbg !31 - store %Integer %2, ptr %capacity, align 8, !dbg !31 - %3 = call %Integer @clone_integer(ptr %capacity), !dbg !32 - %4 = load %"Type", ptr @"Type", align 8, !dbg !32 - %5 = call %MemoryAddress @"allocate <:Integer> <:Type>"(%Integer %3, %"Type" %4), !dbg !32 - %data = alloca %MemoryAddress, align 8, !dbg !32 - store %MemoryAddress %5, ptr %data, align 8, !dbg !32 - %6 = alloca %"Array", align 8, !dbg !32 - %"Array.size" = getelementptr inbounds %"Array", ptr %6, i32 0, i32 0, !dbg !32 - %7 = call %Integer @integer_from_i64(i64 0), !dbg !32 - store %Integer %7, ptr %"Array.size", align 8, !dbg !32 - %"Array.capacity" = getelementptr inbounds %"Array", ptr %6, i32 0, i32 1, !dbg !32 - %8 = call %Integer @clone_integer(ptr %capacity), !dbg !32 - store %Integer %8, ptr %"Array.capacity", align 8, !dbg !32 - %"Array.data" = getelementptr inbounds %"Array", ptr %6, i32 0, i32 2, !dbg !32 - %9 = load %MemoryAddress, ptr %data, align 8, !dbg !32 - store %MemoryAddress %9, ptr %"Array.data", align 8, !dbg !32 - %10 = load %"Array", ptr %6, align 8, !dbg !32 - %"$tmp@260" = alloca %"Array", align 8, !dbg !32 - store %"Array" %10, ptr %"$tmp@260", align 8, !dbg !32 - call void @destroy_integer(ptr %capacity), !dbg !33 - %11 = load %"Array", ptr %"$tmp@260", align 8, !dbg !32 - store %"Array" %11, ptr %return_value, align 8, !dbg !32 - br label %return, !dbg !32 + %2 = call %Integer @integer_from_i64(i64 8), !dbg !35 + %capacity = alloca %Integer, align 8, !dbg !35 + store %Integer %2, ptr %capacity, align 8, !dbg !35 + %3 = call %Integer @clone_integer(ptr %capacity), !dbg !36 + %4 = load %"Type", ptr @"Type", align 8, !dbg !36 + %5 = call %MemoryAddress @"allocate <:Integer> <:Type>"(%Integer %3, %"Type" %4), !dbg !36 + %data = alloca %MemoryAddress, align 8, !dbg !36 + store %MemoryAddress %5, ptr %data, align 8, !dbg !36 + %6 = alloca %"Array", align 8, !dbg !36 + %"Array.size" = getelementptr inbounds %"Array", ptr %6, i32 0, i32 0, !dbg !36 + %7 = call %Integer @integer_from_i64(i64 0), !dbg !36 + store %Integer %7, ptr %"Array.size", align 8, !dbg !36 + %"Array.capacity" = getelementptr inbounds %"Array", ptr %6, i32 0, i32 1, !dbg !36 + %8 = call %Integer @clone_integer(ptr %capacity), !dbg !36 + store %Integer %8, ptr %"Array.capacity", align 8, !dbg !36 + %"Array.data" = getelementptr inbounds %"Array", ptr %6, i32 0, i32 2, !dbg !36 + %9 = load %MemoryAddress, ptr %data, align 8, !dbg !36 + store %MemoryAddress %9, ptr %"Array.data", align 8, !dbg !36 + %10 = load %"Array", ptr %6, align 8, !dbg !36 + %"$tmp@260" = alloca %"Array", align 8, !dbg !36 + store %"Array" %10, ptr %"$tmp@260", align 8, !dbg !36 + call void @destroy_integer(ptr %capacity), !dbg !37 + %11 = load %"Array", ptr %"$tmp@260", align 8, !dbg !36 + store %"Array" %11, ptr %return_value, align 8, !dbg !36 + br label %return, !dbg !36 return: ; preds = %1 %12 = load %"Array", ptr %return_value, align 8 ret %"Array" %12 } -define private %MemoryAddress @"allocate <:Integer> <:Type>"(%Integer %0, %"Type" %1) !dbg !34 { +define private %MemoryAddress @"allocate <:Integer> <:Type>"(%Integer %0, %"Type" %1) !dbg !38 { %return_value = alloca %MemoryAddress, align 8 %n = alloca %Integer, align 8 store %Integer %0, ptr %n, align 8 %"$arg1" = alloca %"Type", align 8 store %"Type" %1, ptr %"$arg1", align 8 - %3 = call %Integer @clone_integer(ptr %n), !dbg !35 - %4 = load %"Type", ptr @"Type", align 8, !dbg !35 - %5 = call %Integer @"size of <:Type>"(%"Type" %4), !dbg !35 - %6 = call %Integer @integer_star_integer(%Integer %3, %Integer %5), !dbg !35 - %7 = call %MemoryAddress @allocate_n_bytes(%Integer %6), !dbg !35 - %"$tmp@760" = alloca %MemoryAddress, align 8, !dbg !35 - store %MemoryAddress %7, ptr %"$tmp@760", align 8, !dbg !35 - call void @destroy_integer(ptr %n), !dbg !35 - %8 = load %MemoryAddress, ptr %"$tmp@760", align 8, !dbg !35 - store %MemoryAddress %8, ptr %return_value, align 8, !dbg !35 - br label %return, !dbg !35 + %3 = call %Integer @clone_integer(ptr %n), !dbg !39 + %4 = load %"Type", ptr @"Type", align 8, !dbg !39 + %5 = call %Integer @"size of <:Type>"(%"Type" %4), !dbg !39 + %6 = call %Integer @integer_star_integer(%Integer %3, %Integer %5), !dbg !39 + %7 = call %MemoryAddress @allocate_n_bytes(%Integer %6), !dbg !39 + %"$tmp@760" = alloca %MemoryAddress, align 8, !dbg !39 + store %MemoryAddress %7, ptr %"$tmp@760", align 8, !dbg !39 + call void @destroy_integer(ptr %n), !dbg !39 + %8 = load %MemoryAddress, ptr %"$tmp@760", align 8, !dbg !39 + store %MemoryAddress %8, ptr %return_value, align 8, !dbg !39 + br label %return, !dbg !39 return: ; preds = %2 %9 = load %MemoryAddress, ptr %return_value, align 8 @@ -194,17 +198,17 @@ declare %Integer @integer_star_integer(%Integer, %Integer) declare %Integer @clone_integer(ptr) -define private %Integer @"size of <:Type>"(%"Type" %0) !dbg !36 { +define private %Integer @"size of <:Type>"(%"Type" %0) !dbg !40 { %return_value = alloca %Integer, align 8 %ty = alloca %"Type", align 8 store %"Type" %0, ptr %ty, align 8 - %size = getelementptr inbounds %"Type", ptr %ty, i32 0, i32 1, !dbg !37 - %2 = call %Integer @clone_integer(ptr %size), !dbg !37 - %"$tmp@4399" = alloca %Integer, align 8, !dbg !37 - store %Integer %2, ptr %"$tmp@4399", align 8, !dbg !37 - %3 = load %Integer, ptr %"$tmp@4399", align 8, !dbg !37 - store %Integer %3, ptr %return_value, align 8, !dbg !37 - br label %return, !dbg !37 + %size = getelementptr inbounds %"Type", ptr %ty, i32 0, i32 1, !dbg !41 + %2 = call %Integer @clone_integer(ptr %size), !dbg !41 + %"$tmp@4399" = alloca %Integer, align 8, !dbg !41 + store %Integer %2, ptr %"$tmp@4399", align 8, !dbg !41 + %3 = load %Integer, ptr %"$tmp@4399", align 8, !dbg !41 + store %Integer %3, ptr %return_value, align 8, !dbg !41 + br label %return, !dbg !41 return: ; preds = %1 %4 = load %Integer, ptr %return_value, align 8 @@ -213,44 +217,22 @@ return: ; preds = %1 declare void @destroy_integer(ptr) -define private void @initialize.3() !dbg !38 { - %1 = call %"Iterator" @"iterator for <:Reference>>"(ptr @arr), !dbg !39 - store %"Iterator" %1, ptr @it, align 8, !dbg !39 - br label %return, !dbg !39 +define private void @initialize.3() !dbg !42 { + %1 = call %Integer @integer_from_i64(i64 2), !dbg !43 + store %Integer %1, ptr @i, align 8, !dbg !43 + br label %return, !dbg !43 return: ; preds = %0 ret void } -define private %"Iterator" @"iterator for <:Reference>>"(ptr %0) !dbg !40 { - %return_value = alloca %"Iterator", align 8 - %array = alloca ptr, align 8 - store ptr %0, ptr %array, align 8 - %2 = alloca %"Iterator", align 8, !dbg !41 - %"Iterator.array" = getelementptr inbounds %"Iterator", ptr %2, i32 0, i32 0, !dbg !41 - %3 = load ptr, ptr %array, align 8, !dbg !41 - store ptr %3, ptr %"Iterator.array", align 8, !dbg !41 - %"Iterator.index" = getelementptr inbounds %"Iterator", ptr %2, i32 0, i32 1, !dbg !41 - %4 = call %Integer @integer_from_i64(i64 0), !dbg !41 - store %Integer %4, ptr %"Iterator.index", align 8, !dbg !41 - %5 = load %"Iterator", ptr %2, align 8, !dbg !41 - %"$tmp@1687" = alloca %"Iterator", align 8, !dbg !41 - store %"Iterator" %5, ptr %"$tmp@1687", align 8, !dbg !41 - %6 = load %"Iterator", ptr %"$tmp@1687", align 8, !dbg !41 - store %"Iterator" %6, ptr %return_value, align 8, !dbg !41 - br label %return, !dbg !41 - -return: ; preds = %1 - %7 = load %"Iterator", ptr %return_value, align 8 - ret %"Iterator" %7 -} - -define private void @"println <:Array>"(%"Array" %0) !dbg !42 { +define private void @"println <:Array>"(%"Array" %0) !dbg !44 { %x = alloca %"Array", align 8 store %"Array" %0, ptr %x, align 8 - %2 = call %String @"String from <:Reference>>"(ptr %x), !dbg !43 - call void @"println <:String>"(%String %2), !dbg !43 - br label %return, !dbg !44 + %2 = load %"Array", ptr %x, align 8, !dbg !45 + %3 = call %String @"String from <:Array>"(%"Array" %2), !dbg !45 + call void @"println <:String>"(%String %3), !dbg !45 + br label %return, !dbg !46 return: ; preds = %1 ret void @@ -258,78 +240,77 @@ return: ; preds = %1 declare void @"println <:String>"(%String) -define private %String @"String from <:Reference>>"(ptr %0) !dbg !45 { +define private %String @"String from <:Array>"(%"Array" %0) !dbg !47 { %return_value = alloca %String, align 8 - %array = alloca ptr, align 8 - store ptr %0, ptr %array, align 8 - %2 = call %String @string_from_c_string_and_length(ptr @2, i64 1), !dbg !46 - %str = alloca %String, align 8, !dbg !46 - store %String %2, ptr %str, align 8, !dbg !46 - br label %if.condition, !dbg !46 + %array = alloca %"Array", align 8 + store %"Array" %0, ptr %array, align 8 + %2 = call %String @string_from_c_string_and_length(ptr @2, i64 1), !dbg !48 + %str = alloca %String, align 8, !dbg !48 + store %String %2, ptr %str, align 8, !dbg !48 + br label %if.condition, !dbg !48 if.condition: ; preds = %1 - %3 = call i1 @"<:Reference>> is not empty"(ptr %array), !dbg !46 - br i1 %3, label %if.body, label %10, !dbg !46 + %3 = call i1 @"<:Reference>> is not empty"(ptr %array), !dbg !48 + br i1 %3, label %if.body, label %10, !dbg !48 if.body: ; preds = %if.condition - %4 = call %Integer @integer_from_i64(i64 0), !dbg !46 - %5 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr %array, %Integer %4), !dbg !46 - %6 = load %Integer, ptr %5, align 8, !dbg !46 - %7 = call %String @integer_as_string(%Integer %6), !dbg !46 - call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %7), !dbg !46 - %8 = call %Integer @integer_from_i64(i64 1), !dbg !46 - %i = alloca %Integer, align 8, !dbg !46 - store %Integer %8, ptr %i, align 8, !dbg !46 - br label %while.condition, !dbg !46 + %4 = call %Integer @integer_from_i64(i64 0), !dbg !48 + %5 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr %array, %Integer %4), !dbg !48 + %6 = load %Integer, ptr %5, align 8, !dbg !48 + %7 = call %String @integer_as_string(%Integer %6), !dbg !48 + call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %7), !dbg !48 + %8 = call %Integer @integer_from_i64(i64 1), !dbg !48 + %i = alloca %Integer, align 8, !dbg !48 + store %Integer %8, ptr %i, align 8, !dbg !48 + br label %while.condition, !dbg !48 return: ; preds = %10 %9 = load %String, ptr %return_value, align 8 ret %String %9 -10: ; preds = %if.condition, %24 - %11 = call %String @string_from_c_string_and_length(ptr @4, i64 1), !dbg !46 - call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %11), !dbg !46 - %12 = call %String @clone_string(ptr %str), !dbg !46 - %"$tmp@1462" = alloca %String, align 8, !dbg !46 - store %String %12, ptr %"$tmp@1462", align 8, !dbg !46 - call void @destroy_string(ptr %str), !dbg !46 - %13 = load %String, ptr %"$tmp@1462", align 8, !dbg !46 - store %String %13, ptr %return_value, align 8, !dbg !46 - br label %return, !dbg !46 +10: ; preds = %if.condition, %23 + %11 = call %String @string_from_c_string_and_length(ptr @4, i64 1), !dbg !48 + call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %11), !dbg !48 + %12 = call %String @clone_string(ptr %str), !dbg !48 + %"$tmp@1530" = alloca %String, align 8, !dbg !48 + store %String %12, ptr %"$tmp@1530", align 8, !dbg !48 + call void @destroy_string(ptr %str), !dbg !48 + %13 = load %String, ptr %"$tmp@1530", align 8, !dbg !48 + store %String %13, ptr %return_value, align 8, !dbg !48 + br label %return, !dbg !48 while.condition: ; preds = %while.body, %if.body - %14 = call %Integer @clone_integer(ptr %i), !dbg !46 - %15 = load ptr, ptr %array, align 8, !dbg !46 - %size = getelementptr inbounds %"Array", ptr %15, i32 0, i32 0, !dbg !46 - %16 = call %Integer @clone_integer(ptr %size), !dbg !46 - %17 = call i1 @integer_less_integer(%Integer %14, %Integer %16), !dbg !46 - br i1 %17, label %while.body, label %24, !dbg !46 + %14 = call %Integer @clone_integer(ptr %i), !dbg !48 + %size = getelementptr inbounds %"Array", ptr %array, i32 0, i32 0, !dbg !48 + %15 = call %Integer @clone_integer(ptr %size), !dbg !48 + %16 = call i1 @integer_less_integer(%Integer %14, %Integer %15), !dbg !48 + br i1 %16, label %while.body, label %23, !dbg !48 while.body: ; preds = %while.condition - %18 = call %String @string_from_c_string_and_length(ptr @3, i64 2), !dbg !46 - call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %18), !dbg !46 - %19 = call %Integer @clone_integer(ptr %i), !dbg !46 - %20 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr %array, %Integer %19), !dbg !46 - %21 = load %Integer, ptr %20, align 8, !dbg !46 - %22 = call %String @integer_as_string(%Integer %21), !dbg !46 - call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %22), !dbg !46 - %23 = call %Integer @integer_from_i64(i64 1), !dbg !46 - call void @"<:ReferenceMut> += <:Integer>"(ptr %i, %Integer %23), !dbg !46 - br label %while.condition, !dbg !46 - -24: ; preds = %while.condition - call void @destroy_integer(ptr %i), !dbg !46 - br label %10, !dbg !46 + %17 = call %String @string_from_c_string_and_length(ptr @3, i64 2), !dbg !48 + call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %17), !dbg !48 + %18 = call %Integer @clone_integer(ptr %i), !dbg !48 + %19 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr %array, %Integer %18), !dbg !48 + %20 = load %Integer, ptr %19, align 8, !dbg !48 + %21 = call %String @integer_as_string(%Integer %20), !dbg !48 + call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %21), !dbg !48 + %22 = call %Integer @integer_from_i64(i64 1), !dbg !48 + call void @"<:ReferenceMut> += <:Integer>"(ptr %i, %Integer %22), !dbg !48 + br label %while.condition, !dbg !48 + +23: ; preds = %while.condition + call void @destroy_integer(ptr %i), !dbg !48 + br label %10, !dbg !48 } -define private void @"<:ReferenceMut> += <:String>"(ptr %0, %String %1) !dbg !47 { +define private void @"<:ReferenceMut> += <:String>"(ptr %0, %String %1) !dbg !49 { %self = alloca ptr, align 8 store ptr %0, ptr %self, align 8 %other = alloca %String, align 8 store %String %1, ptr %other, align 8 - %3 = load ptr, ptr %self, align 8, !dbg !48 - %4 = load ptr, ptr %self, align 8, !dbg !49 - %5 = load %String, ptr %4, align 8, !dbg !49 + %3 = load ptr, ptr %self, align 8, !dbg !50 + %4 = load ptr, ptr %self, align 8, !dbg !50 + %5 = load %String, ptr %4, align 8, !dbg !50 %6 = load %String, ptr %other, align 8, !dbg !50 %7 = call %String @string_plus_string(%String %5, %String %6), !dbg !50 store %String %7, ptr %3, align 8, !dbg !50 @@ -360,19 +341,18 @@ define private ptr @"<:Reference>> [ <:Integer> ]"(ptr %0, %Integ %address = alloca %MemoryAddress, align 8, !dbg !52 store %MemoryAddress %9, ptr %address, align 8, !dbg !52 %10 = load %"Type", ptr @"Type", align 8, !dbg !52 - %11 = load %MemoryAddress, ptr %address, align 8, !dbg !52 - %12 = call ptr @read_memory(%"Type" %10, %MemoryAddress %11), !dbg !52 - store ptr %12, ptr %return_value, align 8, !dbg !52 + %11 = call ptr @read_memory(%"Type" %10, ptr %address), !dbg !52 + store ptr %11, ptr %return_value, align 8, !dbg !52 br label %return, !dbg !52 return: ; preds = %2 - %13 = load ptr, ptr %return_value, align 8 - ret ptr %13 + %12 = load ptr, ptr %return_value, align 8 + ret ptr %12 } declare %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress, %Integer) -declare ptr @read_memory(%"Type", %MemoryAddress) +declare ptr @read_memory(%"Type", ptr) define private void @"<:ReferenceMut> += <:Integer>"(ptr %0, %Integer %1) !dbg !53 { %self = alloca ptr, align 8 @@ -380,12 +360,12 @@ define private void @"<:ReferenceMut> += <:Integer>"(ptr %0, %Integer % %other = alloca %Integer, align 8 store %Integer %1, ptr %other, align 8 %3 = load ptr, ptr %self, align 8, !dbg !54 - %4 = load ptr, ptr %self, align 8, !dbg !55 - %5 = load %Integer, ptr %4, align 8, !dbg !55 - %6 = load %Integer, ptr %other, align 8, !dbg !56 - %7 = call %Integer @integer_plus_integer(%Integer %5, %Integer %6), !dbg !56 - store %Integer %7, ptr %3, align 8, !dbg !56 - br label %return, !dbg !56 + %4 = load ptr, ptr %self, align 8, !dbg !54 + %5 = load %Integer, ptr %4, align 8, !dbg !54 + %6 = load %Integer, ptr %other, align 8, !dbg !54 + %7 = call %Integer @integer_plus_integer(%Integer %5, %Integer %6), !dbg !54 + store %Integer %7, ptr %3, align 8, !dbg !54 + br label %return, !dbg !54 return: ; preds = %2 ret void @@ -395,37 +375,37 @@ declare %Integer @integer_plus_integer(%Integer, %Integer) declare i1 @integer_less_integer(%Integer, %Integer) -define private i1 @"<:Reference>> is not empty"(ptr %0) !dbg !57 { +define private i1 @"<:Reference>> is not empty"(ptr %0) !dbg !55 { %return_value = alloca i1, align 1 %array = alloca ptr, align 8 store ptr %0, ptr %array, align 8 - %2 = load ptr, ptr %array, align 8, !dbg !58 - %size = getelementptr inbounds %"Array", ptr %2, i32 0, i32 0, !dbg !58 - %3 = load %Integer, ptr %size, align 8, !dbg !58 - %4 = call %Integer @integer_from_i64(i64 0), !dbg !58 - %5 = call i1 @"<:Integer> > <:Integer>"(%Integer %3, %Integer %4), !dbg !58 - store i1 %5, ptr %return_value, align 1, !dbg !58 - br label %return, !dbg !58 + %2 = load ptr, ptr %array, align 8, !dbg !56 + %size = getelementptr inbounds %"Array", ptr %2, i32 0, i32 0, !dbg !56 + %3 = load %Integer, ptr %size, align 8, !dbg !56 + %4 = call %Integer @integer_from_i64(i64 0), !dbg !56 + %5 = call i1 @"<:Integer> > <:Integer>"(%Integer %3, %Integer %4), !dbg !56 + store i1 %5, ptr %return_value, align 1, !dbg !56 + br label %return, !dbg !56 return: ; preds = %1 %6 = load i1, ptr %return_value, align 1 ret i1 %6 } -define private i1 @"<:Integer> > <:Integer>"(%Integer %0, %Integer %1) !dbg !59 { +define private i1 @"<:Integer> > <:Integer>"(%Integer %0, %Integer %1) !dbg !57 { %return_value = alloca i1, align 1 %x = alloca %Integer, align 8 store %Integer %0, ptr %x, align 8 %y = alloca %Integer, align 8 store %Integer %1, ptr %y, align 8 - %3 = load %Integer, ptr %y, align 8, !dbg !60 - %4 = load %Integer, ptr %x, align 8, !dbg !60 - %5 = call i1 @integer_less_integer(%Integer %3, %Integer %4), !dbg !60 - %"$tmp@1032" = alloca i1, align 1, !dbg !60 - store i1 %5, ptr %"$tmp@1032", align 1, !dbg !60 - %6 = load i1, ptr %"$tmp@1032", align 1, !dbg !60 - store i1 %6, ptr %return_value, align 1, !dbg !60 - br label %return, !dbg !60 + %3 = load %Integer, ptr %y, align 8, !dbg !58 + %4 = load %Integer, ptr %x, align 8, !dbg !58 + %5 = call i1 @integer_less_integer(%Integer %3, %Integer %4), !dbg !58 + %"$tmp@1032" = alloca i1, align 1, !dbg !58 + store i1 %5, ptr %"$tmp@1032", align 1, !dbg !58 + %6 = load i1, ptr %"$tmp@1032", align 1, !dbg !58 + store i1 %6, ptr %return_value, align 1, !dbg !58 + br label %return, !dbg !58 return: ; preds = %2 %7 = load i1, ptr %return_value, align 1 @@ -436,20 +416,20 @@ declare %String @clone_string(ptr) declare void @destroy_string(ptr) -define private i1 @"<:Reference>> is empty"(ptr %0) !dbg !61 { +define private i1 @"<:Reference>> is empty"(ptr %0) !dbg !59 { %return_value = alloca i1, align 1 %array = alloca ptr, align 8 store ptr %0, ptr %array, align 8 - %2 = load ptr, ptr %array, align 8, !dbg !62 - %size = getelementptr inbounds %"Array", ptr %2, i32 0, i32 0, !dbg !62 - %3 = call %Integer @clone_integer(ptr %size), !dbg !62 - %4 = call %Integer @integer_from_i64(i64 0), !dbg !62 - %5 = call i1 @integer_eq_integer(%Integer %3, %Integer %4), !dbg !62 - %"$tmp@1137" = alloca i1, align 1, !dbg !62 - store i1 %5, ptr %"$tmp@1137", align 1, !dbg !62 - %6 = load i1, ptr %"$tmp@1137", align 1, !dbg !62 - store i1 %6, ptr %return_value, align 1, !dbg !62 - br label %return, !dbg !62 + %2 = load ptr, ptr %array, align 8, !dbg !60 + %size = getelementptr inbounds %"Array", ptr %2, i32 0, i32 0, !dbg !60 + %3 = call %Integer @clone_integer(ptr %size), !dbg !60 + %4 = call %Integer @integer_from_i64(i64 0), !dbg !60 + %5 = call i1 @integer_eq_integer(%Integer %3, %Integer %4), !dbg !60 + %"$tmp@1206" = alloca i1, align 1, !dbg !60 + store i1 %5, ptr %"$tmp@1206", align 1, !dbg !60 + %6 = load i1, ptr %"$tmp@1206", align 1, !dbg !60 + store i1 %6, ptr %return_value, align 1, !dbg !60 + br label %return, !dbg !60 return: ; preds = %1 %7 = load i1, ptr %return_value, align 1 @@ -458,193 +438,164 @@ return: ; preds = %1 declare i1 @integer_eq_integer(%Integer, %Integer) -define private void @"push <:Integer> to <:ReferenceMut>>"(%Integer %0, ptr %1) !dbg !63 { +define private void @"push <:Integer> to <:ReferenceMut>>"(%Integer %0, ptr %1) !dbg !61 { %x = alloca %Integer, align 8 store %Integer %0, ptr %x, align 8 %array = alloca ptr, align 8 store ptr %1, ptr %array, align 8 - br label %if.condition, !dbg !64 + %3 = load %"Type", ptr @"Type", align 8, !dbg !62 + %4 = call %Integer @"size of <:Type>"(%"Type" %3), !dbg !62 + %bytes = alloca %Integer, align 8, !dbg !62 + store %Integer %4, ptr %bytes, align 8, !dbg !62 + br label %if.condition, !dbg !62 if.condition: ; preds = %2 - %3 = load ptr, ptr %array, align 8, !dbg !64 - %size4 = getelementptr inbounds %"Array", ptr %3, i32 0, i32 0, !dbg !64 - %4 = call %Integer @clone_integer(ptr %size4), !dbg !64 - %5 = load ptr, ptr %array, align 8, !dbg !64 - %capacity5 = getelementptr inbounds %"Array", ptr %5, i32 0, i32 1, !dbg !64 - %6 = call %Integer @clone_integer(ptr %capacity5), !dbg !64 - %7 = call i1 @integer_eq_integer(%Integer %4, %Integer %6), !dbg !64 - br i1 %7, label %if.body, label %16, !dbg !64 + %5 = load ptr, ptr %array, align 8, !dbg !62 + %size5 = getelementptr inbounds %"Array", ptr %5, i32 0, i32 0, !dbg !62 + %6 = call %Integer @clone_integer(ptr %size5), !dbg !62 + %7 = load ptr, ptr %array, align 8, !dbg !62 + %capacity6 = getelementptr inbounds %"Array", ptr %7, i32 0, i32 1, !dbg !62 + %8 = call %Integer @clone_integer(ptr %capacity6), !dbg !62 + %9 = call i1 @integer_eq_integer(%Integer %6, %Integer %8), !dbg !62 + br i1 %9, label %if.body, label %18, !dbg !62 if.body: ; preds = %if.condition - %8 = load ptr, ptr %array, align 8, !dbg !64 - %capacity = getelementptr inbounds %"Array", ptr %8, i32 0, i32 1, !dbg !64 - %9 = call %Integer @clone_integer(ptr %capacity), !dbg !64 - %10 = call %Integer @integer_from_i64(i64 2), !dbg !64 - %11 = call %Integer @integer_star_integer(%Integer %9, %Integer %10), !dbg !64 - %new_capacity = alloca %Integer, align 8, !dbg !64 - store %Integer %11, ptr %new_capacity, align 8, !dbg !64 - %12 = call %Integer @clone_integer(ptr %new_capacity), !dbg !64 - %13 = load %"Type", ptr @"Type", align 8, !dbg !64 - %14 = call %MemoryAddress @"allocate <:Integer> <:Type>"(%Integer %12, %"Type" %13), !dbg !64 - %new_data = alloca %MemoryAddress, align 8, !dbg !64 - store %MemoryAddress %14, ptr %new_data, align 8, !dbg !64 - %15 = call %Integer @integer_from_i64(i64 0), !dbg !64 - %i = alloca %Integer, align 8, !dbg !64 - store %Integer %15, ptr %i, align 8, !dbg !64 - br label %while.condition, !dbg !64 - -return: ; preds = %16 + %10 = load ptr, ptr %array, align 8, !dbg !62 + %capacity = getelementptr inbounds %"Array", ptr %10, i32 0, i32 1, !dbg !62 + %11 = call %Integer @clone_integer(ptr %capacity), !dbg !62 + %12 = call %Integer @integer_from_i64(i64 2), !dbg !62 + %13 = call %Integer @integer_star_integer(%Integer %11, %Integer %12), !dbg !62 + %new_capacity = alloca %Integer, align 8, !dbg !62 + store %Integer %13, ptr %new_capacity, align 8, !dbg !62 + %14 = call %Integer @clone_integer(ptr %new_capacity), !dbg !62 + %15 = load %"Type", ptr @"Type", align 8, !dbg !62 + %16 = call %MemoryAddress @"allocate <:Integer> <:Type>"(%Integer %14, %"Type" %15), !dbg !62 + %new_data = alloca %MemoryAddress, align 8, !dbg !62 + store %MemoryAddress %16, ptr %new_data, align 8, !dbg !62 + %17 = call %Integer @integer_from_i64(i64 0), !dbg !62 + %i = alloca %Integer, align 8, !dbg !62 + store %Integer %17, ptr %i, align 8, !dbg !62 + br label %while.condition, !dbg !62 + +return: ; preds = %18 ret void -16: ; preds = %if.condition, %48 - %17 = load %"Type", ptr @"Type", align 8, !dbg !64 - %18 = load ptr, ptr %array, align 8, !dbg !64 - %data6 = getelementptr inbounds %"Array", ptr %18, i32 0, i32 2, !dbg !64 - %19 = load %MemoryAddress, ptr %data6, align 8, !dbg !64 - %20 = load ptr, ptr %array, align 8, !dbg !64 - %size7 = getelementptr inbounds %"Array", ptr %20, i32 0, i32 0, !dbg !64 - %21 = call %Integer @clone_integer(ptr %size7), !dbg !64 - %22 = call %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress %19, %Integer %21), !dbg !64 - %23 = call ptr @read_memory(%"Type" %17, %MemoryAddress %22), !dbg !64 - %value8 = alloca ptr, align 8, !dbg !64 - store ptr %23, ptr %value8, align 8, !dbg !64 - %24 = load ptr, ptr %value8, align 8, !dbg !64 - %25 = load %Integer, ptr %x, align 8, !dbg !64 - store %Integer %25, ptr %24, align 8, !dbg !64 - %26 = load ptr, ptr %array, align 8, !dbg !64 - %size9 = getelementptr inbounds %"Array", ptr %26, i32 0, i32 0, !dbg !64 - call void @destroy_integer(ptr %size9), !dbg !64 - %27 = load ptr, ptr %array, align 8, !dbg !64 - %size10 = getelementptr inbounds %"Array", ptr %27, i32 0, i32 0, !dbg !64 - %28 = load ptr, ptr %array, align 8, !dbg !64 - %size11 = getelementptr inbounds %"Array", ptr %28, i32 0, i32 0, !dbg !64 - %29 = call %Integer @clone_integer(ptr %size11), !dbg !64 - %30 = call %Integer @integer_from_i64(i64 1), !dbg !64 - %31 = call %Integer @integer_plus_integer(%Integer %29, %Integer %30), !dbg !64 - store %Integer %31, ptr %size10, align 8, !dbg !64 - br label %return, !dbg !64 +18: ; preds = %if.condition, %44 + %19 = call %MemoryAddress @address_of(ptr %x), !dbg !62 + %"$tmp@1100" = alloca %MemoryAddress, align 8, !dbg !62 + store %MemoryAddress %19, ptr %"$tmp@1100", align 8, !dbg !62 + %20 = load ptr, ptr %array, align 8, !dbg !62 + %data7 = getelementptr inbounds %"Array", ptr %20, i32 0, i32 2, !dbg !62 + %21 = load %MemoryAddress, ptr %data7, align 8, !dbg !62 + %22 = load ptr, ptr %array, align 8, !dbg !62 + %size8 = getelementptr inbounds %"Array", ptr %22, i32 0, i32 0, !dbg !62 + %23 = call %Integer @clone_integer(ptr %size8), !dbg !62 + %24 = call %Integer @clone_integer(ptr %bytes), !dbg !62 + %25 = call %Integer @integer_star_integer(%Integer %23, %Integer %24), !dbg !62 + %26 = call %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress %21, %Integer %25), !dbg !62 + %"$tmp@1118" = alloca %MemoryAddress, align 8, !dbg !62 + store %MemoryAddress %26, ptr %"$tmp@1118", align 8, !dbg !62 + call void @copy_bytes(ptr %bytes, ptr %"$tmp@1100", ptr %"$tmp@1118"), !dbg !62 + %27 = load ptr, ptr %array, align 8, !dbg !62 + %size9 = getelementptr inbounds %"Array", ptr %27, i32 0, i32 0, !dbg !62 + %28 = call %Integer @integer_from_i64(i64 1), !dbg !62 + call void @"<:ReferenceMut> += <:Integer>"(ptr %size9, %Integer %28), !dbg !62 + call void @destroy_integer(ptr %bytes), !dbg !62 + br label %return, !dbg !62 while.condition: ; preds = %while.body, %if.body - %32 = call %Integer @clone_integer(ptr %i), !dbg !64 - %33 = load ptr, ptr %array, align 8, !dbg !64 - %size = getelementptr inbounds %"Array", ptr %33, i32 0, i32 0, !dbg !64 - %34 = call %Integer @clone_integer(ptr %size), !dbg !64 - %35 = call i1 @integer_less_integer(%Integer %32, %Integer %34), !dbg !64 - br i1 %35, label %while.body, label %48, !dbg !64 + %29 = call %Integer @clone_integer(ptr %i), !dbg !62 + %30 = load ptr, ptr %array, align 8, !dbg !62 + %size = getelementptr inbounds %"Array", ptr %30, i32 0, i32 0, !dbg !62 + %31 = call %Integer @clone_integer(ptr %size), !dbg !62 + %32 = call i1 @integer_less_integer(%Integer %29, %Integer %31), !dbg !62 + br i1 %32, label %while.body, label %44, !dbg !62 while.body: ; preds = %while.condition - %36 = load %"Type", ptr @"Type", align 8, !dbg !64 - %37 = load %MemoryAddress, ptr %new_data, align 8, !dbg !64 - %38 = call %Integer @clone_integer(ptr %i), !dbg !64 - %39 = call %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress %37, %Integer %38), !dbg !64 - %40 = call ptr @read_memory(%"Type" %36, %MemoryAddress %39), !dbg !64 - %value = alloca ptr, align 8, !dbg !64 - store ptr %40, ptr %value, align 8, !dbg !64 - %41 = load ptr, ptr %value, align 8, !dbg !64 - %42 = call %Integer @clone_integer(ptr %i), !dbg !64 - %43 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr %array, %Integer %42), !dbg !64 - %44 = load %Integer, ptr %43, align 8, !dbg !64 - store %Integer %44, ptr %41, align 8, !dbg !64 - call void @destroy_integer(ptr %i), !dbg !64 - %45 = call %Integer @clone_integer(ptr %i), !dbg !64 - %46 = call %Integer @integer_from_i64(i64 1), !dbg !64 - %47 = call %Integer @integer_plus_integer(%Integer %45, %Integer %46), !dbg !64 - store %Integer %47, ptr %i, align 8, !dbg !64 - br label %while.condition, !dbg !64 - -48: ; preds = %while.condition - %49 = load ptr, ptr %array, align 8, !dbg !64 - %data = getelementptr inbounds %"Array", ptr %49, i32 0, i32 2, !dbg !64 - %50 = load %MemoryAddress, ptr %data, align 8, !dbg !64 - call void @free_memory(%MemoryAddress %50), !dbg !64 - %51 = load ptr, ptr %array, align 8, !dbg !64 - %data1 = getelementptr inbounds %"Array", ptr %51, i32 0, i32 2, !dbg !64 - %52 = load %MemoryAddress, ptr %new_data, align 8, !dbg !64 - store %MemoryAddress %52, ptr %data1, align 8, !dbg !64 - %53 = load ptr, ptr %array, align 8, !dbg !64 - %capacity2 = getelementptr inbounds %"Array", ptr %53, i32 0, i32 1, !dbg !64 - call void @destroy_integer(ptr %capacity2), !dbg !64 - %54 = load ptr, ptr %array, align 8, !dbg !64 - %capacity3 = getelementptr inbounds %"Array", ptr %54, i32 0, i32 1, !dbg !64 - %55 = call %Integer @clone_integer(ptr %new_capacity), !dbg !64 - store %Integer %55, ptr %capacity3, align 8, !dbg !64 - call void @destroy_integer(ptr %new_capacity), !dbg !64 - call void @destroy_integer(ptr %i), !dbg !64 - br label %16, !dbg !64 + %33 = call %Integer @clone_integer(ptr %i), !dbg !62 + %34 = call %Integer @clone_integer(ptr %bytes), !dbg !62 + %35 = call %Integer @integer_star_integer(%Integer %33, %Integer %34), !dbg !62 + %offset = alloca %Integer, align 8, !dbg !62 + store %Integer %35, ptr %offset, align 8, !dbg !62 + %36 = load ptr, ptr %array, align 8, !dbg !62 + %data = getelementptr inbounds %"Array", ptr %36, i32 0, i32 2, !dbg !62 + %37 = load %MemoryAddress, ptr %data, align 8, !dbg !62 + %38 = call %Integer @clone_integer(ptr %offset), !dbg !62 + %39 = call %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress %37, %Integer %38), !dbg !62 + %"$tmp@947" = alloca %MemoryAddress, align 8, !dbg !62 + store %MemoryAddress %39, ptr %"$tmp@947", align 8, !dbg !62 + %40 = load %MemoryAddress, ptr %new_data, align 8, !dbg !62 + %41 = call %Integer @clone_integer(ptr %offset), !dbg !62 + %42 = call %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress %40, %Integer %41), !dbg !62 + %"$tmp@972" = alloca %MemoryAddress, align 8, !dbg !62 + store %MemoryAddress %42, ptr %"$tmp@972", align 8, !dbg !62 + call void @copy_bytes(ptr %bytes, ptr %"$tmp@947", ptr %"$tmp@972"), !dbg !62 + %43 = call %Integer @integer_from_i64(i64 1), !dbg !62 + call void @"<:ReferenceMut> += <:Integer>"(ptr %i, %Integer %43), !dbg !62 + call void @destroy_integer(ptr %offset), !dbg !62 + br label %while.condition, !dbg !62 + +44: ; preds = %while.condition + %45 = load ptr, ptr %array, align 8, !dbg !62 + %data1 = getelementptr inbounds %"Array", ptr %45, i32 0, i32 2, !dbg !62 + call void @free_memory(ptr %data1), !dbg !62 + %46 = load ptr, ptr %array, align 8, !dbg !62 + %data2 = getelementptr inbounds %"Array", ptr %46, i32 0, i32 2, !dbg !62 + %47 = load %MemoryAddress, ptr %new_data, align 8, !dbg !62 + store %MemoryAddress %47, ptr %data2, align 8, !dbg !62 + %48 = load ptr, ptr %array, align 8, !dbg !62 + %capacity3 = getelementptr inbounds %"Array", ptr %48, i32 0, i32 1, !dbg !62 + call void @destroy_integer(ptr %capacity3), !dbg !62 + %49 = load ptr, ptr %array, align 8, !dbg !62 + %capacity4 = getelementptr inbounds %"Array", ptr %49, i32 0, i32 1, !dbg !62 + %50 = call %Integer @clone_integer(ptr %new_capacity), !dbg !62 + store %Integer %50, ptr %capacity4, align 8, !dbg !62 + call void @destroy_integer(ptr %new_capacity), !dbg !62 + call void @destroy_integer(ptr %i), !dbg !62 + br label %18, !dbg !62 } -declare void @free_memory(%MemoryAddress) +declare void @copy_bytes(ptr, ptr, ptr) -define private void @"println <:Integer>"(%Integer %0) !dbg !65 { - %x = alloca %Integer, align 8 - store %Integer %0, ptr %x, align 8 - %2 = load %Integer, ptr %x, align 8, !dbg !66 - %3 = call %String @integer_as_string(%Integer %2), !dbg !66 - call void @"println <:String>"(%String %3), !dbg !66 - br label %return, !dbg !67 +declare void @free_memory(ptr) -return: ; preds = %1 - ret void -} - -define private ptr @"value from <:Reference>>"(ptr %0) !dbg !68 { - %return_value = alloca ptr, align 8 - %it = alloca ptr, align 8 - store ptr %0, ptr %it, align 8 - %2 = load ptr, ptr %it, align 8, !dbg !69 - %array = getelementptr inbounds %"Iterator", ptr %2, i32 0, i32 0, !dbg !69 - %3 = load ptr, ptr %it, align 8, !dbg !69 - %index = getelementptr inbounds %"Iterator", ptr %3, i32 0, i32 1, !dbg !69 - %4 = call %Integer @clone_integer(ptr %index), !dbg !69 - %5 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr %array, %Integer %4), !dbg !69 - %"$tmp@1886" = alloca ptr, align 8, !dbg !69 - store ptr %5, ptr %"$tmp@1886", align 8, !dbg !69 - %6 = load ptr, ptr %"$tmp@1886", align 8, !dbg !69 - store ptr %6, ptr %return_value, align 8, !dbg !69 - br label %return, !dbg !69 - -return: ; preds = %1 - %7 = load ptr, ptr %return_value, align 8 - ret ptr %7 -} +declare %MemoryAddress @address_of(ptr) -define private void @"advance <:ReferenceMut>>"(ptr %0) !dbg !70 { - %it = alloca ptr, align 8 - store ptr %0, ptr %it, align 8 - %2 = load ptr, ptr %it, align 8, !dbg !71 - %index = getelementptr inbounds %"Iterator", ptr %2, i32 0, i32 1, !dbg !71 - %3 = call %Integer @integer_from_i64(i64 1), !dbg !71 - call void @"<:ReferenceMut> += <:Integer>"(ptr %index, %Integer %3), !dbg !71 - br label %return, !dbg !71 +define private void @"println <:Integer>"(%Integer %0) !dbg !63 { + %x = alloca %Integer, align 8 + store %Integer %0, ptr %x, align 8 + %2 = load %Integer, ptr %x, align 8, !dbg !64 + %3 = call %String @integer_as_string(%Integer %2), !dbg !64 + call void @"println <:String>"(%String %3), !dbg !64 + br label %return, !dbg !65 return: ; preds = %1 ret void } -define private i1 @"<:Reference>> exists"(ptr %0) !dbg !72 { +define private i1 @"<:Integer> <= <:Integer>"(%Integer %0, %Integer %1) !dbg !66 { %return_value = alloca i1, align 1 - %it = alloca ptr, align 8 - store ptr %0, ptr %it, align 8 - %2 = load ptr, ptr %it, align 8, !dbg !73 - %index = getelementptr inbounds %"Iterator", ptr %2, i32 0, i32 1, !dbg !73 - %3 = call %Integer @clone_integer(ptr %index), !dbg !73 - %4 = load ptr, ptr %it, align 8, !dbg !73 - %array = getelementptr inbounds %"Iterator", ptr %4, i32 0, i32 0, !dbg !73 - %5 = load ptr, ptr %array, align 8, !dbg !73 - %size = getelementptr inbounds %"Array", ptr %5, i32 0, i32 0, !dbg !73 - %6 = call %Integer @clone_integer(ptr %size), !dbg !73 - %7 = call i1 @integer_less_integer(%Integer %3, %Integer %6), !dbg !73 - %"$tmp@1755" = alloca i1, align 1, !dbg !73 - store i1 %7, ptr %"$tmp@1755", align 1, !dbg !73 - %8 = load i1, ptr %"$tmp@1755", align 1, !dbg !73 - store i1 %8, ptr %return_value, align 1, !dbg !73 - br label %return, !dbg !73 + %x = alloca %Integer, align 8 + store %Integer %0, ptr %x, align 8 + %y = alloca %Integer, align 8 + store %Integer %1, ptr %y, align 8 + %3 = load %Integer, ptr %x, align 8, !dbg !67 + %4 = load %Integer, ptr %y, align 8, !dbg !67 + %5 = call i1 @"<:Integer> > <:Integer>"(%Integer %3, %Integer %4), !dbg !67 + %6 = call i1 @"not <:Bool>"(i1 %5), !dbg !67 + %"$tmp@1068" = alloca i1, align 1, !dbg !67 + store i1 %6, ptr %"$tmp@1068", align 1, !dbg !67 + %7 = load i1, ptr %"$tmp@1068", align 1, !dbg !67 + store i1 %7, ptr %return_value, align 1, !dbg !67 + br label %return, !dbg !67 -return: ; preds = %1 - %9 = load i1, ptr %return_value, align 1 - ret i1 %9 +return: ; preds = %2 + %8 = load i1, ptr %return_value, align 1 + ret i1 %8 } +declare i1 @"not <:Bool>"(i1) + !llvm.module.flags = !{!0} !llvm.dbg.cu = !{!1} @@ -663,7 +614,7 @@ return: ; preds = %1 !12 = distinct !DISubprogram(name: "main.execute", linkageName: "main.execute", scope: !2, file: !2, type: !4, spFlags: DISPFlagDefinition, unit: !1) !13 = !DILocation(line: 7, column: 18, scope: !12) !14 = !DILocation(line: 0, column: 14, scope: !12) -!15 = !DILocation(line: 10, column: 13, scope: !12) +!15 = !DILocation(line: 10, column: 12, scope: !12) !16 = !DILocation(line: 1, column: 8, scope: !12) !17 = !DILocation(line: 3, column: 9, scope: !12) !18 = !DILocation(line: 2, column: 3, scope: !12) @@ -674,51 +625,45 @@ return: ; preds = %1 !23 = !DILocation(line: 6, column: 3, scope: !12) !24 = !DILocation(line: 8, column: 12, scope: !12) !25 = !DILocation(line: 11, column: 6, scope: !12) -!26 = !DILocation(line: 12, column: 21, scope: !12) -!27 = !DILocation(line: 13, column: 9, scope: !12) -!28 = distinct !DISubprogram(name: "initialize.2", linkageName: "initialize.2", scope: !12, file: !2, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!29 = !DILocation(line: 0, column: 14, scope: !28) -!30 = distinct !DISubprogram(name: "<:Type> [ ]", linkageName: "<:Type> [ ]", scope: !28, file: !2, line: 10, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!31 = !DILocation(line: 12, column: 17, scope: !30) -!32 = !DILocation(line: 13, column: 11, scope: !30) -!33 = !DILocation(line: 12, column: 2, scope: !30) -!34 = distinct !DISubprogram(name: "allocate <:Integer> <:Type>", linkageName: "allocate <:Integer> <:Type>", scope: !30, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!35 = !DILocation(line: 13, column: 11, scope: !34) -!36 = distinct !DISubprogram(name: "size of <:Type>", linkageName: "size of <:Type>", scope: !34, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!37 = !DILocation(line: 13, column: 11, scope: !36) -!38 = distinct !DISubprogram(name: "initialize.3", linkageName: "initialize.3", scope: !12, file: !2, line: 10, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!39 = !DILocation(line: 10, column: 26, scope: !38) -!40 = distinct !DISubprogram(name: "iterator for <:Reference>>", linkageName: "iterator for <:Reference>>", scope: !38, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!41 = !DILocation(line: 13, column: 11, scope: !40) -!42 = distinct !DISubprogram(name: "println <:Array>", linkageName: "println <:Array>", scope: !12, file: !2, line: 8, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!43 = !DILocation(line: 11, column: 13, scope: !42) -!44 = !DILocation(line: 10, column: 22, scope: !42) -!45 = distinct !DISubprogram(name: "String from <:Reference>>", linkageName: "String from <:Reference>>", scope: !42, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!46 = !DILocation(line: 13, column: 11, scope: !45) -!47 = distinct !DISubprogram(name: "<:ReferenceMut> += <:String>", linkageName: "<:ReferenceMut> += <:String>", scope: !45, file: !2, line: 10, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!48 = !DILocation(line: 12, column: 22, scope: !47) -!49 = !DILocation(line: 13, column: 4, scope: !47) -!50 = !DILocation(line: 13, column: 11, scope: !47) -!51 = distinct !DISubprogram(name: "<:Reference>> [ <:Integer> ]", linkageName: "<:Reference>> [ <:Integer> ]", scope: !45, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!52 = !DILocation(line: 13, column: 11, scope: !51) -!53 = distinct !DISubprogram(name: "<:ReferenceMut> += <:Integer>", linkageName: "<:ReferenceMut> += <:Integer>", scope: !45, file: !2, line: 10, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!54 = !DILocation(line: 12, column: 22, scope: !53) -!55 = !DILocation(line: 13, column: 4, scope: !53) -!56 = !DILocation(line: 13, column: 11, scope: !53) -!57 = distinct !DISubprogram(name: "<:Reference>> is not empty", linkageName: "<:Reference>> is not empty", scope: !45, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!58 = !DILocation(line: 13, column: 11, scope: !57) -!59 = distinct !DISubprogram(name: "<:Integer> > <:Integer>", linkageName: "<:Integer> > <:Integer>", scope: !57, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!60 = !DILocation(line: 13, column: 11, scope: !59) -!61 = distinct !DISubprogram(name: "<:Reference>> is empty", linkageName: "<:Reference>> is empty", scope: !12, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!62 = !DILocation(line: 13, column: 11, scope: !61) -!63 = distinct !DISubprogram(name: "push <:Integer> to <:ReferenceMut>>", linkageName: "push <:Integer> to <:ReferenceMut>>", scope: !12, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!64 = !DILocation(line: 13, column: 11, scope: !63) -!65 = distinct !DISubprogram(name: "println <:Integer>", linkageName: "println <:Integer>", scope: !12, file: !2, line: 8, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!66 = !DILocation(line: 11, column: 13, scope: !65) -!67 = !DILocation(line: 10, column: 22, scope: !65) -!68 = distinct !DISubprogram(name: "value from <:Reference>>", linkageName: "value from <:Reference>>", scope: !12, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!69 = !DILocation(line: 13, column: 11, scope: !68) -!70 = distinct !DISubprogram(name: "advance <:ReferenceMut>>", linkageName: "advance <:ReferenceMut>>", scope: !12, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!71 = !DILocation(line: 13, column: 11, scope: !70) -!72 = distinct !DISubprogram(name: "<:Reference>> exists", linkageName: "<:Reference>> exists", scope: !12, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!73 = !DILocation(line: 13, column: 11, scope: !72) +!26 = !DILocation(line: 11, column: 11, scope: !12) +!27 = !DILocation(line: 12, column: 6, scope: !12) +!28 = !DILocation(line: 12, column: 11, scope: !12) +!29 = !DILocation(line: 13, column: 6, scope: !12) +!30 = !DILocation(line: 14, column: 9, scope: !12) +!31 = !DILocation(line: 10, scope: !12) +!32 = distinct !DISubprogram(name: "initialize.2", linkageName: "initialize.2", scope: !12, file: !2, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!33 = !DILocation(line: 0, column: 14, scope: !32) +!34 = distinct !DISubprogram(name: "<:Type> [ ]", linkageName: "<:Type> [ ]", scope: !32, file: !2, line: 11, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!35 = !DILocation(line: 14, column: 12, scope: !34) +!36 = !DILocation(line: 15, scope: !34) +!37 = !DILocation(line: 13, column: 5, scope: !34) +!38 = distinct !DISubprogram(name: "allocate <:Integer> <:Type>", linkageName: "allocate <:Integer> <:Type>", scope: !34, file: !2, line: 15, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!39 = !DILocation(line: 15, scope: !38) +!40 = distinct !DISubprogram(name: "size of <:Type>", linkageName: "size of <:Type>", scope: !38, file: !2, line: 15, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!41 = !DILocation(line: 15, scope: !40) +!42 = distinct !DISubprogram(name: "initialize.3", linkageName: "initialize.3", scope: !12, file: !2, line: 10, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!43 = !DILocation(line: 10, column: 12, scope: !42) +!44 = distinct !DISubprogram(name: "println <:Array>", linkageName: "println <:Array>", scope: !12, file: !2, line: 8, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!45 = !DILocation(line: 12, column: 14, scope: !44) +!46 = !DILocation(line: 11, column: 8, scope: !44) +!47 = distinct !DISubprogram(name: "String from <:Array>", linkageName: "String from <:Array>", scope: !44, file: !2, line: 15, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!48 = !DILocation(line: 15, scope: !47) +!49 = distinct !DISubprogram(name: "<:ReferenceMut> += <:String>", linkageName: "<:ReferenceMut> += <:String>", scope: !47, file: !2, line: 11, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!50 = !DILocation(line: 15, scope: !49) +!51 = distinct !DISubprogram(name: "<:Reference>> [ <:Integer> ]", linkageName: "<:Reference>> [ <:Integer> ]", scope: !47, file: !2, line: 15, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!52 = !DILocation(line: 15, scope: !51) +!53 = distinct !DISubprogram(name: "<:ReferenceMut> += <:Integer>", linkageName: "<:ReferenceMut> += <:Integer>", scope: !47, file: !2, line: 11, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!54 = !DILocation(line: 15, scope: !53) +!55 = distinct !DISubprogram(name: "<:Reference>> is not empty", linkageName: "<:Reference>> is not empty", scope: !47, file: !2, line: 15, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!56 = !DILocation(line: 15, scope: !55) +!57 = distinct !DISubprogram(name: "<:Integer> > <:Integer>", linkageName: "<:Integer> > <:Integer>", scope: !55, file: !2, line: 15, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!58 = !DILocation(line: 15, scope: !57) +!59 = distinct !DISubprogram(name: "<:Reference>> is empty", linkageName: "<:Reference>> is empty", scope: !12, file: !2, line: 15, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!60 = !DILocation(line: 15, scope: !59) +!61 = distinct !DISubprogram(name: "push <:Integer> to <:ReferenceMut>>", linkageName: "push <:Integer> to <:ReferenceMut>>", scope: !12, file: !2, line: 15, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!62 = !DILocation(line: 15, scope: !61) +!63 = distinct !DISubprogram(name: "println <:Integer>", linkageName: "println <:Integer>", scope: !12, file: !2, line: 8, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!64 = !DILocation(line: 12, column: 14, scope: !63) +!65 = !DILocation(line: 11, column: 8, scope: !63) +!66 = distinct !DISubprogram(name: "<:Integer> <= <:Integer>", linkageName: "<:Integer> <= <:Integer>", scope: !12, file: !2, line: 15, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!67 = !DILocation(line: 15, scope: !66) diff --git a/src/tests/snapshots/ppl__tests__array.run.snap b/src/tests/snapshots/ppl__tests__array.run.snap index 0e3fda8a..5a857f57 100644 --- a/src/tests/snapshots/ppl__tests__array.run.snap +++ b/src/tests/snapshots/ppl__tests__array.run.snap @@ -2,6 +2,17 @@ source: src/tests/mod.rs expression: run_log --- +[] Empty +[1] Not empty 1 +[1, 2] +[1, 2, 3] +[1, 2, 3, 4] +[1, 2, 3, 4, 5] +[1, 2, 3, 4, 5, 6] +[1, 2, 3, 4, 5, 6, 7] +[1, 2, 3, 4, 5, 6, 7, 8] +[1, 2, 3, 4, 5, 6, 7, 8, 9] +[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] diff --git a/src/tests/snapshots/ppl__tests__memory.hir.snap b/src/tests/snapshots/ppl__tests__memory.hir.snap index cc8ead12..bac5c69e 100644 --- a/src/tests/snapshots/ppl__tests__memory.hir.snap +++ b/src/tests/snapshots/ppl__tests__memory.hir.snap @@ -3,7 +3,7 @@ source: src/tests/mod.rs expression: hir --- let address: MemoryAddress = `allocate <:Integer> <:Type>`(1, (Type:Type)) -let x: ReferenceMut = `<:Type> at <:MemoryAddress>`((Type:Type), (address:MemoryAddress)) +let x: ReferenceMut = `<:Type> at <:Reference>`((Type:Type), (&address:Reference)) (x:ReferenceMut) = 0 `println <:Integer>`(`clone <:Reference>`((*x:Integer))) (x:ReferenceMut) = 1 @@ -24,7 +24,7 @@ fn allocate <$arg1: Type> -> MemoryAddress: @mangle_as("read_memory") -fn > at -> ReferenceMut +fn > at > -> ReferenceMut @mangle_as("integer_as_string") fn String from <$arg0: Integer> -> String diff --git a/src/tests/snapshots/ppl__tests__memory.ir.snap b/src/tests/snapshots/ppl__tests__memory.ir.snap index ee444692..10f6b780 100644 --- a/src/tests/snapshots/ppl__tests__memory.ir.snap +++ b/src/tests/snapshots/ppl__tests__memory.ir.snap @@ -138,16 +138,15 @@ declare void @destroy_integer(ptr) define private void @initialize.3() !dbg !30 { %1 = load %"Type", ptr @"Type", align 8, !dbg !31 - %2 = load %MemoryAddress, ptr @address, align 8, !dbg !32 - %3 = call ptr @read_memory(%"Type" %1, %MemoryAddress %2), !dbg !32 - store ptr %3, ptr @x, align 8, !dbg !32 + %2 = call ptr @read_memory(%"Type" %1, ptr @address), !dbg !32 + store ptr %2, ptr @x, align 8, !dbg !32 br label %return, !dbg !32 return: ; preds = %0 ret void } -declare ptr @read_memory(%"Type", %MemoryAddress) +declare ptr @read_memory(%"Type", ptr) define private void @"println <:Integer>"(%Integer %0) !dbg !33 { %x = alloca %Integer, align 8 diff --git a/src/tests/snapshots/ppl__tests__references.hir.snap b/src/tests/snapshots/ppl__tests__references.hir.snap index ffe0e256..2059d858 100644 --- a/src/tests/snapshots/ppl__tests__references.hir.snap +++ b/src/tests/snapshots/ppl__tests__references.hir.snap @@ -4,12 +4,12 @@ expression: hir --- let n: Integer = `size of <:Type>`((Type:Type)) let address: MemoryAddress = `allocate <:Integer> bytes`(`clone <:Reference>`((n:Integer))) -let value: ReferenceMut = `<:Type> at <:MemoryAddress>`((Type:Type), (address:MemoryAddress)) +let value: ReferenceMut = `<:Type> at <:Reference>`((Type:Type), (&address:Reference)) (value:ReferenceMut) = `<:Integer> as I32`(0) `println <:I32>`((*value:I32)) (value:ReferenceMut) = `<:Integer> as I32`(1) `println <:I32>`((*value:I32)) -`free <:MemoryAddress>`((address:MemoryAddress)) +`free <:Reference>`((&address:Reference)) `destroy <:ReferenceMut>`((n:Integer)) ==MONOMORPHIZED== @@ -21,7 +21,7 @@ fn size of > -> Integer: @mangle_as("read_memory") -fn > at -> ReferenceMut +fn > at > -> ReferenceMut @mangle_as("i32_as_string") fn String from <$arg0: I32> -> String diff --git a/src/tests/snapshots/ppl__tests__references.ir.snap b/src/tests/snapshots/ppl__tests__references.ir.snap index a8b7b8df..4be64d70 100644 --- a/src/tests/snapshots/ppl__tests__references.ir.snap +++ b/src/tests/snapshots/ppl__tests__references.ir.snap @@ -75,8 +75,7 @@ define void @main.execute() !dbg !12 { %9 = load ptr, ptr @value, align 8, !dbg !23 %10 = load i32, ptr %9, align 4, !dbg !23 call void @"println <:I32>"(i32 %10), !dbg !23 - %11 = load %MemoryAddress, ptr @address, align 8, !dbg !24 - call void @free_memory(%MemoryAddress %11), !dbg !24 + call void @free_memory(ptr @address), !dbg !24 call void @destroy_integer(ptr @n), !dbg !25 br label %return, !dbg !25 @@ -127,16 +126,15 @@ declare %MemoryAddress @allocate_n_bytes(%Integer) define private void @initialize.4() !dbg !32 { %1 = load %"Type", ptr @"Type", align 8, !dbg !33 - %2 = load %MemoryAddress, ptr @address, align 8, !dbg !34 - %3 = call ptr @read_memory(%"Type" %1, %MemoryAddress %2), !dbg !34 - store ptr %3, ptr @value, align 8, !dbg !34 + %2 = call ptr @read_memory(%"Type" %1, ptr @address), !dbg !34 + store ptr %2, ptr @value, align 8, !dbg !34 br label %return, !dbg !34 return: ; preds = %0 ret void } -declare ptr @read_memory(%"Type", %MemoryAddress) +declare ptr @read_memory(%"Type", ptr) declare i32 @integer_as_i32(%Integer) @@ -156,7 +154,7 @@ declare void @"println <:String>"(%String) declare %String @i32_as_string(i32) -declare void @free_memory(%MemoryAddress) +declare void @free_memory(ptr) declare void @destroy_integer(ptr)