//===----------------------------------------------------------------------===//
// L2Loss op patterns.
//===----------------------------------------------------------------------===//

def GetAllAxes : NativeCodeCall<
  "GetI64ElementsAttrForSeq("
  "0, $0.getType().cast<RankedTensorType>().getRank(), &$_builder)">;

// L2Loss is lowered using the formula,
// L2Loss(input) = Sum(input * input) / 2

using ops::Conv2D;
using ops::Conv2DBackpropInput;
using ops::DepthwiseConv2dNative;
using ops::Elu;
using ops::FractionalAvgPool;
using ops::FractionalMaxPool;
using ops::FusedBatchNormV3;
using ops::L2Loss;
using ops::LogSoftmax;
using ops::LRN;
using ops::MaxPool;
using ops::MaxPool3D;
using ops::MaxPoolV2;
using ops::Placeholder;
using ops::Relu;
using ops::Relu6;
using ops::Selu;
using ops::Softmax;

 TensorArrayV3 8
 TensorArrayWriteV3 9
 Unique 2
 VariableV2 164
 _Retval 5
cluster 0 size 440
 Abs 40
 AddN 1
 Any 41
 Cast 40
 ConcatV2 2
 Const 95
 ExpandDims 2
 IsInf 1
 IsNan 40
 L2Loss 40
 LogicalOr 1
 Max 41
 Minimum 1
 Mul 82
 Pack 3
 Reciprocal 2
 Reshape 2
 ReverseSequence 1
 Sqrt 1
 Sum 1
 Transpose 3
cluster 1 size 86
 BroadcastGradientArgs 1
 Cast 5
 ConcatV2 1

                  std::vector<Output>* grad_outputs) {
  grad_outputs->push_back(Mul(scope, op.input(0), grad_inputs[0]));
  return scope.status();
}
REGISTER_GRADIENT_OP("L2Loss", L2LossGrad);

Status BiasAddGradHelper(const Scope& scope, const Operation& op,
                         const std::vector<Output>& grad_inputs,
                         std::vector<Output>* grad_outputs) {

  %0 = "tf.L2Loss"(%arg0) : (tensor<?x?xf32>) -> tensor<f32>

  // CHECK: return %[[LOSS]] : tensor<f32>
  func.return %0 : tensor<f32>
}

// CHECK-LABEL: func @l2_loss_unranked
func.func @l2_loss_unranked(%arg0: tensor<*xf32>) -> tensor<f32> {
  // CHECK: tf.L2Loss
  %0 = "tf.L2Loss"(%arg0) : (tensor<*xf32>) -> tensor<f32>
  func.return %0 : tensor<f32>
}

      "GatherV2",
      "HSVToRGB",
      "IFFT",
      "IFFT2D",
      "IFFT3D",
      "IRFFT",
      "IRFFT2D",
      "IRFFT3D",
      "If",
      "InTopKV2",
      "L2Loss",
      "LeakyRelu",
      "LinSpace",
      "ListDiff",
      "LogMatrixDeterminant",
      "LowerBound",
      "MatMul",
      "MatrixBandPart",
      "MatrixDiag",
      "MatrixDiagPart",

  );

  TF_DerivedOperandTypeAttr T = TF_DerivedOperandTypeAttr<0>;
}


def TF_L2LossOp : TF_Op<"L2Loss", [Pure]> {
  let summary = "L2 Loss.";

  let description = [{
Computes half the L2 norm of a tensor without the `sqrt`:

    output = sum(t ** 2) / 2
  }];

  let arguments = (ins