From 4ee71b6e5a21c83f5136138f25b8e46208a7f343 Mon Sep 17 00:00:00 2001 From: Gavrilikhin Daniil Date: Thu, 16 May 2024 20:29:30 +0800 Subject: [PATCH 1/2] Fix array a little --- ppl/src/array.ppl | 6 +- 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 | 272 ++++-- src/tests/snapshots/ppl__tests__array.ir.snap | 789 ++++++++---------- .../snapshots/ppl__tests__array.run.snap | 2 + .../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, 602 insertions(+), 561 deletions(-) diff --git a/ppl/src/array.ppl b/ppl/src/array.ppl index e1181af8..6b1d584c 100644 --- a/ppl/src/array.ppl +++ b/ppl/src/array.ppl @@ -36,20 +36,20 @@ fn push to >: let mut i = 0 while i < array.size: let value = T at (new_data + i * bytes) - value = array[i] + copy array[i] to value 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 x to value 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..84755350 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..7e29127d 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,38 @@ 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@1497: String = `clone <:Reference>`((str:String)) `destroy <:ReferenceMut>`((str:String)) - return ($tmp@1462:String) + return ($tmp@1497: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@1173: Bool = `<:Integer> == <:Integer>`(`clone <:Reference>`((*array:Array).size), 0) + return ($tmp@1173:Bool) + + +fn size of > -> Integer: + let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) + return ($tmp@4399:Integer) fn size of > -> Integer: @@ -87,10 +89,7 @@ fn allocate <$arg1: Type> -> MemoryAddress: @mangle_as("read_memory") -fn > at -> ReferenceMut - -@mangle_as("read_memory") -fn > at -> ReferenceMut +fn > at > -> ReferenceMut fn size of > -> Integer: let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) @@ -98,70 +97,117 @@ fn size of > -> Integer: @mangle_as("read_memory") -fn > at -> ReferenceMut +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)) + return `<:Type> at <:Reference>`((Type:Type), (&address:Reference)) + + +@mangle_as("read_memory") +fn > at > -> ReferenceMut + +@mangle_as("address_of") +fn address of > -> MemoryAddress + +@mangle_as("address_of") +fn address of > -> MemoryAddress + +fn size of > -> Integer: + let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) + return ($tmp@4399:Integer) + + +fn copy <:Type> from > to > -> None: + `copy <:Reference> bytes from <:Reference> to <:Reference>`((&`size of <:Type>`((Type:Type)):Reference), (src:Reference), (dst:Reference)) + + +fn copy > to > -> None: + let $tmp@1518: MemoryAddress = `address of <:Reference>`((src:Reference)) + let $tmp@1538: MemoryAddress = `address of <:Reference>`((dst:ReferenceMut)) + `copy <:Type> from <:Reference> to <:Reference>`((Type:Type), (&$tmp@1518:Reference), (&$tmp@1538:Reference)) @mangle_as("read_memory") -fn > at -> ReferenceMut +fn > at > -> ReferenceMut @mangle_as("read_memory") -fn > at -> ReferenceMut +fn > at > -> ReferenceMut + +@mangle_as("address_of") +fn address of > -> MemoryAddress + +@mangle_as("address_of") +fn address of > -> MemoryAddress + +fn size of > -> Integer: + let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) + return ($tmp@4399:Integer) + + +fn copy <:Type> from > to > -> None: + `copy <:Reference> bytes from <:Reference> to <:Reference>`((&`size of <:Type>`((Type:Type)):Reference), (src:Reference), (dst:Reference)) + + +fn copy > to > -> None: + let $tmp@1518: MemoryAddress = `address of <:Reference>`((src:Reference)) + let $tmp@1538: MemoryAddress = `address of <:Reference>`((dst:ReferenceMut)) + `copy <:Type> from <:Reference> to <:Reference>`((Type:Type), (&$tmp@1518:Reference), (&$tmp@1538:Reference)) + 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 $tmp@916: MemoryAddress = `<:MemoryAddress> + <:Integer>`((new_data:MemoryAddress), `<:Integer> * <:Integer>`(`clone <:Reference>`((i:Integer)), `clone <:Reference>`((bytes:Integer)))) + let value: ReferenceMut = `<:Type> at <:Reference>`((Type:Type), (&$tmp@916:Reference)) + `copy <:Reference> to <:ReferenceMut>`(`<:Reference>> [ <:Integer> ]`((array:ReferenceMut>), `clone <:Reference>`((i:Integer))), (value:ReferenceMut)) + `<:ReferenceMut> += <:Integer>`((&i:ReferenceMut), 1) - `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@1068: MemoryAddress = `<:MemoryAddress> + <:Integer>`((*array:Array).data, `<:Integer> * <:Integer>`(`clone <:Reference>`((*array:Array).size), `clone <:Reference>`((bytes:Integer)))) + let value: ReferenceMut = `<:Type> at <:Reference>`((Type:Type), (&$tmp@1068:Reference)) + `copy <:Reference> to <:ReferenceMut>`((&x:Reference), (value:ReferenceMut)) + `<: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@1497: String = `clone <:Reference>`((str:String)) `destroy <:ReferenceMut>`((str:String)) - return ($tmp@1462:String) + return ($tmp@1497: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@1230: Bool = `<:Integer> > <:Integer>`(`clone <:Reference>`((*array:Array).size), 0) + return ($tmp@1230:Bool) fn size of > -> Integer: @@ -170,14 +216,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,10 +237,24 @@ 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) +fn size of > -> Integer: + let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) + return ($tmp@4399:Integer) + + +fn size of > -> Integer: + let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) + 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 fn size of > -> Integer: let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) @@ -202,39 +262,115 @@ fn size of > -> Integer: @mangle_as("read_memory") -fn > at -> ReferenceMut +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)) + return `<:Type> at <:Reference>`((Type:Type), (&address:Reference)) +@mangle_as("read_memory") +fn > at > -> ReferenceMut + +@mangle_as("address_of") +fn address of > -> MemoryAddress + +@mangle_as("address_of") +fn address of > -> MemoryAddress + fn size of > -> Integer: let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) return ($tmp@4399:Integer) +fn copy <:Type> from > to > -> None: + `copy <:Reference> bytes from <:Reference> to <:Reference>`((&`size of <:Type>`((Type:Type)):Reference), (src:Reference), (dst:Reference)) + + +fn copy > to > -> None: + let $tmp@1518: MemoryAddress = `address of <:Reference>`((src:Reference)) + let $tmp@1538: MemoryAddress = `address of <:Reference>`((dst:ReferenceMut)) + `copy <:Type> from <:Reference> to <:Reference>`((Type:Type), (&$tmp@1518:Reference), (&$tmp@1538:Reference)) + + @mangle_as("read_memory") -fn > at -> ReferenceMut +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)) +@mangle_as("read_memory") +fn > at > -> ReferenceMut + +@mangle_as("address_of") +fn address of > -> MemoryAddress + +@mangle_as("address_of") +fn address of > -> MemoryAddress +fn size of > -> Integer: + let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) + return ($tmp@4399:Integer) -fn value from >> -> Reference: - let $tmp@1886: Reference = `<:Reference>> [ <:Integer> ]`((*it:Iterator).array, `clone <:Reference>`((*it:Iterator).index)) - return ($tmp@1886:Reference) +fn copy <:Type> from > to > -> None: + `copy <:Reference> bytes from <:Reference> to <:Reference>`((&`size of <:Type>`((Type:Type)):Reference), (src:Reference), (dst:Reference)) -@mangle_as("integer_as_string") -fn String from <$arg0: Integer> -> String -fn println -> None: - let $tmp@176: None = `println <:String>`(`String from <:Integer>`((x:Integer))) - return ($tmp@176:None) +fn copy > to > -> None: + let $tmp@1518: MemoryAddress = `address of <:Reference>`((src:Reference)) + let $tmp@1538: MemoryAddress = `address of <:Reference>`((dst:ReferenceMut)) + `copy <:Type> from <:Reference> to <:Reference>`((Type:Type), (&$tmp@1518:Reference), (&$tmp@1538:Reference)) + + +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 $tmp@916: MemoryAddress = `<:MemoryAddress> + <:Integer>`((new_data:MemoryAddress), `<:Integer> * <:Integer>`(`clone <:Reference>`((i:Integer)), `clone <:Reference>`((bytes:Integer)))) + let value: ReferenceMut = `<:Type> at <:Reference>`((Type:Type), (&$tmp@916:Reference)) + `copy <:Reference> to <:ReferenceMut>`(`<:Reference>> [ <:Integer> ]`((array:ReferenceMut>), `clone <:Reference>`((i:Integer))), (value:ReferenceMut)) + `<:ReferenceMut> += <:Integer>`((&i:ReferenceMut), 1) + + `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 $tmp@1068: MemoryAddress = `<:MemoryAddress> + <:Integer>`((*array:Array).data, `<:Integer> * <:Integer>`(`clone <:Reference>`((*array:Array).size), `clone <:Reference>`((bytes:Integer)))) + let value: ReferenceMut = `<:Type> at <:Reference>`((Type:Type), (&$tmp@1068:Reference)) + `copy <:Reference> to <:ReferenceMut>`((&x:Reference), (value:ReferenceMut)) + `<: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 advance >> -> None: - `<:ReferenceMut> += <:Integer>`((&(*it:Iterator).index:ReferenceMut), 1) +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@1497: String = `clone <:Reference>`((str:String)) + `destroy <:ReferenceMut>`((str:String)) + return ($tmp@1497:String) + + +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..a968e4c3 100644 --- a/src/tests/snapshots/ppl__tests__array.ir.snap +++ b/src/tests/snapshots/ppl__tests__array.ir.snap @@ -11,14 +11,12 @@ 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 @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 @@ -65,123 +63,108 @@ define void @main.execute() !dbg !12 { call void @initialize(), !dbg !13 call void @initialize.1(), !dbg !14 call void @initialize.2(), !dbg !14 - call void @initialize.3(), !dbg !15 - %1 = load %"Array", ptr @arr, align 8, !dbg !16 - call void @"println <:Array>"(%"Array" %1), !dbg !16 - br label %if.condition, !dbg !17 + %1 = load %"Array", ptr @arr, align 8, !dbg !15 + call void @"println <:Array>"(%"Array" %1), !dbg !15 + br label %if.condition, !dbg !16 if.condition: ; preds = %0 - %2 = call i1 @"<:Reference>> is empty"(ptr @arr), !dbg !18 - br i1 %2, label %if.body, label %4, !dbg !18 + %2 = call i1 @"<:Reference>> is empty"(ptr @arr), !dbg !17 + br i1 %2, label %if.body, label %4, !dbg !17 if.body: ; preds = %if.condition - %3 = call %String @string_from_c_string_and_length(ptr @5, i64 5), !dbg !17 - call void @"println <:String>"(%String %3), !dbg !17 - br label %4, !dbg !17 + %3 = call %String @string_from_c_string_and_length(ptr @5, i64 5), !dbg !16 + call void @"println <:String>"(%String %3), !dbg !16 + br label %4, !dbg !16 -return: ; preds = %16 +return: ; preds = %9 ret void 4: ; preds = %if.condition, %if.body - %5 = call %Integer @integer_from_i64(i64 1), !dbg !19 - call void @"push <:Integer> to <:ReferenceMut>>"(%Integer %5, ptr @arr), !dbg !20 - %6 = load %"Array", ptr @arr, align 8, !dbg !21 - call void @"println <:Array>"(%"Array" %6), !dbg !21 - br label %if.condition2, !dbg !22 + %5 = call %Integer @integer_from_i64(i64 1), !dbg !18 + call void @"push <:Integer> to <:ReferenceMut>>"(%Integer %5, ptr @arr), !dbg !19 + %6 = load %"Array", ptr @arr, align 8, !dbg !20 + call void @"println <:Array>"(%"Array" %6), !dbg !20 + br label %if.condition2, !dbg !21 if.condition2: ; preds = %4 - %7 = call i1 @"<:Reference>> is not empty"(ptr @arr), !dbg !23 - br i1 %7, label %if.body1, label %9, !dbg !23 + %7 = call i1 @"<:Reference>> is not empty"(ptr @arr), !dbg !22 + br i1 %7, label %if.body1, label %9, !dbg !22 if.body1: ; preds = %if.condition2 - %8 = call %String @string_from_c_string_and_length(ptr @6, i64 9), !dbg !22 - call void @"println <:String>"(%String %8), !dbg !22 - br label %9, !dbg !22 + %8 = call %String @string_from_c_string_and_length(ptr @6, i64 9), !dbg !21 + call void @"println <:String>"(%String %8), !dbg !21 + br label %9, !dbg !21 9: ; preds = %if.condition2, %if.body1 - %10 = call %Integer @integer_from_i64(i64 0), !dbg !24 - %11 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr @arr, %Integer %10), !dbg !24 - %12 = call %Integer @clone_integer(ptr %11), !dbg !24 - call void @"println <:Integer>"(%Integer %12), !dbg !24 - 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 - -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 + %10 = call %Integer @integer_from_i64(i64 0), !dbg !23 + %11 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr @arr, %Integer %10), !dbg !23 + %12 = call %Integer @clone_integer(ptr %11), !dbg !23 + call void @"println <:Integer>"(%Integer %12), !dbg !23 + br label %return, !dbg !23 } -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 !24 { + %1 = load %"Type", ptr @"Type", align 8, !dbg !25 + %2 = call %"Array" @"<:Type> [ ]"(%"Type" %1), !dbg !25 + store %"Array" %2, ptr @arr, align 8, !dbg !25 + br label %return, !dbg !25 return: ; preds = %0 ret void } -define private %"Array" @"<:Type> [ ]"(%"Type" %0) !dbg !30 { +define private %"Array" @"<:Type> [ ]"(%"Type" %0) !dbg !26 { %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 !27 + %capacity = alloca %Integer, align 8, !dbg !27 + store %Integer %2, ptr %capacity, align 8, !dbg !27 + %3 = call %Integer @clone_integer(ptr %capacity), !dbg !28 + %4 = load %"Type", ptr @"Type", align 8, !dbg !29 + %5 = call %MemoryAddress @"allocate <:Integer> <:Type>"(%Integer %3, %"Type" %4), !dbg !29 + %data = alloca %MemoryAddress, align 8, !dbg !29 + store %MemoryAddress %5, ptr %data, align 8, !dbg !29 + %6 = alloca %"Array", align 8, !dbg !29 + %"Array.size" = getelementptr inbounds %"Array", ptr %6, i32 0, i32 0, !dbg !29 + %7 = call %Integer @integer_from_i64(i64 0), !dbg !29 + store %Integer %7, ptr %"Array.size", align 8, !dbg !29 + %"Array.capacity" = getelementptr inbounds %"Array", ptr %6, i32 0, i32 1, !dbg !29 + %8 = call %Integer @clone_integer(ptr %capacity), !dbg !29 + store %Integer %8, ptr %"Array.capacity", align 8, !dbg !29 + %"Array.data" = getelementptr inbounds %"Array", ptr %6, i32 0, i32 2, !dbg !29 + %9 = load %MemoryAddress, ptr %data, align 8, !dbg !29 + store %MemoryAddress %9, ptr %"Array.data", align 8, !dbg !29 + %10 = load %"Array", ptr %6, align 8, !dbg !29 + %"$tmp@260" = alloca %"Array", align 8, !dbg !29 + store %"Array" %10, ptr %"$tmp@260", align 8, !dbg !29 + call void @destroy_integer(ptr %capacity), !dbg !30 + %11 = load %"Array", ptr %"$tmp@260", align 8, !dbg !29 + store %"Array" %11, ptr %return_value, align 8, !dbg !29 + br label %return, !dbg !29 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 !31 { %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 !32 + %4 = load %"Type", ptr @"Type", align 8, !dbg !32 + %5 = call %Integer @"size of <:Type>"(%"Type" %4), !dbg !32 + %6 = call %Integer @integer_star_integer(%Integer %3, %Integer %5), !dbg !32 + %7 = call %MemoryAddress @allocate_n_bytes(%Integer %6), !dbg !32 + %"$tmp@760" = alloca %MemoryAddress, align 8, !dbg !32 + store %MemoryAddress %7, ptr %"$tmp@760", align 8, !dbg !32 + call void @destroy_integer(ptr %n), !dbg !32 + %8 = load %MemoryAddress, ptr %"$tmp@760", align 8, !dbg !32 + store %MemoryAddress %8, ptr %return_value, align 8, !dbg !32 + br label %return, !dbg !32 return: ; preds = %2 %9 = load %MemoryAddress, ptr %return_value, align 8 @@ -194,17 +177,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 !33 { %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 !34 + %2 = call %Integer @clone_integer(ptr %size), !dbg !34 + %"$tmp@4399" = alloca %Integer, align 8, !dbg !34 + store %Integer %2, ptr %"$tmp@4399", align 8, !dbg !34 + %3 = load %Integer, ptr %"$tmp@4399", align 8, !dbg !34 + store %Integer %3, ptr %return_value, align 8, !dbg !34 + br label %return, !dbg !34 return: ; preds = %1 %4 = load %Integer, ptr %return_value, align 8 @@ -213,44 +196,13 @@ 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 - -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 !35 { %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 !36 + %3 = call %String @"String from <:Array>"(%"Array" %2), !dbg !36 + call void @"println <:String>"(%String %3), !dbg !36 + br label %return, !dbg !37 return: ; preds = %1 ret void @@ -258,82 +210,81 @@ 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 !38 { %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 !39 + %str = alloca %String, align 8, !dbg !39 + store %String %2, ptr %str, align 8, !dbg !39 + br label %if.condition, !dbg !39 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 !39 + br i1 %3, label %if.body, label %10, !dbg !39 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 !39 + %5 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr %array, %Integer %4), !dbg !39 + %6 = load %Integer, ptr %5, align 8, !dbg !39 + %7 = call %String @integer_as_string(%Integer %6), !dbg !39 + call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %7), !dbg !39 + %8 = call %Integer @integer_from_i64(i64 1), !dbg !39 + %i = alloca %Integer, align 8, !dbg !39 + store %Integer %8, ptr %i, align 8, !dbg !39 + br label %while.condition, !dbg !39 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 !39 + call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %11), !dbg !39 + %12 = call %String @clone_string(ptr %str), !dbg !39 + %"$tmp@1485" = alloca %String, align 8, !dbg !39 + store %String %12, ptr %"$tmp@1485", align 8, !dbg !39 + call void @destroy_string(ptr %str), !dbg !39 + %13 = load %String, ptr %"$tmp@1485", align 8, !dbg !39 + store %String %13, ptr %return_value, align 8, !dbg !39 + br label %return, !dbg !39 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 !39 + %size = getelementptr inbounds %"Array", ptr %array, i32 0, i32 0, !dbg !39 + %15 = call %Integer @clone_integer(ptr %size), !dbg !39 + %16 = call i1 @integer_less_integer(%Integer %14, %Integer %15), !dbg !39 + br i1 %16, label %while.body, label %23, !dbg !39 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 !39 + call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %17), !dbg !39 + %18 = call %Integer @clone_integer(ptr %i), !dbg !39 + %19 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr %array, %Integer %18), !dbg !39 + %20 = load %Integer, ptr %19, align 8, !dbg !39 + %21 = call %String @integer_as_string(%Integer %20), !dbg !39 + call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %21), !dbg !39 + %22 = call %Integer @integer_from_i64(i64 1), !dbg !39 + call void @"<:ReferenceMut> += <:Integer>"(ptr %i, %Integer %22), !dbg !39 + br label %while.condition, !dbg !39 + +23: ; preds = %while.condition + call void @destroy_integer(ptr %i), !dbg !39 + br label %10, !dbg !39 } -define private void @"<:ReferenceMut> += <:String>"(ptr %0, %String %1) !dbg !47 { +define private void @"<:ReferenceMut> += <:String>"(ptr %0, %String %1) !dbg !40 { %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 - %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 - br label %return, !dbg !50 + %3 = load ptr, ptr %self, align 8, !dbg !41 + %4 = load ptr, ptr %self, align 8, !dbg !42 + %5 = load %String, ptr %4, align 8, !dbg !42 + %6 = load %String, ptr %other, align 8, !dbg !43 + %7 = call %String @string_plus_string(%String %5, %String %6), !dbg !43 + store %String %7, ptr %3, align 8, !dbg !43 + br label %return, !dbg !43 return: ; preds = %2 ret void @@ -343,27 +294,27 @@ declare %String @string_plus_string(%String, %String) declare %String @integer_as_string(%Integer) -define private ptr @"<:Reference>> [ <:Integer> ]"(ptr %0, %Integer %1) !dbg !51 { +define private ptr @"<:Reference>> [ <:Integer> ]"(ptr %0, %Integer %1) !dbg !44 { %return_value = alloca ptr, align 8 %array = alloca ptr, align 8 store ptr %0, ptr %array, align 8 %i = alloca %Integer, align 8 store %Integer %1, ptr %i, align 8 - %3 = load ptr, ptr %array, align 8, !dbg !52 - %data = getelementptr inbounds %"Array", ptr %3, i32 0, i32 2, !dbg !52 - %4 = load %MemoryAddress, ptr %data, align 8, !dbg !52 - %5 = load %Integer, ptr %i, align 8, !dbg !52 - %6 = load %"Type", ptr @"Type", align 8, !dbg !52 - %7 = call %Integer @"size of <:Type>"(%"Type" %6), !dbg !52 - %8 = call %Integer @integer_star_integer(%Integer %5, %Integer %7), !dbg !52 - %9 = call %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress %4, %Integer %8), !dbg !52 - %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 - br label %return, !dbg !52 + %3 = load ptr, ptr %array, align 8, !dbg !45 + %data = getelementptr inbounds %"Array", ptr %3, i32 0, i32 2, !dbg !45 + %4 = load %MemoryAddress, ptr %data, align 8, !dbg !45 + %5 = load %Integer, ptr %i, align 8, !dbg !45 + %6 = load %"Type", ptr @"Type", align 8, !dbg !45 + %7 = call %Integer @"size of <:Type>"(%"Type" %6), !dbg !45 + %8 = call %Integer @integer_star_integer(%Integer %5, %Integer %7), !dbg !45 + %9 = call %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress %4, %Integer %8), !dbg !45 + %address = alloca %MemoryAddress, align 8, !dbg !45 + store %MemoryAddress %9, ptr %address, align 8, !dbg !45 + %10 = load %"Type", ptr @"Type", align 8, !dbg !45 + %11 = load %MemoryAddress, ptr %address, align 8, !dbg !45 + %12 = call ptr @read_memory(%"Type" %10, %MemoryAddress %11), !dbg !45 + store ptr %12, ptr %return_value, align 8, !dbg !45 + br label %return, !dbg !45 return: ; preds = %2 %13 = load ptr, ptr %return_value, align 8 @@ -374,18 +325,18 @@ declare %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress, %Integer declare ptr @read_memory(%"Type", %MemoryAddress) -define private void @"<:ReferenceMut> += <:Integer>"(ptr %0, %Integer %1) !dbg !53 { +define private void @"<:ReferenceMut> += <:Integer>"(ptr %0, %Integer %1) !dbg !46 { %self = alloca ptr, align 8 store ptr %0, ptr %self, align 8 %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 + %3 = load ptr, ptr %self, align 8, !dbg !47 + %4 = load ptr, ptr %self, align 8, !dbg !48 + %5 = load %Integer, ptr %4, align 8, !dbg !48 + %6 = load %Integer, ptr %other, align 8, !dbg !49 + %7 = call %Integer @integer_plus_integer(%Integer %5, %Integer %6), !dbg !49 + store %Integer %7, ptr %3, align 8, !dbg !49 + br label %return, !dbg !49 return: ; preds = %2 ret void @@ -395,37 +346,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 !50 { %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 !51 + %size = getelementptr inbounds %"Array", ptr %2, i32 0, i32 0, !dbg !51 + %3 = load %Integer, ptr %size, align 8, !dbg !51 + %4 = call %Integer @integer_from_i64(i64 0), !dbg !51 + %5 = call i1 @"<:Integer> > <:Integer>"(%Integer %3, %Integer %4), !dbg !51 + store i1 %5, ptr %return_value, align 1, !dbg !51 + br label %return, !dbg !51 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 !52 { %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 !53 + %4 = load %Integer, ptr %x, align 8, !dbg !53 + %5 = call i1 @integer_less_integer(%Integer %3, %Integer %4), !dbg !53 + %"$tmp@1032" = alloca i1, align 1, !dbg !53 + store i1 %5, ptr %"$tmp@1032", align 1, !dbg !53 + %6 = load i1, ptr %"$tmp@1032", align 1, !dbg !53 + store i1 %6, ptr %return_value, align 1, !dbg !53 + br label %return, !dbg !53 return: ; preds = %2 %7 = load i1, ptr %return_value, align 1 @@ -436,20 +387,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 !54 { %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 !55 + %size = getelementptr inbounds %"Array", ptr %2, i32 0, i32 0, !dbg !55 + %3 = call %Integer @clone_integer(ptr %size), !dbg !55 + %4 = call %Integer @integer_from_i64(i64 0), !dbg !55 + %5 = call i1 @integer_eq_integer(%Integer %3, %Integer %4), !dbg !55 + %"$tmp@1161" = alloca i1, align 1, !dbg !55 + store i1 %5, ptr %"$tmp@1161", align 1, !dbg !55 + %6 = load i1, ptr %"$tmp@1161", align 1, !dbg !55 + store i1 %6, ptr %return_value, align 1, !dbg !55 + br label %return, !dbg !55 return: ; preds = %1 %7 = load i1, ptr %return_value, align 1 @@ -458,193 +409,134 @@ 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 !56 { %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 !57 + %4 = call %Integer @"size of <:Type>"(%"Type" %3), !dbg !57 + %bytes = alloca %Integer, align 8, !dbg !57 + store %Integer %4, ptr %bytes, align 8, !dbg !57 + br label %if.condition, !dbg !57 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 !57 + %size4 = getelementptr inbounds %"Array", ptr %5, i32 0, i32 0, !dbg !57 + %6 = call %Integer @clone_integer(ptr %size4), !dbg !57 + %7 = load ptr, ptr %array, align 8, !dbg !57 + %capacity5 = getelementptr inbounds %"Array", ptr %7, i32 0, i32 1, !dbg !57 + %8 = call %Integer @clone_integer(ptr %capacity5), !dbg !57 + %9 = call i1 @integer_eq_integer(%Integer %6, %Integer %8), !dbg !57 + br i1 %9, label %if.body, label %18, !dbg !57 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 !57 + %capacity = getelementptr inbounds %"Array", ptr %10, i32 0, i32 1, !dbg !57 + %11 = call %Integer @clone_integer(ptr %capacity), !dbg !57 + %12 = call %Integer @integer_from_i64(i64 2), !dbg !57 + %13 = call %Integer @integer_star_integer(%Integer %11, %Integer %12), !dbg !57 + %new_capacity = alloca %Integer, align 8, !dbg !57 + store %Integer %13, ptr %new_capacity, align 8, !dbg !57 + %14 = call %Integer @clone_integer(ptr %new_capacity), !dbg !57 + %15 = load %"Type", ptr @"Type", align 8, !dbg !57 + %16 = call %MemoryAddress @"allocate <:Integer> <:Type>"(%Integer %14, %"Type" %15), !dbg !57 + %new_data = alloca %MemoryAddress, align 8, !dbg !57 + store %MemoryAddress %16, ptr %new_data, align 8, !dbg !57 + %17 = call %Integer @integer_from_i64(i64 0), !dbg !57 + %i = alloca %Integer, align 8, !dbg !57 + store %Integer %17, ptr %i, align 8, !dbg !57 + br label %while.condition, !dbg !57 + +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, %48 + %19 = load %"Type", ptr @"Type", align 8, !dbg !57 + %20 = load ptr, ptr %array, align 8, !dbg !57 + %data6 = getelementptr inbounds %"Array", ptr %20, i32 0, i32 2, !dbg !57 + %21 = load %MemoryAddress, ptr %data6, align 8, !dbg !57 + %22 = load ptr, ptr %array, align 8, !dbg !57 + %size7 = getelementptr inbounds %"Array", ptr %22, i32 0, i32 0, !dbg !57 + %23 = call %Integer @clone_integer(ptr %size7), !dbg !57 + %24 = call %Integer @clone_integer(ptr %bytes), !dbg !57 + %25 = call %Integer @integer_star_integer(%Integer %23, %Integer %24), !dbg !57 + %26 = call %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress %21, %Integer %25), !dbg !57 + %27 = call ptr @read_memory(%"Type" %19, %MemoryAddress %26), !dbg !57 + %value8 = alloca ptr, align 8, !dbg !57 + store ptr %27, ptr %value8, align 8, !dbg !57 + %28 = load ptr, ptr %value8, align 8, !dbg !57 + %29 = load %Integer, ptr %x, align 8, !dbg !57 + store %Integer %29, ptr %28, align 8, !dbg !57 + %30 = load ptr, ptr %array, align 8, !dbg !57 + %size9 = getelementptr inbounds %"Array", ptr %30, i32 0, i32 0, !dbg !57 + %31 = call %Integer @integer_from_i64(i64 1), !dbg !57 + call void @"<:ReferenceMut> += <:Integer>"(ptr %size9, %Integer %31), !dbg !57 + call void @destroy_integer(ptr %bytes), !dbg !57 + br label %return, !dbg !57 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 + %32 = call %Integer @clone_integer(ptr %i), !dbg !57 + %33 = load ptr, ptr %array, align 8, !dbg !57 + %size = getelementptr inbounds %"Array", ptr %33, i32 0, i32 0, !dbg !57 + %34 = call %Integer @clone_integer(ptr %size), !dbg !57 + %35 = call i1 @integer_less_integer(%Integer %32, %Integer %34), !dbg !57 + br i1 %35, label %while.body, label %48, !dbg !57 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 + %36 = load %"Type", ptr @"Type", align 8, !dbg !57 + %37 = load %MemoryAddress, ptr %new_data, align 8, !dbg !57 + %38 = call %Integer @clone_integer(ptr %i), !dbg !57 + %39 = call %Integer @clone_integer(ptr %bytes), !dbg !57 + %40 = call %Integer @integer_star_integer(%Integer %38, %Integer %39), !dbg !57 + %41 = call %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress %37, %Integer %40), !dbg !57 + %42 = call ptr @read_memory(%"Type" %36, %MemoryAddress %41), !dbg !57 + %value = alloca ptr, align 8, !dbg !57 + store ptr %42, ptr %value, align 8, !dbg !57 + %43 = load ptr, ptr %value, align 8, !dbg !57 + %44 = call %Integer @clone_integer(ptr %i), !dbg !57 + %45 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr %array, %Integer %44), !dbg !57 + %46 = load %Integer, ptr %45, align 8, !dbg !57 + store %Integer %46, ptr %43, align 8, !dbg !57 + %47 = call %Integer @integer_from_i64(i64 1), !dbg !57 + call void @"<:ReferenceMut> += <:Integer>"(ptr %i, %Integer %47), !dbg !57 + br label %while.condition, !dbg !57 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 + %49 = load ptr, ptr %array, align 8, !dbg !57 + %data = getelementptr inbounds %"Array", ptr %49, i32 0, i32 2, !dbg !57 + %50 = load %MemoryAddress, ptr %data, align 8, !dbg !57 + call void @free_memory(%MemoryAddress %50), !dbg !57 + %51 = load ptr, ptr %array, align 8, !dbg !57 + %data1 = getelementptr inbounds %"Array", ptr %51, i32 0, i32 2, !dbg !57 + %52 = load %MemoryAddress, ptr %new_data, align 8, !dbg !57 + store %MemoryAddress %52, ptr %data1, align 8, !dbg !57 + %53 = load ptr, ptr %array, align 8, !dbg !57 + %capacity2 = getelementptr inbounds %"Array", ptr %53, i32 0, i32 1, !dbg !57 + call void @destroy_integer(ptr %capacity2), !dbg !57 + %54 = load ptr, ptr %array, align 8, !dbg !57 + %capacity3 = getelementptr inbounds %"Array", ptr %54, i32 0, i32 1, !dbg !57 + %55 = call %Integer @clone_integer(ptr %new_capacity), !dbg !57 + store %Integer %55, ptr %capacity3, align 8, !dbg !57 + call void @destroy_integer(ptr %new_capacity), !dbg !57 + call void @destroy_integer(ptr %i), !dbg !57 + br label %18, !dbg !57 } declare void @free_memory(%MemoryAddress) -define private void @"println <:Integer>"(%Integer %0) !dbg !65 { +define private void @"println <:Integer>"(%Integer %0) !dbg !58 { %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 - -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 -} - -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 + %2 = load %Integer, ptr %x, align 8, !dbg !59 + %3 = call %String @integer_as_string(%Integer %2), !dbg !59 + call void @"println <:String>"(%String %3), !dbg !59 + br label %return, !dbg !60 return: ; preds = %1 ret void } -define private i1 @"<:Reference>> exists"(ptr %0) !dbg !72 { - %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 - -return: ; preds = %1 - %9 = load i1, ptr %return_value, align 1 - ret i1 %9 -} - !llvm.module.flags = !{!0} !llvm.dbg.cu = !{!1} @@ -663,62 +555,49 @@ 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) -!16 = !DILocation(line: 1, column: 8, scope: !12) -!17 = !DILocation(line: 3, column: 9, scope: !12) -!18 = !DILocation(line: 2, column: 3, scope: !12) -!19 = !DILocation(line: 4, column: 5, scope: !12) -!20 = !DILocation(line: 4, column: 10, scope: !12) -!21 = !DILocation(line: 5, column: 8, scope: !12) -!22 = !DILocation(line: 7, column: 9, scope: !12) -!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) +!15 = !DILocation(line: 1, column: 8, scope: !12) +!16 = !DILocation(line: 3, column: 9, scope: !12) +!17 = !DILocation(line: 2, column: 3, scope: !12) +!18 = !DILocation(line: 4, column: 5, scope: !12) +!19 = !DILocation(line: 4, column: 10, scope: !12) +!20 = !DILocation(line: 5, column: 8, scope: !12) +!21 = !DILocation(line: 7, column: 9, scope: !12) +!22 = !DILocation(line: 6, column: 3, scope: !12) +!23 = !DILocation(line: 8, column: 12, scope: !12) +!24 = distinct !DISubprogram(name: "initialize.2", linkageName: "initialize.2", scope: !12, file: !2, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!25 = !DILocation(line: 0, column: 14, scope: !24) +!26 = distinct !DISubprogram(name: "<:Type> [ ]", linkageName: "<:Type> [ ]", scope: !24, file: !2, line: 10, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!27 = !DILocation(line: 12, column: 11, scope: !26) +!28 = !DILocation(line: 13, column: 6, scope: !26) +!29 = !DILocation(line: 13, column: 14, scope: !26) +!30 = !DILocation(line: 11, column: 16, scope: !26) +!31 = distinct !DISubprogram(name: "allocate <:Integer> <:Type>", linkageName: "allocate <:Integer> <:Type>", scope: !26, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!32 = !DILocation(line: 13, column: 14, scope: !31) +!33 = distinct !DISubprogram(name: "size of <:Type>", linkageName: "size of <:Type>", scope: !31, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!34 = !DILocation(line: 13, column: 14, scope: !33) +!35 = distinct !DISubprogram(name: "println <:Array>", linkageName: "println <:Array>", scope: !12, file: !2, line: 8, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!36 = !DILocation(line: 11, column: 10, scope: !35) +!37 = !DILocation(line: 10, column: 22, scope: !35) +!38 = distinct !DISubprogram(name: "String from <:Array>", linkageName: "String from <:Array>", scope: !35, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!39 = !DILocation(line: 13, column: 14, scope: !38) +!40 = distinct !DISubprogram(name: "<:ReferenceMut> += <:String>", linkageName: "<:ReferenceMut> += <:String>", scope: !38, file: !2, line: 10, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!41 = !DILocation(line: 12, column: 16, scope: !40) +!42 = !DILocation(line: 12, column: 23, scope: !40) +!43 = !DILocation(line: 13, column: 2, scope: !40) +!44 = distinct !DISubprogram(name: "<:Reference>> [ <:Integer> ]", linkageName: "<:Reference>> [ <:Integer> ]", scope: !38, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!45 = !DILocation(line: 13, column: 14, scope: !44) +!46 = distinct !DISubprogram(name: "<:ReferenceMut> += <:Integer>", linkageName: "<:ReferenceMut> += <:Integer>", scope: !38, file: !2, line: 10, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!47 = !DILocation(line: 12, column: 16, scope: !46) +!48 = !DILocation(line: 12, column: 23, scope: !46) +!49 = !DILocation(line: 13, column: 2, scope: !46) +!50 = distinct !DISubprogram(name: "<:Reference>> is not empty", linkageName: "<:Reference>> is not empty", scope: !38, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!51 = !DILocation(line: 13, column: 14, scope: !50) +!52 = distinct !DISubprogram(name: "<:Integer> > <:Integer>", linkageName: "<:Integer> > <:Integer>", scope: !50, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!53 = !DILocation(line: 13, column: 14, scope: !52) +!54 = distinct !DISubprogram(name: "<:Reference>> is empty", linkageName: "<:Reference>> is empty", scope: !12, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!55 = !DILocation(line: 13, column: 14, scope: !54) +!56 = distinct !DISubprogram(name: "push <:Integer> to <:ReferenceMut>>", linkageName: "push <:Integer> to <:ReferenceMut>>", scope: !12, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!57 = !DILocation(line: 13, column: 14, scope: !56) +!58 = distinct !DISubprogram(name: "println <:Integer>", linkageName: "println <:Integer>", scope: !12, file: !2, line: 8, type: !4, spFlags: DISPFlagDefinition, unit: !1) +!59 = !DILocation(line: 11, column: 10, scope: !58) +!60 = !DILocation(line: 10, column: 22, scope: !58) diff --git a/src/tests/snapshots/ppl__tests__array.run.snap b/src/tests/snapshots/ppl__tests__array.run.snap index 0e3fda8a..f4cfa682 100644 --- a/src/tests/snapshots/ppl__tests__array.run.snap +++ b/src/tests/snapshots/ppl__tests__array.run.snap @@ -2,6 +2,8 @@ source: src/tests/mod.rs expression: run_log --- +[] Empty +[1] Not empty 1 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) From 49e54bdb40eb53f31c2624a0392ce6d20de4d35c Mon Sep 17 00:00:00 2001 From: Gavrilikhin Daniil Date: Thu, 16 May 2024 20:48:29 +0800 Subject: [PATCH 2/2] Fix array --- ppl/src/array.ppl | 7 +- src/tests/array/src/main.ppl | 2 +- .../snapshots/ppl__tests__array.hir.snap | 187 +---- src/tests/snapshots/ppl__tests__array.ir.snap | 732 ++++++++++-------- .../snapshots/ppl__tests__array.run.snap | 9 + 5 files changed, 451 insertions(+), 486 deletions(-) diff --git a/ppl/src/array.ppl b/ppl/src/array.ppl index 6b1d584c..854aeccd 100644 --- a/ppl/src/array.ppl +++ b/ppl/src/array.ppl @@ -35,15 +35,14 @@ 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) - copy array[i] to value + 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) - copy x to value + copy bytes bytes from (address of x) to (array.data + array.size * bytes) array.size += 1 fn > is empty => array.size == 0 diff --git a/src/tests/array/src/main.ppl b/src/tests/array/src/main.ppl index 84755350..d3babd4a 100644 --- a/src/tests/array/src/main.ppl +++ b/src/tests/array/src/main.ppl @@ -9,7 +9,7 @@ if arr is not empty: println arr[0] let mut i = 2 -while i < 10: +while i <= 10: push i to arr i += 1 println arr diff --git a/src/tests/snapshots/ppl__tests__array.hir.snap b/src/tests/snapshots/ppl__tests__array.hir.snap index 7e29127d..6dcd006d 100644 --- a/src/tests/snapshots/ppl__tests__array.hir.snap +++ b/src/tests/snapshots/ppl__tests__array.hir.snap @@ -14,7 +14,7 @@ if `<:Reference>> is not empty`((&arr:ReferenceMut `println <:String>`("Not empty") `println <:Integer>`(`clone <:Reference>`((*`<:Reference>> [ <:Integer> ]`((&arr:ReferenceMut>), 0):Integer))) -while `<:Integer> < <:Integer>`(`clone <:Reference>`((i:Integer)), 10): +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)) @@ -56,9 +56,9 @@ fn String from > -> String: `destroy <:ReferenceMut>`((i:Integer)) `<:ReferenceMut> += <:String>`((&str:ReferenceMut), "]") - let $tmp@1497: String = `clone <:Reference>`((str:String)) + let $tmp@1530: String = `clone <:Reference>`((str:String)) `destroy <:ReferenceMut>`((str:String)) - return ($tmp@1497:String) + return ($tmp@1530:String) fn println > -> None: @@ -68,8 +68,8 @@ fn println > -> None: fn >> is empty -> Bool: - let $tmp@1173: Bool = `<:Integer> == <:Integer>`(`clone <:Reference>`((*array:Array).size), 0) - return ($tmp@1173:Bool) + let $tmp@1206: Bool = `<:Integer> == <:Integer>`(`clone <:Reference>`((*array:Array).size), 0) + return ($tmp@1206:Bool) fn size of > -> Integer: @@ -88,73 +88,9 @@ fn allocate <$arg1: Type> -> MemoryAddress: return ($tmp@760:MemoryAddress) -@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 <:Reference>`((Type:Type), (&address:Reference)) - - -@mangle_as("read_memory") -fn > at > -> ReferenceMut - -@mangle_as("address_of") -fn address of > -> MemoryAddress - @mangle_as("address_of") fn address of > -> MemoryAddress -fn size of > -> Integer: - let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) - return ($tmp@4399:Integer) - - -fn copy <:Type> from > to > -> None: - `copy <:Reference> bytes from <:Reference> to <:Reference>`((&`size of <:Type>`((Type:Type)):Reference), (src:Reference), (dst:Reference)) - - -fn copy > to > -> None: - let $tmp@1518: MemoryAddress = `address of <:Reference>`((src:Reference)) - let $tmp@1538: MemoryAddress = `address of <:Reference>`((dst:ReferenceMut)) - `copy <:Type> from <:Reference> to <:Reference>`((Type:Type), (&$tmp@1518:Reference), (&$tmp@1538:Reference)) - - -@mangle_as("read_memory") -fn > at > -> ReferenceMut - -@mangle_as("read_memory") -fn > at > -> ReferenceMut - -@mangle_as("address_of") -fn address of > -> MemoryAddress - -@mangle_as("address_of") -fn address of > -> MemoryAddress - -fn size of > -> Integer: - let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) - return ($tmp@4399:Integer) - - -fn copy <:Type> from > to > -> None: - `copy <:Reference> bytes from <:Reference> to <:Reference>`((&`size of <:Type>`((Type:Type)):Reference), (src:Reference), (dst:Reference)) - - -fn copy > to > -> None: - let $tmp@1518: MemoryAddress = `address of <:Reference>`((src:Reference)) - let $tmp@1538: MemoryAddress = `address of <:Reference>`((dst:ReferenceMut)) - `copy <:Type> from <:Reference> to <:Reference>`((Type:Type), (&$tmp@1518:Reference), (&$tmp@1538:Reference)) - - 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)): @@ -162,10 +98,12 @@ fn push to >> -> None: 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 $tmp@916: MemoryAddress = `<:MemoryAddress> + <:Integer>`((new_data:MemoryAddress), `<:Integer> * <:Integer>`(`clone <:Reference>`((i:Integer)), `clone <:Reference>`((bytes:Integer)))) - let value: ReferenceMut = `<:Type> at <:Reference>`((Type:Type), (&$tmp@916:Reference)) - `copy <:Reference> to <:ReferenceMut>`(`<:Reference>> [ <:Integer> ]`((array:ReferenceMut>), `clone <:Reference>`((i:Integer))), (value:ReferenceMut)) + 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 <:Reference>`((&(*array:Array).data:ReferenceMut)) (*array:Array).data = (new_data:MemoryAddress) @@ -174,9 +112,9 @@ fn push to >> -> None: `destroy <:ReferenceMut>`((new_capacity:Integer)) `destroy <:ReferenceMut>`((i:Integer)) - let $tmp@1068: MemoryAddress = `<:MemoryAddress> + <:Integer>`((*array:Array).data, `<:Integer> * <:Integer>`(`clone <:Reference>`((*array:Array).size), `clone <:Reference>`((bytes:Integer)))) - let value: ReferenceMut = `<:Type> at <:Reference>`((Type:Type), (&$tmp@1068:Reference)) - `copy <:Reference> to <:ReferenceMut>`((&x:Reference), (value:ReferenceMut)) + 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)) @@ -194,9 +132,9 @@ fn String from > -> String: `destroy <:ReferenceMut>`((i:Integer)) `<:ReferenceMut> += <:String>`((&str:ReferenceMut), "]") - let $tmp@1497: String = `clone <:Reference>`((str:String)) + let $tmp@1530: String = `clone <:Reference>`((str:String)) `destroy <:ReferenceMut>`((str:String)) - return ($tmp@1497:String) + return ($tmp@1530:String) fn println > -> None: @@ -206,8 +144,8 @@ fn println > -> None: fn >> is not empty -> Bool: - let $tmp@1230: Bool = `<:Integer> > <:Integer>`(`clone <:Reference>`((*array:Array).size), 0) - return ($tmp@1230:Bool) + let $tmp@1263: Bool = `<:Integer> > <:Integer>`(`clone <:Reference>`((*array:Array).size), 0) + return ($tmp@1263:Bool) fn size of > -> Integer: @@ -237,89 +175,40 @@ fn println -> None: -fn size of > -> Integer: - let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) - return ($tmp@4399:Integer) +@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) -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 <= -> Bool: + let $tmp@1068: Bool = `not <:Bool>`(`<:Integer> > <:Integer>`((x:Integer), (y:Integer))) + return ($tmp@1068:Bool) -@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 <:Reference>`((Type:Type), (&address:Reference)) - - -@mangle_as("read_memory") -fn > at > -> ReferenceMut - -@mangle_as("address_of") -fn address of > -> MemoryAddress - -@mangle_as("address_of") -fn address of > -> MemoryAddress - fn size of > -> Integer: let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) return ($tmp@4399:Integer) -fn copy <:Type> from > to > -> None: - `copy <:Reference> bytes from <:Reference> to <:Reference>`((&`size of <:Type>`((Type:Type)):Reference), (src:Reference), (dst:Reference)) - - -fn copy > to > -> None: - let $tmp@1518: MemoryAddress = `address of <:Reference>`((src:Reference)) - let $tmp@1538: MemoryAddress = `address of <:Reference>`((dst:ReferenceMut)) - `copy <:Type> from <:Reference> to <:Reference>`((Type:Type), (&$tmp@1518:Reference), (&$tmp@1538:Reference)) - - -@mangle_as("read_memory") -fn > at > -> ReferenceMut - -@mangle_as("read_memory") -fn > at > -> ReferenceMut +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("address_of") -fn address of > -> MemoryAddress @mangle_as("address_of") fn address of > -> MemoryAddress -fn size of > -> Integer: - let $tmp@4399: Integer = `clone <:Reference>`((ty:Type).size) - return ($tmp@4399:Integer) - - -fn copy <:Type> from > to > -> None: - `copy <:Reference> bytes from <:Reference> to <:Reference>`((&`size of <:Type>`((Type:Type)):Reference), (src:Reference), (dst:Reference)) - - -fn copy > to > -> None: - let $tmp@1518: MemoryAddress = `address of <:Reference>`((src:Reference)) - let $tmp@1538: MemoryAddress = `address of <:Reference>`((dst:ReferenceMut)) - `copy <:Type> from <:Reference> to <:Reference>`((Type:Type), (&$tmp@1518:Reference), (&$tmp@1538:Reference)) - - 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)): @@ -327,10 +216,12 @@ fn push to >> -> None: 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 $tmp@916: MemoryAddress = `<:MemoryAddress> + <:Integer>`((new_data:MemoryAddress), `<:Integer> * <:Integer>`(`clone <:Reference>`((i:Integer)), `clone <:Reference>`((bytes:Integer)))) - let value: ReferenceMut = `<:Type> at <:Reference>`((Type:Type), (&$tmp@916:Reference)) - `copy <:Reference> to <:ReferenceMut>`(`<:Reference>> [ <:Integer> ]`((array:ReferenceMut>), `clone <:Reference>`((i:Integer))), (value:ReferenceMut)) + 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 <:Reference>`((&(*array:Array).data:ReferenceMut)) (*array:Array).data = (new_data:MemoryAddress) @@ -339,9 +230,9 @@ fn push to >> -> None: `destroy <:ReferenceMut>`((new_capacity:Integer)) `destroy <:ReferenceMut>`((i:Integer)) - let $tmp@1068: MemoryAddress = `<:MemoryAddress> + <:Integer>`((*array:Array).data, `<:Integer> * <:Integer>`(`clone <:Reference>`((*array:Array).size), `clone <:Reference>`((bytes:Integer)))) - let value: ReferenceMut = `<:Type> at <:Reference>`((Type:Type), (&$tmp@1068:Reference)) - `copy <:Reference> to <:ReferenceMut>`((&x:Reference), (value:ReferenceMut)) + 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)) @@ -366,9 +257,9 @@ fn String from > -> String: `destroy <:ReferenceMut>`((i:Integer)) `<:ReferenceMut> += <:String>`((&str:ReferenceMut), "]") - let $tmp@1497: String = `clone <:Reference>`((str:String)) + let $tmp@1530: String = `clone <:Reference>`((str:String)) `destroy <:ReferenceMut>`((str:String)) - return ($tmp@1497:String) + return ($tmp@1530:String) fn println > -> None: diff --git a/src/tests/snapshots/ppl__tests__array.ir.snap b/src/tests/snapshots/ppl__tests__array.ir.snap index a968e4c3..9ee934d4 100644 --- a/src/tests/snapshots/ppl__tests__array.ir.snap +++ b/src/tests/snapshots/ppl__tests__array.ir.snap @@ -17,6 +17,7 @@ source_filename = "src/main.ppl" @"Type" = private global %"Type" zeroinitializer @1 = private unnamed_addr constant [8 x i8] c"Integer\00", align 1 @arr = global %"Array" 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 @@ -63,108 +64,128 @@ define void @main.execute() !dbg !12 { call void @initialize(), !dbg !13 call void @initialize.1(), !dbg !14 call void @initialize.2(), !dbg !14 - %1 = load %"Array", ptr @arr, align 8, !dbg !15 - call void @"println <:Array>"(%"Array" %1), !dbg !15 - br label %if.condition, !dbg !16 + call void @initialize.3(), !dbg !15 + %1 = load %"Array", ptr @arr, align 8, !dbg !16 + call void @"println <:Array>"(%"Array" %1), !dbg !16 + br label %if.condition, !dbg !17 if.condition: ; preds = %0 - %2 = call i1 @"<:Reference>> is empty"(ptr @arr), !dbg !17 - br i1 %2, label %if.body, label %4, !dbg !17 + %2 = call i1 @"<:Reference>> is empty"(ptr @arr), !dbg !18 + br i1 %2, label %if.body, label %4, !dbg !18 if.body: ; preds = %if.condition - %3 = call %String @string_from_c_string_and_length(ptr @5, i64 5), !dbg !16 - call void @"println <:String>"(%String %3), !dbg !16 - br label %4, !dbg !16 + %3 = call %String @string_from_c_string_and_length(ptr @5, i64 5), !dbg !17 + call void @"println <:String>"(%String %3), !dbg !17 + br label %4, !dbg !17 -return: ; preds = %9 +return: ; preds = %19 ret void 4: ; preds = %if.condition, %if.body - %5 = call %Integer @integer_from_i64(i64 1), !dbg !18 - call void @"push <:Integer> to <:ReferenceMut>>"(%Integer %5, ptr @arr), !dbg !19 - %6 = load %"Array", ptr @arr, align 8, !dbg !20 - call void @"println <:Array>"(%"Array" %6), !dbg !20 - br label %if.condition2, !dbg !21 + %5 = call %Integer @integer_from_i64(i64 1), !dbg !19 + call void @"push <:Integer> to <:ReferenceMut>>"(%Integer %5, ptr @arr), !dbg !20 + %6 = load %"Array", ptr @arr, align 8, !dbg !21 + call void @"println <:Array>"(%"Array" %6), !dbg !21 + br label %if.condition2, !dbg !22 if.condition2: ; preds = %4 - %7 = call i1 @"<:Reference>> is not empty"(ptr @arr), !dbg !22 - br i1 %7, label %if.body1, label %9, !dbg !22 + %7 = call i1 @"<:Reference>> is not empty"(ptr @arr), !dbg !23 + br i1 %7, label %if.body1, label %9, !dbg !23 if.body1: ; preds = %if.condition2 - %8 = call %String @string_from_c_string_and_length(ptr @6, i64 9), !dbg !21 - call void @"println <:String>"(%String %8), !dbg !21 - br label %9, !dbg !21 + %8 = call %String @string_from_c_string_and_length(ptr @6, i64 9), !dbg !22 + call void @"println <:String>"(%String %8), !dbg !22 + br label %9, !dbg !22 9: ; preds = %if.condition2, %if.body1 - %10 = call %Integer @integer_from_i64(i64 0), !dbg !23 - %11 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr @arr, %Integer %10), !dbg !23 - %12 = call %Integer @clone_integer(ptr %11), !dbg !23 - call void @"println <:Integer>"(%Integer %12), !dbg !23 - br label %return, !dbg !23 + %10 = call %Integer @integer_from_i64(i64 0), !dbg !24 + %11 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr @arr, %Integer %10), !dbg !24 + %12 = call %Integer @clone_integer(ptr %11), !dbg !24 + call void @"println <:Integer>"(%Integer %12), !dbg !24 + br label %while.condition, !dbg !24 + +while.condition: ; preds = %while.body, %9 + %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 + %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 !24 { - %1 = load %"Type", ptr @"Type", align 8, !dbg !25 - %2 = call %"Array" @"<:Type> [ ]"(%"Type" %1), !dbg !25 - store %"Array" %2, ptr @arr, align 8, !dbg !25 - br label %return, !dbg !25 +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 !26 { +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 !27 - %capacity = alloca %Integer, align 8, !dbg !27 - store %Integer %2, ptr %capacity, align 8, !dbg !27 - %3 = call %Integer @clone_integer(ptr %capacity), !dbg !28 - %4 = load %"Type", ptr @"Type", align 8, !dbg !29 - %5 = call %MemoryAddress @"allocate <:Integer> <:Type>"(%Integer %3, %"Type" %4), !dbg !29 - %data = alloca %MemoryAddress, align 8, !dbg !29 - store %MemoryAddress %5, ptr %data, align 8, !dbg !29 - %6 = alloca %"Array", align 8, !dbg !29 - %"Array.size" = getelementptr inbounds %"Array", ptr %6, i32 0, i32 0, !dbg !29 - %7 = call %Integer @integer_from_i64(i64 0), !dbg !29 - store %Integer %7, ptr %"Array.size", align 8, !dbg !29 - %"Array.capacity" = getelementptr inbounds %"Array", ptr %6, i32 0, i32 1, !dbg !29 - %8 = call %Integer @clone_integer(ptr %capacity), !dbg !29 - store %Integer %8, ptr %"Array.capacity", align 8, !dbg !29 - %"Array.data" = getelementptr inbounds %"Array", ptr %6, i32 0, i32 2, !dbg !29 - %9 = load %MemoryAddress, ptr %data, align 8, !dbg !29 - store %MemoryAddress %9, ptr %"Array.data", align 8, !dbg !29 - %10 = load %"Array", ptr %6, align 8, !dbg !29 - %"$tmp@260" = alloca %"Array", align 8, !dbg !29 - store %"Array" %10, ptr %"$tmp@260", align 8, !dbg !29 - call void @destroy_integer(ptr %capacity), !dbg !30 - %11 = load %"Array", ptr %"$tmp@260", align 8, !dbg !29 - store %"Array" %11, ptr %return_value, align 8, !dbg !29 - br label %return, !dbg !29 + %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 !31 { +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 !32 - %4 = load %"Type", ptr @"Type", align 8, !dbg !32 - %5 = call %Integer @"size of <:Type>"(%"Type" %4), !dbg !32 - %6 = call %Integer @integer_star_integer(%Integer %3, %Integer %5), !dbg !32 - %7 = call %MemoryAddress @allocate_n_bytes(%Integer %6), !dbg !32 - %"$tmp@760" = alloca %MemoryAddress, align 8, !dbg !32 - store %MemoryAddress %7, ptr %"$tmp@760", align 8, !dbg !32 - call void @destroy_integer(ptr %n), !dbg !32 - %8 = load %MemoryAddress, ptr %"$tmp@760", align 8, !dbg !32 - store %MemoryAddress %8, ptr %return_value, align 8, !dbg !32 - br label %return, !dbg !32 + %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 @@ -177,17 +198,17 @@ declare %Integer @integer_star_integer(%Integer, %Integer) declare %Integer @clone_integer(ptr) -define private %Integer @"size of <:Type>"(%"Type" %0) !dbg !33 { +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 !34 - %2 = call %Integer @clone_integer(ptr %size), !dbg !34 - %"$tmp@4399" = alloca %Integer, align 8, !dbg !34 - store %Integer %2, ptr %"$tmp@4399", align 8, !dbg !34 - %3 = load %Integer, ptr %"$tmp@4399", align 8, !dbg !34 - store %Integer %3, ptr %return_value, align 8, !dbg !34 - br label %return, !dbg !34 + %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 @@ -196,13 +217,22 @@ return: ; preds = %1 declare void @destroy_integer(ptr) -define private void @"println <:Array>"(%"Array" %0) !dbg !35 { +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 void @"println <:Array>"(%"Array" %0) !dbg !44 { %x = alloca %"Array", align 8 store %"Array" %0, ptr %x, align 8 - %2 = load %"Array", ptr %x, align 8, !dbg !36 - %3 = call %String @"String from <:Array>"(%"Array" %2), !dbg !36 - call void @"println <:String>"(%String %3), !dbg !36 - br label %return, !dbg !37 + %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 @@ -210,81 +240,81 @@ return: ; preds = %1 declare void @"println <:String>"(%String) -define private %String @"String from <:Array>"(%"Array" %0) !dbg !38 { +define private %String @"String from <:Array>"(%"Array" %0) !dbg !47 { %return_value = alloca %String, align 8 %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 !39 - %str = alloca %String, align 8, !dbg !39 - store %String %2, ptr %str, align 8, !dbg !39 - br label %if.condition, !dbg !39 + %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 !39 - br i1 %3, label %if.body, label %10, !dbg !39 + %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 !39 - %5 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr %array, %Integer %4), !dbg !39 - %6 = load %Integer, ptr %5, align 8, !dbg !39 - %7 = call %String @integer_as_string(%Integer %6), !dbg !39 - call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %7), !dbg !39 - %8 = call %Integer @integer_from_i64(i64 1), !dbg !39 - %i = alloca %Integer, align 8, !dbg !39 - store %Integer %8, ptr %i, align 8, !dbg !39 - br label %while.condition, !dbg !39 + %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, %23 - %11 = call %String @string_from_c_string_and_length(ptr @4, i64 1), !dbg !39 - call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %11), !dbg !39 - %12 = call %String @clone_string(ptr %str), !dbg !39 - %"$tmp@1485" = alloca %String, align 8, !dbg !39 - store %String %12, ptr %"$tmp@1485", align 8, !dbg !39 - call void @destroy_string(ptr %str), !dbg !39 - %13 = load %String, ptr %"$tmp@1485", align 8, !dbg !39 - store %String %13, ptr %return_value, align 8, !dbg !39 - br label %return, !dbg !39 + %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 !39 - %size = getelementptr inbounds %"Array", ptr %array, i32 0, i32 0, !dbg !39 - %15 = call %Integer @clone_integer(ptr %size), !dbg !39 - %16 = call i1 @integer_less_integer(%Integer %14, %Integer %15), !dbg !39 - br i1 %16, label %while.body, label %23, !dbg !39 + %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 - %17 = call %String @string_from_c_string_and_length(ptr @3, i64 2), !dbg !39 - call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %17), !dbg !39 - %18 = call %Integer @clone_integer(ptr %i), !dbg !39 - %19 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr %array, %Integer %18), !dbg !39 - %20 = load %Integer, ptr %19, align 8, !dbg !39 - %21 = call %String @integer_as_string(%Integer %20), !dbg !39 - call void @"<:ReferenceMut> += <:String>"(ptr %str, %String %21), !dbg !39 - %22 = call %Integer @integer_from_i64(i64 1), !dbg !39 - call void @"<:ReferenceMut> += <:Integer>"(ptr %i, %Integer %22), !dbg !39 - br label %while.condition, !dbg !39 + %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 !39 - br label %10, !dbg !39 + call void @destroy_integer(ptr %i), !dbg !48 + br label %10, !dbg !48 } -define private void @"<:ReferenceMut> += <:String>"(ptr %0, %String %1) !dbg !40 { +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 !41 - %4 = load ptr, ptr %self, align 8, !dbg !42 - %5 = load %String, ptr %4, align 8, !dbg !42 - %6 = load %String, ptr %other, align 8, !dbg !43 - %7 = call %String @string_plus_string(%String %5, %String %6), !dbg !43 - store %String %7, ptr %3, align 8, !dbg !43 - br label %return, !dbg !43 + %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 + br label %return, !dbg !50 return: ; preds = %2 ret void @@ -294,49 +324,48 @@ declare %String @string_plus_string(%String, %String) declare %String @integer_as_string(%Integer) -define private ptr @"<:Reference>> [ <:Integer> ]"(ptr %0, %Integer %1) !dbg !44 { +define private ptr @"<:Reference>> [ <:Integer> ]"(ptr %0, %Integer %1) !dbg !51 { %return_value = alloca ptr, align 8 %array = alloca ptr, align 8 store ptr %0, ptr %array, align 8 %i = alloca %Integer, align 8 store %Integer %1, ptr %i, align 8 - %3 = load ptr, ptr %array, align 8, !dbg !45 - %data = getelementptr inbounds %"Array", ptr %3, i32 0, i32 2, !dbg !45 - %4 = load %MemoryAddress, ptr %data, align 8, !dbg !45 - %5 = load %Integer, ptr %i, align 8, !dbg !45 - %6 = load %"Type", ptr @"Type", align 8, !dbg !45 - %7 = call %Integer @"size of <:Type>"(%"Type" %6), !dbg !45 - %8 = call %Integer @integer_star_integer(%Integer %5, %Integer %7), !dbg !45 - %9 = call %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress %4, %Integer %8), !dbg !45 - %address = alloca %MemoryAddress, align 8, !dbg !45 - store %MemoryAddress %9, ptr %address, align 8, !dbg !45 - %10 = load %"Type", ptr @"Type", align 8, !dbg !45 - %11 = load %MemoryAddress, ptr %address, align 8, !dbg !45 - %12 = call ptr @read_memory(%"Type" %10, %MemoryAddress %11), !dbg !45 - store ptr %12, ptr %return_value, align 8, !dbg !45 - br label %return, !dbg !45 + %3 = load ptr, ptr %array, align 8, !dbg !52 + %data = getelementptr inbounds %"Array", ptr %3, i32 0, i32 2, !dbg !52 + %4 = load %MemoryAddress, ptr %data, align 8, !dbg !52 + %5 = load %Integer, ptr %i, align 8, !dbg !52 + %6 = load %"Type", ptr @"Type", align 8, !dbg !52 + %7 = call %Integer @"size of <:Type>"(%"Type" %6), !dbg !52 + %8 = call %Integer @integer_star_integer(%Integer %5, %Integer %7), !dbg !52 + %9 = call %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress %4, %Integer %8), !dbg !52 + %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 = 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 !46 { +define private void @"<:ReferenceMut> += <:Integer>"(ptr %0, %Integer %1) !dbg !53 { %self = alloca ptr, align 8 store ptr %0, ptr %self, align 8 %other = alloca %Integer, align 8 store %Integer %1, ptr %other, align 8 - %3 = load ptr, ptr %self, align 8, !dbg !47 - %4 = load ptr, ptr %self, align 8, !dbg !48 - %5 = load %Integer, ptr %4, align 8, !dbg !48 - %6 = load %Integer, ptr %other, align 8, !dbg !49 - %7 = call %Integer @integer_plus_integer(%Integer %5, %Integer %6), !dbg !49 - store %Integer %7, ptr %3, align 8, !dbg !49 - br label %return, !dbg !49 + %3 = load ptr, ptr %self, align 8, !dbg !54 + %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 @@ -346,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 !50 { +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 !51 - %size = getelementptr inbounds %"Array", ptr %2, i32 0, i32 0, !dbg !51 - %3 = load %Integer, ptr %size, align 8, !dbg !51 - %4 = call %Integer @integer_from_i64(i64 0), !dbg !51 - %5 = call i1 @"<:Integer> > <:Integer>"(%Integer %3, %Integer %4), !dbg !51 - store i1 %5, ptr %return_value, align 1, !dbg !51 - br label %return, !dbg !51 + %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 !52 { +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 !53 - %4 = load %Integer, ptr %x, align 8, !dbg !53 - %5 = call i1 @integer_less_integer(%Integer %3, %Integer %4), !dbg !53 - %"$tmp@1032" = alloca i1, align 1, !dbg !53 - store i1 %5, ptr %"$tmp@1032", align 1, !dbg !53 - %6 = load i1, ptr %"$tmp@1032", align 1, !dbg !53 - store i1 %6, ptr %return_value, align 1, !dbg !53 - br label %return, !dbg !53 + %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 @@ -387,20 +416,20 @@ declare %String @clone_string(ptr) declare void @destroy_string(ptr) -define private i1 @"<:Reference>> is empty"(ptr %0) !dbg !54 { +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 !55 - %size = getelementptr inbounds %"Array", ptr %2, i32 0, i32 0, !dbg !55 - %3 = call %Integer @clone_integer(ptr %size), !dbg !55 - %4 = call %Integer @integer_from_i64(i64 0), !dbg !55 - %5 = call i1 @integer_eq_integer(%Integer %3, %Integer %4), !dbg !55 - %"$tmp@1161" = alloca i1, align 1, !dbg !55 - store i1 %5, ptr %"$tmp@1161", align 1, !dbg !55 - %6 = load i1, ptr %"$tmp@1161", align 1, !dbg !55 - store i1 %6, ptr %return_value, align 1, !dbg !55 - br label %return, !dbg !55 + %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 @@ -409,134 +438,164 @@ return: ; preds = %1 declare i1 @integer_eq_integer(%Integer, %Integer) -define private void @"push <:Integer> to <:ReferenceMut>>"(%Integer %0, ptr %1) !dbg !56 { +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 - %3 = load %"Type", ptr @"Type", align 8, !dbg !57 - %4 = call %Integer @"size of <:Type>"(%"Type" %3), !dbg !57 - %bytes = alloca %Integer, align 8, !dbg !57 - store %Integer %4, ptr %bytes, align 8, !dbg !57 - br label %if.condition, !dbg !57 + %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 - %5 = load ptr, ptr %array, align 8, !dbg !57 - %size4 = getelementptr inbounds %"Array", ptr %5, i32 0, i32 0, !dbg !57 - %6 = call %Integer @clone_integer(ptr %size4), !dbg !57 - %7 = load ptr, ptr %array, align 8, !dbg !57 - %capacity5 = getelementptr inbounds %"Array", ptr %7, i32 0, i32 1, !dbg !57 - %8 = call %Integer @clone_integer(ptr %capacity5), !dbg !57 - %9 = call i1 @integer_eq_integer(%Integer %6, %Integer %8), !dbg !57 - br i1 %9, label %if.body, label %18, !dbg !57 + %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 - %10 = load ptr, ptr %array, align 8, !dbg !57 - %capacity = getelementptr inbounds %"Array", ptr %10, i32 0, i32 1, !dbg !57 - %11 = call %Integer @clone_integer(ptr %capacity), !dbg !57 - %12 = call %Integer @integer_from_i64(i64 2), !dbg !57 - %13 = call %Integer @integer_star_integer(%Integer %11, %Integer %12), !dbg !57 - %new_capacity = alloca %Integer, align 8, !dbg !57 - store %Integer %13, ptr %new_capacity, align 8, !dbg !57 - %14 = call %Integer @clone_integer(ptr %new_capacity), !dbg !57 - %15 = load %"Type", ptr @"Type", align 8, !dbg !57 - %16 = call %MemoryAddress @"allocate <:Integer> <:Type>"(%Integer %14, %"Type" %15), !dbg !57 - %new_data = alloca %MemoryAddress, align 8, !dbg !57 - store %MemoryAddress %16, ptr %new_data, align 8, !dbg !57 - %17 = call %Integer @integer_from_i64(i64 0), !dbg !57 - %i = alloca %Integer, align 8, !dbg !57 - store %Integer %17, ptr %i, align 8, !dbg !57 - br label %while.condition, !dbg !57 + %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 -18: ; preds = %if.condition, %48 - %19 = load %"Type", ptr @"Type", align 8, !dbg !57 - %20 = load ptr, ptr %array, align 8, !dbg !57 - %data6 = getelementptr inbounds %"Array", ptr %20, i32 0, i32 2, !dbg !57 - %21 = load %MemoryAddress, ptr %data6, align 8, !dbg !57 - %22 = load ptr, ptr %array, align 8, !dbg !57 - %size7 = getelementptr inbounds %"Array", ptr %22, i32 0, i32 0, !dbg !57 - %23 = call %Integer @clone_integer(ptr %size7), !dbg !57 - %24 = call %Integer @clone_integer(ptr %bytes), !dbg !57 - %25 = call %Integer @integer_star_integer(%Integer %23, %Integer %24), !dbg !57 - %26 = call %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress %21, %Integer %25), !dbg !57 - %27 = call ptr @read_memory(%"Type" %19, %MemoryAddress %26), !dbg !57 - %value8 = alloca ptr, align 8, !dbg !57 - store ptr %27, ptr %value8, align 8, !dbg !57 - %28 = load ptr, ptr %value8, align 8, !dbg !57 - %29 = load %Integer, ptr %x, align 8, !dbg !57 - store %Integer %29, ptr %28, align 8, !dbg !57 - %30 = load ptr, ptr %array, align 8, !dbg !57 - %size9 = getelementptr inbounds %"Array", ptr %30, i32 0, i32 0, !dbg !57 - %31 = call %Integer @integer_from_i64(i64 1), !dbg !57 - call void @"<:ReferenceMut> += <:Integer>"(ptr %size9, %Integer %31), !dbg !57 - call void @destroy_integer(ptr %bytes), !dbg !57 - br label %return, !dbg !57 +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 !57 - %33 = load ptr, ptr %array, align 8, !dbg !57 - %size = getelementptr inbounds %"Array", ptr %33, i32 0, i32 0, !dbg !57 - %34 = call %Integer @clone_integer(ptr %size), !dbg !57 - %35 = call i1 @integer_less_integer(%Integer %32, %Integer %34), !dbg !57 - br i1 %35, label %while.body, label %48, !dbg !57 + %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 !57 - %37 = load %MemoryAddress, ptr %new_data, align 8, !dbg !57 - %38 = call %Integer @clone_integer(ptr %i), !dbg !57 - %39 = call %Integer @clone_integer(ptr %bytes), !dbg !57 - %40 = call %Integer @integer_star_integer(%Integer %38, %Integer %39), !dbg !57 - %41 = call %MemoryAddress @"<:MemoryAddress> + <:Integer>"(%MemoryAddress %37, %Integer %40), !dbg !57 - %42 = call ptr @read_memory(%"Type" %36, %MemoryAddress %41), !dbg !57 - %value = alloca ptr, align 8, !dbg !57 - store ptr %42, ptr %value, align 8, !dbg !57 - %43 = load ptr, ptr %value, align 8, !dbg !57 - %44 = call %Integer @clone_integer(ptr %i), !dbg !57 - %45 = call ptr @"<:Reference>> [ <:Integer> ]"(ptr %array, %Integer %44), !dbg !57 - %46 = load %Integer, ptr %45, align 8, !dbg !57 - store %Integer %46, ptr %43, align 8, !dbg !57 - %47 = call %Integer @integer_from_i64(i64 1), !dbg !57 - call void @"<:ReferenceMut> += <:Integer>"(ptr %i, %Integer %47), !dbg !57 - br label %while.condition, !dbg !57 - -48: ; preds = %while.condition - %49 = load ptr, ptr %array, align 8, !dbg !57 - %data = getelementptr inbounds %"Array", ptr %49, i32 0, i32 2, !dbg !57 - %50 = load %MemoryAddress, ptr %data, align 8, !dbg !57 - call void @free_memory(%MemoryAddress %50), !dbg !57 - %51 = load ptr, ptr %array, align 8, !dbg !57 - %data1 = getelementptr inbounds %"Array", ptr %51, i32 0, i32 2, !dbg !57 - %52 = load %MemoryAddress, ptr %new_data, align 8, !dbg !57 - store %MemoryAddress %52, ptr %data1, align 8, !dbg !57 - %53 = load ptr, ptr %array, align 8, !dbg !57 - %capacity2 = getelementptr inbounds %"Array", ptr %53, i32 0, i32 1, !dbg !57 - call void @destroy_integer(ptr %capacity2), !dbg !57 - %54 = load ptr, ptr %array, align 8, !dbg !57 - %capacity3 = getelementptr inbounds %"Array", ptr %54, i32 0, i32 1, !dbg !57 - %55 = call %Integer @clone_integer(ptr %new_capacity), !dbg !57 - store %Integer %55, ptr %capacity3, align 8, !dbg !57 - call void @destroy_integer(ptr %new_capacity), !dbg !57 - call void @destroy_integer(ptr %i), !dbg !57 - br label %18, !dbg !57 + %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) + +declare void @free_memory(ptr) -define private void @"println <:Integer>"(%Integer %0) !dbg !58 { +declare %MemoryAddress @address_of(ptr) + +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 !59 - %3 = call %String @integer_as_string(%Integer %2), !dbg !59 - call void @"println <:String>"(%String %3), !dbg !59 - br label %return, !dbg !60 + %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 @"<:Integer> <= <:Integer>"(%Integer %0, %Integer %1) !dbg !66 { + %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 %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 = %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} @@ -555,49 +614,56 @@ 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: 1, column: 8, scope: !12) -!16 = !DILocation(line: 3, column: 9, scope: !12) -!17 = !DILocation(line: 2, column: 3, scope: !12) -!18 = !DILocation(line: 4, column: 5, scope: !12) -!19 = !DILocation(line: 4, column: 10, scope: !12) -!20 = !DILocation(line: 5, column: 8, scope: !12) -!21 = !DILocation(line: 7, column: 9, scope: !12) -!22 = !DILocation(line: 6, column: 3, scope: !12) -!23 = !DILocation(line: 8, column: 12, scope: !12) -!24 = distinct !DISubprogram(name: "initialize.2", linkageName: "initialize.2", scope: !12, file: !2, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!25 = !DILocation(line: 0, column: 14, scope: !24) -!26 = distinct !DISubprogram(name: "<:Type> [ ]", linkageName: "<:Type> [ ]", scope: !24, file: !2, line: 10, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!27 = !DILocation(line: 12, column: 11, scope: !26) -!28 = !DILocation(line: 13, column: 6, scope: !26) -!29 = !DILocation(line: 13, column: 14, scope: !26) -!30 = !DILocation(line: 11, column: 16, scope: !26) -!31 = distinct !DISubprogram(name: "allocate <:Integer> <:Type>", linkageName: "allocate <:Integer> <:Type>", scope: !26, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!32 = !DILocation(line: 13, column: 14, scope: !31) -!33 = distinct !DISubprogram(name: "size of <:Type>", linkageName: "size of <:Type>", scope: !31, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!34 = !DILocation(line: 13, column: 14, scope: !33) -!35 = distinct !DISubprogram(name: "println <:Array>", linkageName: "println <:Array>", scope: !12, file: !2, line: 8, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!36 = !DILocation(line: 11, column: 10, scope: !35) -!37 = !DILocation(line: 10, column: 22, scope: !35) -!38 = distinct !DISubprogram(name: "String from <:Array>", linkageName: "String from <:Array>", scope: !35, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!39 = !DILocation(line: 13, column: 14, scope: !38) -!40 = distinct !DISubprogram(name: "<:ReferenceMut> += <:String>", linkageName: "<:ReferenceMut> += <:String>", scope: !38, file: !2, line: 10, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!41 = !DILocation(line: 12, column: 16, scope: !40) -!42 = !DILocation(line: 12, column: 23, scope: !40) -!43 = !DILocation(line: 13, column: 2, scope: !40) -!44 = distinct !DISubprogram(name: "<:Reference>> [ <:Integer> ]", linkageName: "<:Reference>> [ <:Integer> ]", scope: !38, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!45 = !DILocation(line: 13, column: 14, scope: !44) -!46 = distinct !DISubprogram(name: "<:ReferenceMut> += <:Integer>", linkageName: "<:ReferenceMut> += <:Integer>", scope: !38, file: !2, line: 10, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!47 = !DILocation(line: 12, column: 16, scope: !46) -!48 = !DILocation(line: 12, column: 23, scope: !46) -!49 = !DILocation(line: 13, column: 2, scope: !46) -!50 = distinct !DISubprogram(name: "<:Reference>> is not empty", linkageName: "<:Reference>> is not empty", scope: !38, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!51 = !DILocation(line: 13, column: 14, scope: !50) -!52 = distinct !DISubprogram(name: "<:Integer> > <:Integer>", linkageName: "<:Integer> > <:Integer>", scope: !50, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!53 = !DILocation(line: 13, column: 14, scope: !52) -!54 = distinct !DISubprogram(name: "<:Reference>> is empty", linkageName: "<:Reference>> is empty", scope: !12, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!55 = !DILocation(line: 13, column: 14, scope: !54) -!56 = distinct !DISubprogram(name: "push <:Integer> to <:ReferenceMut>>", linkageName: "push <:Integer> to <:ReferenceMut>>", scope: !12, file: !2, line: 13, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!57 = !DILocation(line: 13, column: 14, scope: !56) -!58 = distinct !DISubprogram(name: "println <:Integer>", linkageName: "println <:Integer>", scope: !12, file: !2, line: 8, type: !4, spFlags: DISPFlagDefinition, unit: !1) -!59 = !DILocation(line: 11, column: 10, scope: !58) -!60 = !DILocation(line: 10, column: 22, scope: !58) +!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) +!19 = !DILocation(line: 4, column: 5, scope: !12) +!20 = !DILocation(line: 4, column: 10, scope: !12) +!21 = !DILocation(line: 5, column: 8, scope: !12) +!22 = !DILocation(line: 7, column: 9, scope: !12) +!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: 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 f4cfa682..5a857f57 100644 --- a/src/tests/snapshots/ppl__tests__array.run.snap +++ b/src/tests/snapshots/ppl__tests__array.run.snap @@ -7,3 +7,12 @@ 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]