✨[Feature] Support negative dimension slicing in the dynamic shape case

[narendasan]

Is your feature request related to a problem? Please describe.

Patterns like this are starting to show up, starting with PyTorch 2.12. Presumably this is some thing similar to x[0:-2]. However, one of the values is a symbolic shape now.

2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion._TRTInterpreter - INFO - Converted node /neg [<built-in function neg>] (Inputs: (add_176: (((s65 - 1)//8)) + 1@SymInt) | Outputs: (neg: -(((s65 - 1)//8)) - 1@SymInt))
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion._TRTInterpreter - DEBUG - Converting node /slice_2 (kind: aten.slice.Tensor, args: ('full <Node>', '2 <int>', 'neg <Node>'))
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion._ConverterRegistry - DEBUG - Converter options for aten.slice.Tensor: 1
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion._ConverterRegistry - DEBUG - Selecting converter option 0 for converting aten.slice.Tensor
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion.impl.elementwise.base - INFO - skip broadcast for /slice_2_shape
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion.impl.elementwise.base - INFO - skip broadcast for /slice_2_sub_stop
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion.impl.elementwise.base - INFO - skip broadcast for /slice_2_sub_num
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion.impl.elementwise.base - INFO - skip broadcast for /slice_2_div
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion.impl.elementwise.base - INFO - skip broadcast for /slice_2_prod
2026-06-08 22:50:23 - root - DEBUG - add_slice(input=[ELEMENTWISE]-[aten_ops.full.default]-[/full_add]_output_full.default, start=(), shape=(), stride=())
2026-06-08 22:50:23 - root - DEBUG - (Unnamed Layer* 246) [Slice]
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion._TRTInterpreter - INFO - Converted node /slice_2 [aten.slice.Tensor] (Inputs: (full: (s79, (((s65 - 1)//8)) + 1, (((s65 - 1)//8)) + 1)@torch.bool, 2, neg: -(((s65 - 1)//8)) - 1@SymInt) | Outputs: (slice_2: (s79, (((s65 - 1)//8)) + 1, (((s65 - 1)//8)) + 1)@torch.bool))
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion._TRTInterpreter - DEBUG - Converting node /unsqueeze_21 (kind: aten.unsqueeze.default, args: ('gt_9 <Node>', '1 <int>'))
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion._ConverterRegistry - DEBUG - Converter options for aten.unsqueeze.default: 1
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion._ConverterRegistry - DEBUG - Selecting converter option 0 for converting aten.unsqueeze.default
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion._TRTInterpreter - INFO - Converted node /unsqueeze_21 [aten.unsqueeze.default] (Inputs: (gt_9: (s79, (((s65 - 1)//8)) + 1)@torch.bool, 1) | Outputs: (unsqueeze_21: (s79, 1, (((s65 - 1)//8)) + 1)@torch.bool))
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion._TRTInterpreter - DEBUG - Converting node /bitwise_and (kind: aten.bitwise_and.Tensor, args: ('slice_2 <Node>', 'unsqueeze_21 <Node>'))
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion._ConverterRegistry - DEBUG - Converter options for aten.bitwise_and.Tensor: 1
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion._ConverterRegistry - DEBUG - Selecting converter option 0 for converting aten.bitwise_and.Tensor
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion.impl.elementwise.base - INFO - skip broadcast for /bitwise_and_logical_and
2026-06-08 22:50:23 - torch_tensorrt.dynamo.conversion._TRTInterpreter - INFO - Converted node /bitwise_and [aten.bitwise_and.Tensor] (Inputs: (slice_2: (s79, (((s65 - 1)//8)) + 1, (((s65 - 1)//8)) + 1)@torch.bool, unsqueeze_21: (s79, 1, (((s65 - 1)//8)) + 1)@torch.bool) | Outputs: (bitwise_and: (s79, (((s65 - 1)//8)) + 1, (((s65 - 1)//8)) + 1)@torch.bool))

Describe the solution you'd like

Detect these cases and insert the math to calculate the correct ending dimension

Describe alternatives you've considered

Additional context

[narendasan]

cc @shahe-nv

[narendasan]

Various patches to Canary I applied to get to this case:

import operator
from typing import Dict, Sequence, Tuple, Union

import torch
import torch_tensorrt
import operator
from torch.fx.node import Argument, Target
from torch_tensorrt.dynamo import SourceIR
from torch_tensorrt.dynamo.conversion import ConversionContext, impl
from torch_tensorrt.dynamo.conversion  import dynamo_tensorrt_converter
from torch_tensorrt.dynamo.types import TRTTensor


@dynamo_tensorrt_converter(operator.neg, supports_dynamic_shapes=True)
def aten_ops_operator_neg(
    ctx: ConversionContext,
    target: Target,
    args: Tuple[Argument, ...],
    kwargs: Dict[str, Argument],
    name: str,
) -> Union[TRTTensor, Sequence[TRTTensor]]:
    return impl.unary.neg(ctx, target, SourceIR.ATEN, name, args[0])

@dynamo_tensorrt_converter(torch.sym_min, supports_dynamic_shapes=True)
def aten_ops_sym_min(
    ctx: ConversionContext,
    target: Target,
    args: Tuple[Argument, ...],
    kwargs: Dict[str, Argument],
    name: str,
) -> Union[TRTTensor, Sequence[TRTTensor]]:
    return impl.elementwise.min(ctx, target, SourceIR.ATEN, name, args[0], args[1])

import logging
from typing import Sequence

import torch

from torch_tensorrt.dynamo.lowering.passes._aten_lowering_pass import _aten_lowering_pass

logger = logging.getLogger(__name__)

_INT64_MAX = 9223372036854775807

# Unclear if this is necessary
@_aten_lowering_pass
def eliminate_sym_min_int64_max(
    gm: torch.fx.GraphModule,
    sample_inputs: Sequence[torch.Tensor],
) -> torch.fx.GraphModule:
    """Remove sym_min nodes where one operand is INT64_MAX — always a no-op."""
    count = 0
    for node in list(gm.graph.nodes):
        if node.op != "call_function" or node.target is not torch.sym_min:
            continue

        lhs, rhs = node.args[0], node.args[1]

        if rhs == _INT64_MAX:
            passthrough = lhs
        elif lhs == _INT64_MAX:
            passthrough = rhs
        else:
            continue

        node.replace_all_uses_with(passthrough)
        gm.graph.erase_node(node)
        count += 1

    if count > 0:
        gm.graph.lint()
        gm.recompile()

    logger.debug("Eliminated %d no-op sym_min(x, INT64_MAX) node(s)", count)
    return gm

[narendasan]

@micwill755 We could consider trying to do a bit of this work in lowering perhaps. I think the crux is determining if the sym_int is negative and then inserting the computation to do len(dim) + symint (where sym_int is negative)