TorchAudio Conformer model doesn't lower to edge IR

[freddan80]

🐛 Describe the bug

When exporting the TorchAudio Conformer model and lowering it to edge IR, it looks like some ops aren't properly lowered.

There's a draft: #7415 (I'll rebase this soon) that serves as a reproducer with:
pytest -c /dev/null --verbose --color=yes --log-level=DEBUG -s ./backends/arm/test/models/test_conformer.py

Versions

Collecting environment information...
PyTorch version: 2.6.0.dev20250104
Is debug build: False
CUDA used to build PyTorch: None
ROCM used to build PyTorch: N/A

OS: macOS 14.6.1 (arm64)
GCC version: Could not collect
Clang version: 15.0.0 (clang-1500.3.9.4)
CMake version: version 3.29.0
Libc version: N/A

Python version: 3.10.0 (v3.10.0:b494f5935c, Oct 4 2021, 14:59:19) [Clang 12.0.5 (clang-1205.0.22.11)] (64-bit runtime)
Python platform: macOS-14.6.1-arm64-arm-64bit
Is CUDA available: False
CUDA runtime version: No CUDA
CUDA_MODULE_LOADING set to: N/A
GPU models and configuration: No CUDA
Nvidia driver version: No CUDA
cuDNN version: No CUDA
HIP runtime version: N/A
MIOpen runtime version: N/A
Is XNNPACK available: True

CPU:
Apple M3 Pro

Versions of relevant libraries:
[pip3] executorch==0.6.0a0+205f6d0
[pip3] flake8==6.1.0
[pip3] flake8-breakpoint==1.1.0
[pip3] flake8-bugbear==23.9.16
[pip3] flake8-comprehensions==3.14.0
[pip3] flake8-plugin-utils==1.3.3
[pip3] flake8-pyi==23.5.0
[pip3] mypy==1.11.2
[pip3] mypy-extensions==1.0.0
[pip3] numpy==1.26.4
[pip3] optree==0.13.0
[pip3] pytorch_sphinx_theme==0.0.24
[pip3] torch==2.6.0.dev20250104
[pip3] torchao==0.8.0+git11333ba2
[pip3] torchao-nightly==2024.3.18
[pip3] torchaudio==2.6.0.dev20250104
[pip3] torchsr==1.0.4
[pip3] torchsummary==1.5.1
[pip3] torchtune==0.5.0
[pip3] torchvision==0.22.0.dev20250104
[conda] Could not collect

cc @JacobSzwejbka @angelayi @digantdesai @per @zingo @oscarandersson8218

[freddan80]

The ops not lowered properly afaik are:

• aten.lt.Tensor
• aten.ge.Tensor
• aten.gt.Tensor
• aten.scalar_tensor.default
• aten._assert_scalar.default
• aten.sym_constrain_range_for_size.default

When running the reproducer ^^^ you get the operator distribution below:

