fix(ssa): Recursive shared Brillig entry points

[vezenovm]

Description

Problem*

Resolves #8069

For more context surrounding what the Brillig entry point analysis pass is doing and why you can reference #7277 and the doc comments on the pass itself.

The current SSA for the new brillig_entry_points_regression_8069 test:

Details

After Array Set Optimizations (1):
acir(inline) impure fn main f0 {
  b0():
    v4 = call f1(u1 1, i8 1, u32 5) -> u1
    v5 = not v4
    enable_side_effects v5
    v8 = call f2(Field 1, u1 1, u32 5) -> [i8; 4]
    enable_side_effects u1 1
    return u1 0
}
brillig(inline) impure fn func_1 f1 {
  b0(v0: u1, v1: i8, v2: u32):
    v5 = eq v2, u32 0
    jmpif v5 then: b1, else: b2
  b1():
    jmp b3(u1 0)
  b2():
    v7 = sub v2, u32 1
    v8 = cast v0 as Field
    v11 = call f2(v8, u1 0, v7) -> [i8; 4]
    v13 = array_get v11, index u32 3 -> i8
    v15 = call f1(u1 0, v13, v7) -> u1
    jmp b3(v15)
  b3(v3: u1):
    return v3
}
brillig(inline) impure fn func_2 f2 {
  b0(v0: Field, v1: u1, v2: u32):
    v5 = eq v2, u32 0
    jmpif v5 then: b1, else: b2
  b1():
    v17 = make_array [i8 6, i8 101, i8 92, i8 30] : [i8; 4]
    jmp b3(v17)
  b2():
    v7 = sub v2, u32 1
    v10 = call f1(v1, i8 0, v7) -> u1
    v12 = call f2(v0, v10, v7) -> [i8; 4]
    jmp b3(v12)
  b3(v3: [i8; 4]):
    return v3
}

After Brillig Entry Point Analysis (1):
acir(inline) impure fn main f0 {
  b0():
    v4 = call f1(u1 1, i8 1, u32 5) -> u1
    v5 = not v4
    enable_side_effects v5
    v8 = call f2(Field 1, u1 1, u32 5) -> [i8; 4]
    enable_side_effects u1 1
    return u1 0
}
brillig(inline) impure fn func_1 f1 {
  b0(v0: u1, v1: i8, v2: u32):
    v5 = eq v2, u32 0
    jmpif v5 then: b1, else: b2
  b1():
    jmp b3(u1 0)
  b2():
    v7 = sub v2, u32 1
    v8 = cast v0 as Field
    v11 = call f4(v8, u1 0, v7) -> [i8; 4]
    v13 = array_get v11, index u32 3 -> i8
    v15 = call f3(u1 0, v13, v7) -> u1
    jmp b3(v15)
  b3(v3: u1):
    return v3
}
brillig(inline) impure fn func_2 f2 {
  b0(v0: Field, v1: u1, v2: u32):
    v5 = eq v2, u32 0
    jmpif v5 then: b1, else: b2
  b1():
    v17 = make_array [i8 6, i8 101, i8 92, i8 30] : [i8; 4]
    jmp b3(v17)
  b2():
    v7 = sub v2, u32 1
    v10 = call f1(v1, i8 0, v7) -> u1
    v12 = call f2(v0, v10, v7) -> [i8; 4]
    jmp b3(v12)
  b3(v3: [i8; 4]):
    return v3
}
brillig(inline) fn func_1 f3 {
  b0(v0: u1, v1: i8, v2: u32):
    v5 = eq v2, u32 0
    jmpif v5 then: b1, else: b2
  b1():
    jmp b3(u1 0)
  b2():
    v7 = sub v2, u32 1
    v8 = cast v0 as Field
    v11 = call f4(v8, u1 0, v7) -> [i8; 4]
    v13 = array_get v11, index u32 3 -> i8
    v15 = call f3(u1 0, v13, v7) -> u1
    jmp b3(v15)
  b3(v3: u1):
    return v3
}
brillig(inline) fn func_2 f4 {
  b0(v0: Field, v1: u1, v2: u32):
    v5 = eq v2, u32 0
    jmpif v5 then: b1, else: b2
  b1():
    v17 = make_array [i8 6, i8 101, i8 92, i8 30] : [i8; 4]
    jmp b3(v17)
  b2():
    v7 = sub v2, u32 1
    v10 = call f3(v1, i8 0, v7) -> u1
    v12 = call f4(v0, v10, v7) -> [i8; 4]
    jmp b3(v12)
  b3(v3: [i8; 4]):
    return v3
}
brillig(inline) fn func_1 f5 {
  b0(v0: u1, v1: i8, v2: u32):
    v5 = eq v2, u32 0
    jmpif v5 then: b1, else: b2
  b1():
    jmp b3(u1 0)
  b2():
    v7 = sub v2, u32 1
    v8 = cast v0 as Field
    v11 = call f2(v8, u1 0, v7) -> [i8; 4]
    v13 = array_get v11, index u32 3 -> i8
    v15 = call f1(u1 0, v13, v7) -> u1
    jmp b3(v15)
  b3(v3: u1):
    return v3
}
brillig(inline) fn func_2 f6 {
  b0(v0: Field, v1: u1, v2: u32):
    v5 = eq v2, u32 0
    jmpif v5 then: b1, else: b2
  b1():
    v17 = make_array [i8 6, i8 101, i8 92, i8 30] : [i8; 4]
    jmp b3(v17)
  b2():
    v7 = sub v2, u32 1
    v10 = call f1(v1, i8 0, v7) -> u1
    v12 = call f2(v0, v10, v7) -> [i8; 4]
    jmp b3(v12)
  b3(v3: [i8; 4]):
    return v3
}

