Method HandleSlice

tensorflow/compiler/xla/service/algebraic_simplifier.cc:3322–3472

}

Status AlgebraicSimplifierVisitor::HandleSlice(HloInstruction* slice) {
  // Delete no-op slices, i.e. where shape = operand shape.
  if (ReplaceInstructionIfSameShape(slice, slice->mutable_operand(0))) {
    return Status::OK();
  }

  HloInstruction* pad;
  HloInstruction* pad_operand;
  if (Match(slice, m::Slice(m::Pad(&pad, m::Op(&pad_operand), m::Op())))) {
    // Is the result of the slice the pad operand.
    bool slice_undoes_pad = true;
    // Can the slice be moved to the pad_operand without any padding being read.
    bool slice_inside_pad = true;
    // Does this slice slice out pading only.
    bool slice_in_padding = false;
    std::vector<int64> new_starts = slice->slice_starts();
    std::vector<int64> new_limits = slice->slice_limits();
    for (int64 i = 0; i < slice->shape().rank(); ++i) {
      const int64 start = slice->slice_starts(i);
      const int64 stride = slice->slice_strides(i);
      const int64 limit = slice->slice_limits(i);
      const int64 size = pad->shape().dimensions(i);

      const auto& dim = pad->padding_config().dimensions(i);
      const int64 low = dim.edge_padding_low();
      const int64 high = dim.edge_padding_high();
      const int64 interior = dim.interior_padding();
      const int64 edge = size - high;

      if (limit <= low || start >= edge) {
        slice_in_padding = true;
        break;
      }

      if (start != low || stride - 1 != interior) {
        slice_undoes_pad = false;
      }

      if (start < low || limit > edge || interior != 0 || stride != 1) {
        slice_inside_pad = false;
      }
      new_starts[i] -= low;
      new_limits[i] -= low;
    }
    if (slice_in_padding) {
      return ReplaceInstruction(
          slice, MakeBroadcastHlo(pad->mutable_operand(1), {}, slice->shape()));
    }
    if (slice_undoes_pad && ReplaceInstructionIfSameShape(slice, pad_operand)) {
      return Status::OK();
    }
    if (slice_inside_pad) {
      TF_ASSIGN_OR_RETURN(HloInstruction * new_slice,
                          MakeSliceHlo(pad_operand, new_starts, new_limits,
                                       slice->slice_strides()));
      return ReplaceInstruction(slice, new_slice);
    }
  }