########## Toedge Operator Distribution ##########
╒═════════════════════════════════════╤═════════╕
│ Operator                            │   Count │
╞═════════════════════════════════════╪═════════╡
│ <EdgeOpOverload: aten.max.default>: │       1 │
│ schema = aten::max(Tensor self) ->  │         │
│ Tensor                              │         │
├─────────────────────────────────────┼─────────┤
│ aten._local_scalar_dense.default    │       1 │
├─────────────────────────────────────┼─────────┤
│ aten.sym_constrain_range_for_size.d │       1 │
│ efault                              │         │
├─────────────────────────────────────┼─────────┤
│ <built-in function ge>              │       3 │
├─────────────────────────────────────┼─────────┤
│ aten._assert_scalar.default         │       9 │
├─────────────────────────────────────┼─────────┤
│ <built-in function le>              │       3 │
├─────────────────────────────────────┼─────────┤
│ <built-in function eq>              │       3 │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │       1 │
│ aten.arange.start_step>: schema =   │         │
│ aten::arange.start_step(Scalar      │         │
│ start, Scalar end, Scalar step=1,   │         │
│ *, ScalarType? dtype=None, Layout?  │         │
│ layout=None, Device? device=None,   │         │
│ bool? pin_memory=None) -> Tensor    │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │      11 │
│ aten.expand_copy.default>: schema = │         │
│ aten::expand_copy(Tensor self,      │         │
│ SymInt[] size, *, bool              │         │
│ implicit=False) -> Tensor           │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │       3 │
│ aten.unsqueeze_copy.default>:       │         │
│ schema =                            │         │
│ aten::unsqueeze_copy(Tensor self,   │         │
│ int dim) -> Tensor                  │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload: aten.ge.Tensor>:   │       1 │
│ schema = aten::ge.Tensor(Tensor     │         │
│ self, Tensor other) -> Tensor       │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │      38 │
│ aten.permute_copy.default>: schema  │         │
│ = aten::permute_copy(Tensor self,   │         │
│ int[] dims) -> Tensor               │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │      10 │
│ aten.native_layer_norm.default>:    │         │
│ schema =                            │         │
│ aten::native_layer_norm(Tensor      │         │
│ input, SymInt[] normalized_shape,   │         │
│ Tensor? weight, Tensor? bias, float │         │
│ eps) -> (Tensor, Tensor, Tensor)    │         │
├─────────────────────────────────────┼─────────┤
│ <built-in function getitem>         │      12 │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │      56 │
│ aten.view_copy.default>: schema =   │         │
│ aten::view_copy(Tensor self,        │         │
│ SymInt[] size) -> Tensor            │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │      12 │
│ aten.addmm.default>: schema =       │         │
│ aten::addmm(Tensor self, Tensor     │         │
│ mat1, Tensor mat2, *, Scalar        │         │
│ beta=1, Scalar alpha=1) -> Tensor   │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │       8 │
│ aten.sigmoid.default>: schema =     │         │
│ aten::sigmoid(Tensor self) ->       │         │
│ Tensor                              │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload: aten.mul.Tensor>:  │      12 │
│ schema = aten::mul.Tensor(Tensor    │         │
│ self, Tensor other) -> Tensor       │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │      18 │
│ aten.clone.default>: schema =       │         │
│ aten::clone(Tensor self, *,         │         │
│ MemoryFormat? memory_format=None)   │         │
│ -> Tensor                           │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload: aten.add.Tensor>:  │      10 │
│ schema = aten::add.Tensor(Tensor    │         │
│ self, Tensor other, *, Scalar       │         │
│ alpha=1) -> Tensor                  │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │       4 │
│ aten.full_like.default>: schema =   │         │
│ aten::full_like(Tensor self, Scalar │         │
│ fill_value, *, ScalarType?          │         │
│ dtype=None, Layout? layout=None,    │         │
│ Device? device=None, bool?          │         │
│ pin_memory=None, MemoryFormat?      │         │
│ memory_format=None) -> Tensor       │         │
├─────────────────────────────────────┼─────────┤
│ aten.scalar_tensor.default          │       2 │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload: aten.where.self>:  │       4 │
│ schema = aten::where.self(Tensor    │         │
│ condition, Tensor self, Tensor      │         │
│ other) -> Tensor                    │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │       2 │
│ aten.squeeze_copy.dims>: schema =   │         │
│ aten::squeeze_copy.dims(Tensor      │         │
│ self, int[] dim) -> Tensor          │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │       6 │
│ aten.select_copy.int>: schema =     │         │
│ aten::select_copy.int(Tensor self,  │         │
│ int dim, SymInt index) -> Tensor    │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload: aten.mul.Scalar>:  │       4 │
│ schema = aten::mul.Scalar(Tensor    │         │
│ self, Scalar other) -> Tensor       │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload: aten.bmm.default>: │       4 │
│ schema = aten::bmm(Tensor self,     │         │
│ Tensor mat2) -> Tensor              │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │       2 │
│ aten._softmax.default>: schema =    │         │
│ aten::_softmax(Tensor self, int     │         │
│ dim, bool half_to_float) -> Tensor  │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload: aten.eq.Scalar>:   │       2 │
│ schema = aten::eq.Scalar(Tensor     │         │
│ self, Scalar other) -> Tensor       │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │       4 │
│ aten.logical_not.default>: schema = │         │
│ aten::logical_not(Tensor self) ->   │         │
│ Tensor                              │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload: aten.any.dim>:     │       2 │
│ schema = aten::any.dim(Tensor self, │         │
│ int dim, bool keepdim=False) ->     │         │
│ Tensor                              │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │       6 │
│ aten.convolution.default>: schema = │         │
│ aten::convolution(Tensor input,     │         │
│ Tensor weight, Tensor? bias,        │         │
│ SymInt[] stride, SymInt[] padding,  │         │
│ SymInt[] dilation, bool transposed, │         │
│ SymInt[] output_padding, SymInt     │         │
│ groups) -> Tensor                   │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload:                    │       4 │
│ aten.slice_copy.Tensor>: schema =   │         │
│ aten::slice_copy.Tensor(Tensor      │         │
│ self, int dim=0, SymInt?            │         │
│ start=None, SymInt? end=None,       │         │
│ SymInt step=1) -> Tensor            │         │
├─────────────────────────────────────┼─────────┤
│ <EdgeOpOverload: aten._native_batch │       2 │
│ _norm_legit_no_training.default>:   │         │
│ schema = aten::_native_batch_norm_l │         │
│ egit_no_training(Tensor input,      │         │
│ Tensor? weight, Tensor? bias,       │         │
│ Tensor running_mean, Tensor         │         │
│ running_var, float momentum, float  │         │
│ eps) -> (Tensor, Tensor, Tensor)    │         │
╘═════════════════════════════════════╧═════════╛