We can see how the calls to f1 and f2 in f2 are never replaced with duplicated entry points.

We currently have a single mapping of old function ids to new function ids. This leads to IDs being muddled across entry points. We clone the functions and set-up the calls that needs updating in each function before actually performing the update. Thus, let's say we updated the function calls for f1, where the calls f1 and f2 map to f3 and f4 respectively. As the calls to update are already set-up, when we go to update the function calls for f2 (which should map to f5 and f6), we will resolve f2 to f3. The calls to update are set-up off the original Brillig entry points call graph, thus there will be no new functions to update for f3.

Summary*

This fix required a couple changes:

1. We now resolve function IDs per entry point. The inner recursive calls in f1 and f2 now resolve to separate specialized entry points as expected. I have added the linked test in the issue under execution_success and a unit test to brillig_entry_points.rs
2. We also now build our new functions map entirely with the original SSA. We previously would iterate through the Brillig entry points call graph, update call sites, and track the new functions mapping at the same time. Before updating the SSA we already have all this information (as we have already cloned the functions). We should be able to set up the calls to update a single time and the mapping of old functions to new before any updates occur. Only then we do we perform the appropriate updates to all the call sites by iterating calls_to_update.
3. We go over the new functions mapping as there may be cloned functions whose call sites were not appropriately updated. Once again, the calls to update we build are only based upon the original SSA so cloned functions are not going to be included. We iterate over the cloned function call sites and use the new functions mapping to resolve the call sites in cloned functions.

New SSA after this PR:

Details