[freddan80]

FYI - I tried getting rid of the aten._assert_scalar.default op by extending

executorch/exir/passes/remove_graph_asserts_pass.py

Line 55 in a10eabd

node.target in (torch.ops.aten._assert_tensor_metadata.default,)

with torch.ops.aten._assert_scalar.default. That actually removed most of the comparison ops as well as dead code. However, it breaks 4-5 unit tests :/

Finally, the part of the Conformer model that cause the assert mentioned here, is https://github.com/pytorch/audio/blob/b6d4675c7aedc53ba04f3f55786aac1de32be6b4/src/torchaudio/models/conformer.py#L9-L15

[freddan80]

@digantdesai (this is the issue we talked about)
@angelayi tagging you wrt the assert observation above.

[angelayi]

What's the exact error?

[freddan80]

@angelayi The ticket in general is about ops not getting lowered to edge IR, which I assume they should?

Or are you referring to the issue I observed:

However, it breaks 4-5 unit tests

?

[freddan80]

@angelayi If the latter, here's one example:

Reproducer:

pytest -c /dev/null --verbose --color=yes --log-level=DEBUG  -s ./exir/program/test/test_program.py -k tes
t_constraint_present_after_dce

Error:

exir/program/test/test_program.py:311: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
.venv/py310_et/lib/python3.10/site-packages/executorch/exir/program/_program.py:99: in wrapper
    return func(self, *args, **kwargs)
.venv/py310_et/lib/python3.10/site-packages/executorch/exir/program/_program.py:1207: in to_edge
    edge_programs[name] = _generate_edge_program(name, config, program)
.venv/py310_et/lib/python3.10/site-packages/executorch/exir/program/_program.py:785: in _generate_edge_program
    gm_res = p(gm)
.venv/py310_et/lib/python3.10/site-packages/torch/fx/passes/infra/pass_base.py:44: in __call__
    res = self.call(graph_module)
.venv/py310_et/lib/python3.10/site-packages/torch/_export/pass_base.py:439: in call
    result = self.call_submodule(graph_module, tuple(inputs))
.venv/py310_et/lib/python3.10/site-packages/torch/_export/pass_base.py:402: in call_submodule
    interpreter.run(*inputs_data)
.venv/py310_et/lib/python3.10/site-packages/torch/fx/interpreter.py:167: in run
    self.env[node] = self.run_node(node)
.venv/py310_et/lib/python3.10/site-packages/torch/_export/pass_base.py:241: in run_node
    return super().run_node(n)
.venv/py310_et/lib/python3.10/site-packages/torch/fx/interpreter.py:230: in run_node
    return getattr(self, n.op)(n.target, args, kwargs)
.venv/py310_et/lib/python3.10/site-packages/torch/_export/pass_base.py:196: in call_function
    return self.callback.call_operator(
.venv/py310_et/lib/python3.10/site-packages/torch/_export/passes/replace_view_ops_with_view_copy_ops_pass.py:63: in call_operator
    return super().call_operator(view_copy_op, args, kwargs, meta)
.venv/py310_et/lib/python3.10/site-packages/torch/_export/pass_base.py:333: in call_operator
    return self._fx("call_function", op, args, kwargs, meta)
.venv/py310_et/lib/python3.10/site-packages/torch/_export/pass_base.py:263: in _fx
    res_data = getattr(self.interpreter, kind)(target, args_data, kwargs_data)
.venv/py310_et/lib/python3.10/site-packages/torch/fx/interpreter.py:310: in call_function
    return target(*args, **kwargs)
.venv/py310_et/lib/python3.10/site-packages/torch/_ops.py:722: in __call__
    return self._op(*args, **kwargs)
.venv/py310_et/lib/python3.10/site-packages/torch/utils/_stats.py:26: in wrapper
    return fn(*args, **kwargs)
.venv/py310_et/lib/python3.10/site-packages/torch/_subclasses/fake_tensor.py:1276: in __torch_dispatch__
    return self.dispatch(func, types, args, kwargs)
.venv/py310_et/lib/python3.10/site-packages/torch/_subclasses/fake_tensor.py:1817: in dispatch
    return self._cached_dispatch_impl(func, types, args, kwargs)
.venv/py310_et/lib/python3.10/site-packages/torch/_subclasses/fake_tensor.py:1378: in _cached_dispatch_impl
    output = self._dispatch_impl(func, types, args, kwargs)
.venv/py310_et/lib/python3.10/site-packages/torch/_subclasses/fake_tensor.py:2385: in _dispatch_impl
    r = func(*args, **kwargs)
.venv/py310_et/lib/python3.10/site-packages/torch/_ops.py:722: in __call__
    return self._op(*args, **kwargs)
.venv/py310_et/lib/python3.10/site-packages/torch/_decomp/decompositions.py:730: in slice_forward
    if guard_size_oblivious(start_val < 0):
.venv/py310_et/lib/python3.10/site-packages/torch/fx/experimental/symbolic_shapes.py:411: in guard_size_oblivious
    return expr.node.guard_size_oblivious("", 0)
.venv/py310_et/lib/python3.10/site-packages/torch/fx/experimental/sym_node.py:564: in guard_size_oblivious
    r = self.shape_env.evaluate_expr(
.venv/py310_et/lib/python3.10/site-packages/torch/fx/experimental/recording.py:263: in wrapper
    return retlog(fn(*args, **kwargs))
.venv/py310_et/lib/python3.10/site-packages/torch/fx/experimental/symbolic_shapes.py:6350: in evaluate_expr
    return self._evaluate_expr(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <torch.fx.experimental.symbolic_shapes.ShapeEnv object at 0x11c5f8640>, orig_expr = u4 < 0, hint = None, fx_node = False, size_oblivious = True

    def _evaluate_expr(
        self,
        orig_expr: sympy.Basic,
        hint: Optional[Union[bool, int, float]] = None,
        fx_node: Optional[torch.fx.Node] = None,
        size_oblivious: bool = False,
        *,
        forcing_spec: bool = False,
    ) -> sympy.Basic:
        """
        Given an expression, evaluates it, adding guards if necessary
        """
    
        # TODO: split conjunctions and evaluate them separately
    
        if isinstance(
            orig_expr,
            (sympy.logic.boolalg.BooleanTrue, sympy.logic.boolalg.BooleanFalse),
        ):
            return orig_expr
    
        # Don't track this one
        @functools.lru_cache(None)
        def compute_concrete_val() -> sympy.Basic:
            if hint is None:
                # This is only ever called for expressions WITHOUT unbacked
                # symbols
                r = self.size_hint(orig_expr)
                assert r is not None
                return r
            else:
                return sympy.sympify(hint)
    
        concrete_val: Optional[sympy.Basic]
    
        # Check if:
        #   1. 'translation_validation' is set
        #   2. the corresponding 'fx_node' is not 'None'
        #   3. the guard should not be suppressed
        #   4. the guard doesn't contain backed symfloat symbols
        #      since z3 can't handle floats
        #
        # If all of the above check, we create an FX node representing the
        # actual expression to be guarded.
        node = None
        fresh = False
        if (
            self._translation_validation_enabled
            and fx_node is not None
            and not self._suppress_guards_tls()
            and not size_oblivious
            and not any(symbol_is_type(s, SymT.FLOAT) for s in orig_expr.free_symbols)
        ):
            # TODO: does this even worked with unbacked :think:
            concrete_val = compute_concrete_val()
            if concrete_val is sympy.true:
                node, fresh = self._create_fx_call_function(torch._assert, (fx_node,))
            elif concrete_val is sympy.false:
                neg, _ = self._create_fx_call_function(operator.not_, (fx_node,))
                node, fresh = self._create_fx_call_function(torch._assert, (neg,))
            else:
                eql, _ = self._create_fx_call_function(
                    operator.eq, (fx_node, concrete_val)
                )
                node, fresh = self._create_fx_call_function(torch._assert, (eql,))
    
            assert node is not None
            # If this is a fresh node, we have to remember the event index that
            # corresponds to this assertion node.
            # Reason: so that, given an assertion node, we can replay the ShapeEnv
            # events until the point where this assertion node was freshly created.
            if fresh:
                self._add_fx_node_metadata(node)
    
        # After creating the FX node corresponding to orig_expr, we must make sure that
        # no error will be raised until the end of this function.
        #
        # Reason: the translation validation may become invalid otherwise.
        #
        # If an error is raised before the end of this function, we remove the FX node
        # inserted, and re-raise the error.
        guard = None
    
        try:
            if orig_expr.is_number:
                self.log.debug("eval %s [trivial]", orig_expr)
                if hint is not None:
                    assert orig_expr == hint, f"{orig_expr} != {hint}"
                return orig_expr
    
            expr = orig_expr
    
            static_expr = self._maybe_evaluate_static(
                expr, size_oblivious=size_oblivious
            )
            if static_expr is not None:
                self.log.debug(
                    "eval %s == %s [statically known]", orig_expr, static_expr
                )
                if hint is not None:
                    assert static_expr == hint, f"{static_expr} != {hint}"
                return static_expr
    
            transmute_into_runtime_assert = False
    
            concrete_val = None
            if not (expr.free_symbols <= self.var_to_val.keys()):
                # TODO: dedupe this with _maybe_evaluate_static
                # Attempt to eliminate the unbacked SymInt
                new_expr = self._maybe_evaluate_static(expr, unbacked_only=True)
                assert new_expr is not None
                if not (new_expr.free_symbols <= self.var_to_val.keys()):
                    size_oblivious_result = None
                    if not size_oblivious:
                        size_oblivious_result = self._maybe_evaluate_static(
                            expr, size_oblivious=True
                        )
    
                    ok = False
    
                    # Last ditch
                    if (
                        self.oblivious_var_to_val
                        and not (
                            correct_hint := orig_expr.xreplace(
                                self.oblivious_var_to_val
                            )
                        ).free_symbols
                        and not (
                            counterfactual_hint := orig_expr.xreplace(
                                {
                                    k: max(2, v)
                                    for k, v in self.oblivious_var_to_val.items()
                                }
                            )
                        ).free_symbols
                        and correct_hint == counterfactual_hint
                    ):
                        # TODO: better logging
                        log.info(
                            "oblivious_size %s -> %s (passed counterfactual)",
                            orig_expr,
                            correct_hint,
                        )
                        concrete_val = correct_hint
                        # NB: do NOT transmute into runtime assert
                        ok = True
    
                    if (
                        not ok
                        and self.unbacked_var_to_val
                        and not (
                            unsound_result := orig_expr.xreplace(
                                self.unbacked_var_to_val
                            )
                        ).free_symbols
                    ):
                        log.warning(
                            "propagate_real_tensors evaluate_expr(%s) -> %s",
                            orig_expr,
                            unsound_result,
                        )
                        trace_structured(
                            "propagate_real_tensors",
                            metadata_fn=lambda: {
                                "expr": repr(orig_expr),
                                "result": repr(unsound_result),
                                "stack": structured.from_traceback(
                                    CapturedTraceback.extract(skip=1).summary()
                                ),
                            },
                        )
                        transmute_into_runtime_assert = True
                        concrete_val = unsound_result
                        ok = True
    
                    if not ok:
>                       raise self._make_data_dependent_error(
                            expr.xreplace(self.var_to_val),
                            expr,
                            size_oblivious_result=size_oblivious_result,
                        )
E                       torch.fx.experimental.symbolic_shapes.GuardOnDataDependentSymNode: Could not guard on data-dependent expression u4 < 0 (unhinted: u4 < 0).  (Size-like symbols: none)
E                       
E                       Caused by: (_decomp/decompositions.py:730 in slice_forward)
E                       For more information, run with TORCH_LOGS="dynamic"
E                       For extended logs when we create symbols, also add TORCHDYNAMO_EXTENDED_DEBUG_CREATE_SYMBOL="u4"
E                       If you suspect the guard was triggered from C++, add TORCHDYNAMO_EXTENDED_DEBUG_CPP=1
E                       For more debugging help, see https://docs.google.com/document/d/1HSuTTVvYH1pTew89Rtpeu84Ht3nQEFTYhAX3Ypa_xJs/edit?usp=sharing
E                       
E                       For C++ stack trace, run with TORCHDYNAMO_EXTENDED_DEBUG_CPP=1
E                       
E                       While executing %slice_1 : [num_users=1] = call_function[target=torch.ops.aten.slice.Tensor](args = (%x, 0, %_local_scalar_dense, %add), kwargs = {})
E                       Original traceback:
E                         File "/Users/freknu01/repos/executorch/exir/program/test/test_program.py", line 307, in forward
E                           return x[z : z + y.shape[0]]

.venv/py310_et/lib/python3.10/site-packages/torch/fx/experimental/symbolic_shapes.py:6540: GuardOnDataDependentSymNode

[angelayi]

@freddan80 These operators should not get lowered to edge IR as executorch has their own way of treating them (code pointer). So it's not clear to me what error you were running into.

But I constructed a small example and found that the verifier is not passing on those ops, so I put up #8034 to fix it. Please let me know if you're still running into issues!