After Brillig Entry Point Analysis (1):
acir(inline) impure fn main f0 {
  b0():
    v4 = call f1(u1 1, i8 1, u32 5) -> u1
    v5 = not v4
    enable_side_effects v5
    v8 = call f2(Field 1, u1 1, u32 5) -> [i8; 4]
    enable_side_effects u1 1
    return u1 0
}
brillig(inline) impure fn func_1 f1 {
  b0(v0: u1, v1: i8, v2: u32):
    v5 = eq v2, u32 0
    jmpif v5 then: b1, else: b2
  b1():
    jmp b3(u1 0)
  b2():
    v7 = sub v2, u32 1
    v8 = cast v0 as Field
    v11 = call f4(v8, u1 0, v7) -> [i8; 4]
    v13 = array_get v11, index u32 3 -> i8
    v15 = call f3(u1 0, v13, v7) -> u1
    jmp b3(v15)
  b3(v3: u1):
    return v3
}
brillig(inline) impure fn func_2 f2 {
  b0(v0: Field, v1: u1, v2: u32):
    v5 = eq v2, u32 0
    jmpif v5 then: b1, else: b2
  b1():
    v17 = make_array [i8 6, i8 101, i8 92, i8 30] : [i8; 4]
    jmp b3(v17)
  b2():
    v7 = sub v2, u32 1
    v10 = call f5(v1, i8 0, v7) -> u1
    v12 = call f6(v0, v10, v7) -> [i8; 4]
    jmp b3(v12)
  b3(v3: [i8; 4]):
    return v3
}
brillig(inline) fn func_1 f3 {
  b0(v0: u1, v1: i8, v2: u32):
    v5 = eq v2, u32 0
    jmpif v5 then: b1, else: b2
  b1():
    jmp b3(u1 0)
  b2():
    v7 = sub v2, u32 1
    v8 = cast v0 as Field
    v11 = call f4(v8, u1 0, v7) -> [i8; 4]
    v13 = array_get v11, index u32 3 -> i8
    v15 = call f3(u1 0, v13, v7) -> u1
    jmp b3(v15)
  b3(v3: u1):
    return v3
}
brillig(inline) fn func_2 f4 {
  b0(v0: Field, v1: u1, v2: u32):
    v5 = eq v2, u32 0
    jmpif v5 then: b1, else: b2
  b1():
    v17 = make_array [i8 6, i8 101, i8 92, i8 30] : [i8; 4]
    jmp b3(v17)
  b2():
    v7 = sub v2, u32 1
    v10 = call f3(v1, i8 0, v7) -> u1
    v12 = call f4(v0, v10, v7) -> [i8; 4]
    jmp b3(v12)
  b3(v3: [i8; 4]):
    return v3
}
brillig(inline) fn func_1 f5 {
  b0(v0: u1, v1: i8, v2: u32):
    v5 = eq v2, u32 0
    jmpif v5 then: b1, else: b2
  b1():
    jmp b3(u1 0)
  b2():
    v7 = sub v2, u32 1
    v8 = cast v0 as Field
    v11 = call f6(v8, u1 0, v7) -> [i8; 4]
    v13 = array_get v11, index u32 3 -> i8
    v15 = call f5(u1 0, v13, v7) -> u1
    jmp b3(v15)
  b3(v3: u1):
    return v3
}
brillig(inline) fn func_2 f6 {
  b0(v0: Field, v1: u1, v2: u32):
    v5 = eq v2, u32 0
    jmpif v5 then: b1, else: b2
  b1():
    v17 = make_array [i8 6, i8 101, i8 92, i8 30] : [i8; 4]
    jmp b3(v17)
  b2():
    v7 = sub v2, u32 1
    v10 = call f5(v1, i8 0, v7) -> u1
    v12 = call f6(v0, v10, v7) -> [i8; 4]
    jmp b3(v12)
  b3(v3: [i8; 4]):
    return v3
}

Additional Context

Documentation*

Check one:

• No documentation needed.
• Documentation included in this PR.
• [For Experimental Features] Documentation to be submitted in a separate PR.

PR Checklist*

• I have tested the changes locally.
• I have formatted the changes with Prettier and/or cargo fmt on default settings.

[github-actions]

⚠️ Performance Alert ⚠️

Possible performance regression was detected for benchmark 'Test Suite Duration'.
Benchmark result of this commit is worse than the previous benchmark result exceeding threshold 1.20.

Benchmark suite	Current: c1c2c63	Previous: 38070d0	Ratio
test_report_AztecProtocol_aztec-packages_noir-projects_noir-protocol-circuits_crates_blob	53 s	40 s	1.32

This comment was automatically generated by workflow using github-action-benchmark.

CC: @TomAFrench

[github-actions]

⚠️ Performance Alert ⚠️

Possible performance regression was detected for benchmark 'Execution Time'.
Benchmark result of this commit is worse than the previous benchmark result exceeding threshold 1.20.

Benchmark suite	Current: 4745eca	Previous: 20fdf4c	Ratio
private-kernel-tail	0.021 s	0.017 s	1.24

This comment was automatically generated by workflow using github-action-benchmark.

CC: @TomAFrench