Run clang-format for TosaDeserialize.cpp and TosaSerialize.cpp

Signed-off-by: Jerry Ge <jerry.ge@arm.com>
Change-Id: Ia42e457222b1c81732bfcec2b729f295b17d4e81

2 files changed, 243 insertions, 212 deletions

diff --git a/src/TosaDeserialize.cpp b/src/TosaDeserialize.cpp
index 196c8f6..ab60a26 100644
--- a/src/TosaDeserialize.cpp
+++ b/src/TosaDeserialize.cpp
@@ -92,7 +92,8 @@ mlir::LogicalResult BuildTensorType(mlir::OpBuilder *op_builder,
                  << "\n";
     return mlir::failure();
   }
-  llvm::SmallVector<int64_t> shape(ts->GetShape().begin(), ts->GetShape().end());
+  llvm::SmallVector<int64_t> shape(ts->GetShape().begin(),
+                                   ts->GetShape().end());
   type = mlir::RankedTensorType::get(llvm::makeArrayRef(shape), element_type);
   return mlir::success();
 }
@@ -218,116 +219,143 @@ private:
 
 // Main template to catch unimplemented translation
 template <Op OPCODE>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build(TosaSerializationOperator* op) const
-{
-    llvm::errs() << "ERROR: " << get_string(op) << " translation hasn't been implemented\n";
-    return {};
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build(TosaSerializationOperator *op) const {
+  llvm::errs() << "ERROR: " << get_string(op)
+               << " translation hasn't been implemented\n";
+  return {};
 }
 
 // BUILD_OP_POOL2D(MaxPool2d, MAX_POOL2D)
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_MAX_POOL2D>(TosaSerializationOperator* op) const
-{
-    mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
-    mlir::RankedTensorType output_type = tensor_type_map->at(op->GetOutputTensorNames()[0]);
-    assert(op->GetAttributeType() == Attribute_PoolAttribute); // double check attribute type
-    TosaPoolAttribute* attr = static_cast<TosaPoolAttribute*>(op->GetAttribute());
-    mlir::DenseI64ArrayAttr kernel = BuildDenseI64ArrayAttr(op_builder, attr->kernel());
-    mlir::DenseI64ArrayAttr stride = BuildDenseI64ArrayAttr(op_builder, attr->stride());
-    mlir::DenseI64ArrayAttr pad = BuildDenseI64ArrayAttr(op_builder, attr->pad());
-    int32_t input_zp = attr->input_zp();
-    int32_t output_zp = attr->output_zp();
-    assert(input_zp == 0 && output_zp == 0);
-
-    mlir::Operation* mlir_op = op_builder->create<mlir::tosa::MaxPool2dOp>(loc, output_type, input_val, kernel, stride, pad);
-    block->push_back(mlir_op);
-    return std::vector<mlir::Value>({ mlir_op->getResult(0) });
+std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_MAX_POOL2D>(
+    TosaSerializationOperator *op) const {
+  mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
+  mlir::RankedTensorType output_type =
+      tensor_type_map->at(op->GetOutputTensorNames()[0]);
+  assert(op->GetAttributeType() ==
+         Attribute_PoolAttribute); // double check attribute type
+  TosaPoolAttribute *attr =
+      static_cast<TosaPoolAttribute *>(op->GetAttribute());
+  mlir::DenseI64ArrayAttr kernel =
+      BuildDenseI64ArrayAttr(op_builder, attr->kernel());
+  mlir::DenseI64ArrayAttr stride =
+      BuildDenseI64ArrayAttr(op_builder, attr->stride());
+  mlir::DenseI64ArrayAttr pad = BuildDenseI64ArrayAttr(op_builder, attr->pad());
+  int32_t input_zp = attr->input_zp();
+  int32_t output_zp = attr->output_zp();
+  assert(input_zp == 0 && output_zp == 0);
+
+  mlir::Operation *mlir_op = op_builder->create<mlir::tosa::MaxPool2dOp>(
+      loc, output_type, input_val, kernel, stride, pad);
+  block->push_back(mlir_op);
+  return std::vector<mlir::Value>({mlir_op->getResult(0)});
 }
 
 // BUILD_OP_POOL2D(AvgPool2d, AVG_POOL2D)
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_AVG_POOL2D>(TosaSerializationOperator* op) const
-{
-    mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
-    mlir::RankedTensorType output_type = tensor_type_map->at(op->GetOutputTensorNames()[0]);
-    assert(op->GetAttributeType() == Attribute_PoolAttribute); // double check attribute type
-    TosaPoolAttribute* attr = static_cast<TosaPoolAttribute*>(op->GetAttribute());
-    mlir::DenseI64ArrayAttr kernel = BuildDenseI64ArrayAttr(op_builder, attr->kernel());
-    mlir::DenseI64ArrayAttr stride = BuildDenseI64ArrayAttr(op_builder, attr->stride());
-    mlir::DenseI64ArrayAttr pad = BuildDenseI64ArrayAttr(op_builder, attr->pad());
-    int32_t input_zp = attr->input_zp();
-    int32_t output_zp = attr->output_zp();
-    mlir::Operation* mlir_op;
-    if (input_zp == 0 && output_zp == 0) {
-      mlir_op = op_builder->create<mlir::tosa::AvgPool2dOp>(loc, output_type, input_val, kernel, stride, pad);
-    } else {
-      auto quant = op_builder->getAttr<mlir::tosa::UnaryOpQuantizationAttr>(input_zp, output_zp);
-      mlir_op = op_builder->create<mlir::tosa::AvgPool2dOp>(loc, output_type, input_val, kernel, stride, pad, quant);
-    }
-    block->push_back(mlir_op);
-    return std::vector<mlir::Value>({ mlir_op->getResult(0) });
+std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_AVG_POOL2D>(
+    TosaSerializationOperator *op) const {
+  mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
+  mlir::RankedTensorType output_type =
+      tensor_type_map->at(op->GetOutputTensorNames()[0]);
+  assert(op->GetAttributeType() ==
+         Attribute_PoolAttribute); // double check attribute type
+  TosaPoolAttribute *attr =
+      static_cast<TosaPoolAttribute *>(op->GetAttribute());
+  mlir::DenseI64ArrayAttr kernel =
+      BuildDenseI64ArrayAttr(op_builder, attr->kernel());
+  mlir::DenseI64ArrayAttr stride =
+      BuildDenseI64ArrayAttr(op_builder, attr->stride());
+  mlir::DenseI64ArrayAttr pad = BuildDenseI64ArrayAttr(op_builder, attr->pad());
+  int32_t input_zp = attr->input_zp();
+  int32_t output_zp = attr->output_zp();
+  mlir::Operation *mlir_op;
+  if (input_zp == 0 && output_zp == 0) {
+    mlir_op = op_builder->create<mlir::tosa::AvgPool2dOp>(
+        loc, output_type, input_val, kernel, stride, pad);
+  } else {
+    auto quant = op_builder->getAttr<mlir::tosa::UnaryOpQuantizationAttr>(
+        input_zp, output_zp);
+    mlir_op = op_builder->create<mlir::tosa::AvgPool2dOp>(
+        loc, output_type, input_val, kernel, stride, pad, quant);
+  }
+  block->push_back(mlir_op);
+  return std::vector<mlir::Value>({mlir_op->getResult(0)});
 }
 
 template <class MLIR_OP>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::BuildEwiseUnaryOp(TosaSerializationOperator* op) const
-{
-    mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
-    mlir::RankedTensorType output_type = tensor_type_map->at(op->GetOutputTensorNames()[0]);
-    assert(op->GetAttributeType() == Attribute_NONE); // double check that there is no attribute
-
-    mlir::Operation* mlir_op = op_builder->create<MLIR_OP>(loc, output_type, input_val);
-    block->push_back(mlir_op);
-    return std::vector<mlir::Value>({ mlir_op->getResult(0) });
+std::vector<mlir::Value> TosaMlirOperatorBuilder::BuildEwiseUnaryOp(
+    TosaSerializationOperator *op) const {
+  mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
+  mlir::RankedTensorType output_type =
+      tensor_type_map->at(op->GetOutputTensorNames()[0]);
+  assert(op->GetAttributeType() ==
+         Attribute_NONE); // double check that there is no attribute
+
+  mlir::Operation *mlir_op =
+      op_builder->create<MLIR_OP>(loc, output_type, input_val);
+  block->push_back(mlir_op);
+  return std::vector<mlir::Value>({mlir_op->getResult(0)});
 }
 
 template <class MLIR_OP>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::BuildEwiseBinaryOp(TosaSerializationOperator* op) const
-{
-    mlir::Value input0_val = tensor_map->at(op->GetInputTensorNames()[0]);
-    mlir::Value input1_val = tensor_map->at(op->GetInputTensorNames()[1]);
-    mlir::RankedTensorType output_type = tensor_type_map->at(op->GetOutputTensorNames()[0]);
-    assert(op->GetAttributeType() == Attribute_NONE); // double check that there is no attribute
-
-    mlir::Operation* mlir_op = op_builder->create<MLIR_OP>(loc, output_type, input0_val, input1_val);
-    block->push_back(mlir_op);
-    return std::vector<mlir::Value>({ mlir_op->getResult(0) });
+std::vector<mlir::Value> TosaMlirOperatorBuilder::BuildEwiseBinaryOp(
+    TosaSerializationOperator *op) const {
+  mlir::Value input0_val = tensor_map->at(op->GetInputTensorNames()[0]);
+  mlir::Value input1_val = tensor_map->at(op->GetInputTensorNames()[1]);
+  mlir::RankedTensorType output_type =
+      tensor_type_map->at(op->GetOutputTensorNames()[0]);
+  assert(op->GetAttributeType() ==
+         Attribute_NONE); // double check that there is no attribute
+
+  mlir::Operation *mlir_op =
+      op_builder->create<MLIR_OP>(loc, output_type, input0_val, input1_val);
+  block->push_back(mlir_op);
+  return std::vector<mlir::Value>({mlir_op->getResult(0)});
 }
 
 template <class MLIR_OP>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::BuildReductionOp(TosaSerializationOperator* op) const
-{
-    mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
-    mlir::RankedTensorType output_type = tensor_type_map->at(op->GetOutputTensorNames()[0]);
-    assert(op->GetAttributeType() == Attribute_AxisAttribute); // double check attribute type
-
-    TosaAxisAttribute* attr = static_cast<TosaAxisAttribute*>(op->GetAttribute());
-    auto axis = op_builder->getI64IntegerAttr(attr->axis());
-
-    mlir::Operation *mlir_op =
-        op_builder->create<MLIR_OP>(loc, output_type, input_val, axis);
-    block->push_back(mlir_op);
-    return std::vector<mlir::Value>({ mlir_op->getResult(0) });
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::BuildReductionOp(TosaSerializationOperator *op) const {
+  mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
+  mlir::RankedTensorType output_type =
+      tensor_type_map->at(op->GetOutputTensorNames()[0]);
+  assert(op->GetAttributeType() ==
+         Attribute_AxisAttribute); // double check attribute type
+
+  TosaAxisAttribute *attr =
+      static_cast<TosaAxisAttribute *>(op->GetAttribute());
+  auto axis = op_builder->getI64IntegerAttr(attr->axis());
+
+  mlir::Operation *mlir_op =
+      op_builder->create<MLIR_OP>(loc, output_type, input_val, axis);
+  block->push_back(mlir_op);
+  return std::vector<mlir::Value>({mlir_op->getResult(0)});
 }
 
-#define BUILD_OP_ELEMENTWISE_UNARY(MLIR_OP_NAME, SCHEMA_OP_NAME)                  \
-  template <>                                                                     \
-  std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_##SCHEMA_OP_NAME>(   \
-      TosaSerializationOperator* op) const {                                      \
-    return BuildEwiseUnaryOp<mlir::tosa::MLIR_OP_NAME##Op>(op);                   \
+#define BUILD_OP_ELEMENTWISE_UNARY(MLIR_OP_NAME, SCHEMA_OP_NAME)               \
+  template <>                                                                  \
+  std::vector<mlir::Value>                                                     \
+  TosaMlirOperatorBuilder::build<Op_##SCHEMA_OP_NAME>(                         \
+      TosaSerializationOperator * op) const {                                  \
+    return BuildEwiseUnaryOp<mlir::tosa::MLIR_OP_NAME##Op>(op);                \
   }
 
-#define BUILD_OP_ELEMENTWISE_BINARY(MLIR_OP_NAME, SCHEMA_OP_NAME)                 \
-  template <>                                                                     \
-  std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_##SCHEMA_OP_NAME>(   \
-      TosaSerializationOperator* op) const {                                      \
-    return BuildEwiseBinaryOp<mlir::tosa::MLIR_OP_NAME##Op>(op);                  \
+#define BUILD_OP_ELEMENTWISE_BINARY(MLIR_OP_NAME, SCHEMA_OP_NAME)              \
+  template <>                                                                  \
+  std::vector<mlir::Value>                                                     \
+  TosaMlirOperatorBuilder::build<Op_##SCHEMA_OP_NAME>(                         \
+      TosaSerializationOperator * op) const {                                  \
+    return BuildEwiseBinaryOp<mlir::tosa::MLIR_OP_NAME##Op>(op);               \
   }
 
-#define BUILD_OP_REDUCTION(MLIR_OP_NAME, SCHEMA_OP_NAME)                          \
-  template <>                                                                     \
-  std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_##SCHEMA_OP_NAME>(   \
-      TosaSerializationOperator* op) const {                                      \
-    return BuildReductionOp<mlir::tosa::MLIR_OP_NAME##Op>(op);                    \
+#define BUILD_OP_REDUCTION(MLIR_OP_NAME, SCHEMA_OP_NAME)                       \
+  template <>                                                                  \
+  std::vector<mlir::Value>                                                     \
+  TosaMlirOperatorBuilder::build<Op_##SCHEMA_OP_NAME>(                         \
+      TosaSerializationOperator * op) const {                                  \
+    return BuildReductionOp<mlir::tosa::MLIR_OP_NAME##Op>(op);                 \
   }
 
 // BUILD_OP_POOL2D(MaxPool2d, MAX_POOL2D)
@@ -376,8 +404,8 @@ BUILD_OP_ELEMENTWISE_UNARY(Identity, IDENTITY)
 BUILD_OP_ELEMENTWISE_UNARY(Cast, CAST)
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_CONST>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build<Op_CONST>(TosaSerializationOperator *op) const {
   const auto &output_name = op->GetOutputTensorNames()[0];
   mlir::RankedTensorType output_type = tensor_type_map->at(output_name);
   TosaSerializationTensor *ts = ser_block->GetTensorByName(output_name);
@@ -502,8 +530,8 @@ BUILD_OP_CONV(Conv3D, CONV3D)
 BUILD_OP_CONV(DepthwiseConv2D, DEPTHWISE_CONV2D)
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_TRANSPOSE_CONV2D>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_TRANSPOSE_CONV2D>(
+    TosaSerializationOperator *op) const {
   mlir::Value input0_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::Value input1_val = tensor_map->at(op->GetInputTensorNames()[1]);
   mlir::Value input2_val = tensor_map->at(op->GetInputTensorNames()[2]);
@@ -543,8 +571,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_TRANSPOSE_CONV2D>(Tos
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_FULLY_CONNECTED>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_FULLY_CONNECTED>(
+    TosaSerializationOperator *op) const {
   mlir::Value input0_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::Value input1_val = tensor_map->at(op->GetInputTensorNames()[1]);
   mlir::Value input2_val = tensor_map->at(op->GetInputTensorNames()[2]);
@@ -576,8 +604,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_FULLY_CONNECTED>(Tosa
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_MATMUL>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build<Op_MATMUL>(TosaSerializationOperator *op) const {
   mlir::Value input0_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::Value input1_val = tensor_map->at(op->GetInputTensorNames()[1]);
   mlir::RankedTensorType output_type =
@@ -605,8 +633,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_MATMUL>(TosaSerializa
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_SELECT>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build<Op_SELECT>(TosaSerializationOperator *op) const {
   mlir::Value input0_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::Value input1_val = tensor_map->at(op->GetInputTensorNames()[1]);
   mlir::Value input2_val = tensor_map->at(op->GetInputTensorNames()[2]);
@@ -623,8 +651,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_SELECT>(TosaSerializa
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_CLAMP>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build<Op_CLAMP>(TosaSerializationOperator *op) const {
   mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::RankedTensorType output_type =
       tensor_type_map->at(op->GetOutputTensorNames()[0]);
@@ -649,8 +677,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_CLAMP>(TosaSerializat
 BUILD_OP_REDUCTION(ArgMax, ARGMAX)
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_CONCAT>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build<Op_CONCAT>(TosaSerializationOperator *op) const {
   mlir::RankedTensorType output_type =
       tensor_type_map->at(op->GetOutputTensorNames()[0]);
 
@@ -673,8 +701,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_CONCAT>(TosaSerializa
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_NEGATE>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build<Op_NEGATE>(TosaSerializationOperator *op) const {
   mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::RankedTensorType output_type =
       tensor_type_map->at(op->GetOutputTensorNames()[0]);
@@ -703,8 +731,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_NEGATE>(TosaSerializa
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_RESHAPE>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_RESHAPE>(
+    TosaSerializationOperator *op) const {
   mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::RankedTensorType output_type =
       tensor_type_map->at(op->GetOutputTensorNames()[0]);
@@ -724,8 +752,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_RESHAPE>(TosaSerializ
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_PAD>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build<Op_PAD>(TosaSerializationOperator *op) const {
   mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::RankedTensorType output_type =
       tensor_type_map->at(op->GetOutputTensorNames()[0]);
@@ -782,8 +810,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_PAD>(TosaSerializatio
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_TRANSPOSE>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_TRANSPOSE>(
+    TosaSerializationOperator *op) const {
   mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::RankedTensorType output_type =
       tensor_type_map->at(op->GetOutputTensorNames()[0]);
@@ -812,8 +840,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_TRANSPOSE>(TosaSerial
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_SLICE>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build<Op_SLICE>(TosaSerializationOperator *op) const {
   mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::RankedTensorType output_type =
       tensor_type_map->at(op->GetOutputTensorNames()[0]);
@@ -835,8 +863,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_SLICE>(TosaSerializat
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_TILE>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build<Op_TILE>(TosaSerializationOperator *op) const {
   mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::RankedTensorType output_type =
       tensor_type_map->at(op->GetOutputTensorNames()[0]);
@@ -859,8 +887,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_TILE>(TosaSerializati
 BUILD_OP_ELEMENTWISE_BINARY(Gather, GATHER)
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_SCATTER>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_SCATTER>(
+    TosaSerializationOperator *op) const {
   mlir::Value input0_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::Value input1_val = tensor_map->at(op->GetInputTensorNames()[1]);
   mlir::Value input2_val = tensor_map->at(op->GetInputTensorNames()[2]);
@@ -876,8 +904,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_SCATTER>(TosaSerializ
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_RESIZE>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build<Op_RESIZE>(TosaSerializationOperator *op) const {
   mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::RankedTensorType output_type =
       tensor_type_map->at(op->GetOutputTensorNames()[0]);
@@ -905,8 +933,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_RESIZE>(TosaSerializa
 BUILD_OP_REDUCTION(Reverse, REVERSE)
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_MUL>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build<Op_MUL>(TosaSerializationOperator *op) const {
   mlir::Value input0_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::Value input1_val = tensor_map->at(op->GetInputTensorNames()[1]);
   mlir::RankedTensorType output_type =
@@ -925,8 +953,9 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_MUL>(TosaSerializatio
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_ARITHMETIC_RIGHT_SHIFT>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build<Op_ARITHMETIC_RIGHT_SHIFT>(
+    TosaSerializationOperator *op) const {
   mlir::Value input0_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::Value input1_val = tensor_map->at(op->GetInputTensorNames()[1]);
   mlir::RankedTensorType output_type =
@@ -948,8 +977,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_ARITHMETIC_RIGHT_SHIF
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_TABLE>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build<Op_TABLE>(TosaSerializationOperator *op) const {
   mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::RankedTensorType output_type =
       tensor_type_map->at(op->GetOutputTensorNames()[0]);
@@ -977,8 +1006,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_TABLE>(TosaSerializat
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_RESCALE>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_RESCALE>(
+    TosaSerializationOperator *op) const {
   mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::RankedTensorType output_type =
       tensor_type_map->at(op->GetOutputTensorNames()[0]);
@@ -1006,8 +1035,8 @@ std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_RESCALE>(TosaSerializ
 }
 
 template <>
-std::vector<mlir::Value> TosaMlirOperatorBuilder::build<Op_CUSTOM>(TosaSerializationOperator* op) const
-{
+std::vector<mlir::Value>
+TosaMlirOperatorBuilder::build<Op_CUSTOM>(TosaSerializationOperator *op) const {
   mlir::Value input_val = tensor_map->at(op->GetInputTensorNames()[0]);
   mlir::RankedTensorType output_type =
       tensor_type_map->at(op->GetOutputTensorNames()[0]);
@@ -1062,8 +1091,7 @@ TosaMlirOperatorBuilder::build<Op_FFT2D>(TosaSerializationOperator *op) const {
       tensor_type_map->at(op->GetOutputTensorNames()[1]);
 
   assert(op->GetAttributeType() == Attribute_FFTAttribute);
-  TosaFFTAttribute *attr =
-    static_cast<TosaFFTAttribute *>(op->GetAttribute());
+  TosaFFTAttribute *attr = static_cast<TosaFFTAttribute *>(op->GetAttribute());
   auto inverse = op_builder->getBoolAttr(attr->inverse());
 
   mlir::Operation *mlir_op = op_builder->create<mlir::tosa::FFT2dOp>(
@@ -1089,9 +1117,10 @@ public:
     }
   }
 
-  mlir::LogicalResult BuildAllBlocksInRegion(std::vector<mlir::Value>& return_values);
+  mlir::LogicalResult
+  BuildAllBlocksInRegion(std::vector<mlir::Value> &return_values);
 
-  mlir::OpBuilder* GetOpBuilder() { return op_builder; }
+  mlir::OpBuilder *GetOpBuilder() { return op_builder; }
   mlir::Location GetLocation() { return loc; }
   std::unordered_map<std::string, mlir::Value> &GetTensorMap() {
     return tensor_map;
@@ -1099,26 +1128,25 @@ public:
   TosaSerializationHandler *GetTsh() const { return tsh; }
 
 private:
-  mlir::Region* region;
-  TosaSerializationRegion* ser_region;
-  TosaSerializationHandler* tsh;
-  mlir::OpBuilder* op_builder;
+  mlir::Region *region;
+  TosaSerializationRegion *ser_region;
+  TosaSerializationHandler *tsh;
+  mlir::OpBuilder *op_builder;
   mlir::Location loc;
   std::unordered_map<std::string, mlir::Value> tensor_map;
 };
 
 class TosaMlirBlockBuilder {
 public:
-  TosaMlirBlockBuilder(TosaSerializationBasicBlock* _ser_block,
-                       TosaMlirRegionBuilder* _region_builder,
-                       mlir::Block* _block)
+  TosaMlirBlockBuilder(TosaSerializationBasicBlock *_ser_block,
+                       TosaMlirRegionBuilder *_region_builder,
+                       mlir::Block *_block)
       : ser_block(_ser_block), region_builder(_region_builder), block(_block) {}
 
-
   mlir::LogicalResult
-  BuildAllOpsInBlock(std::vector<mlir::Value>& return_values);
+  BuildAllOpsInBlock(std::vector<mlir::Value> &return_values);
 
-  mlir::OpBuilder* GetOpBuilder() { return region_builder->GetOpBuilder(); }
+  mlir::OpBuilder *GetOpBuilder() { return region_builder->GetOpBuilder(); }
   mlir::Location GetLocation() { return region_builder->GetLocation(); }
   std::unordered_map<std::string, mlir::Value> &GetTensorMap() {
     return region_builder->GetTensorMap();
@@ -1128,9 +1156,9 @@ public:
   TosaMlirRegionBuilder *GetRegionBuilder() const { return region_builder; }
 
 private:
-  TosaSerializationBasicBlock* ser_block;
-  TosaMlirRegionBuilder* region_builder;
-  mlir::Block* block;
+  TosaSerializationBasicBlock *ser_block;
+  TosaMlirRegionBuilder *region_builder;
+  mlir::Block *block;
   std::unordered_map<std::string, mlir::RankedTensorType> tensor_type_map;
 };
 
@@ -1295,7 +1323,7 @@ mlir::LogicalResult TosaMlirBlockBuilder::BuildAllOpsInBlock(
   auto &tensor_map = GetTensorMap();
 
   std::unordered_set<TosaSerializationOperator *> operator_built;
-  std::queue<TosaSerializationOperator*> operator_queue;
+  std::queue<TosaSerializationOperator *> operator_queue;
 
   TosaMlirOperatorBuilder tosa_op_builder(op_builder, ser_block, block, loc,
                                           this, &tensor_map, &tensor_type_map);
@@ -1305,7 +1333,7 @@ mlir::LogicalResult TosaMlirBlockBuilder::BuildAllOpsInBlock(
     if (BuildTensorType(op_builder, ts, type).failed()) {
       return mlir::failure();
     }
-    const auto& ts_name = ts->GetName();
+    const auto &ts_name = ts->GetName();
     tensor_type_map[ts_name] = type;
   }
 
@@ -1318,7 +1346,7 @@ mlir::LogicalResult TosaMlirBlockBuilder::BuildAllOpsInBlock(
         continue;
       }
       bool all_inputs_ready = true;
-      for (const auto& input_name : consumer_op->GetInputTensorNames()) {
+      for (const auto &input_name : consumer_op->GetInputTensorNames()) {
         if (!tensor_map.count(input_name)) {
           all_inputs_ready = false;
           break;
@@ -1331,11 +1359,12 @@ mlir::LogicalResult TosaMlirBlockBuilder::BuildAllOpsInBlock(
   };
 
   // Initialize tensor_map/operator_queue based on block input arguments
-  for (const std::string& block_input_name : ser_block->GetInputs()) {
+  for (const std::string &block_input_name : ser_block->GetInputs()) {
     auto type = tensor_type_map[block_input_name];
     auto input_value = block->addArgument(type, loc);
     if (tensor_map.count(block_input_name)) {
-      llvm::errs() << "ERROR: block input tensor " << block_input_name << " already exists\n";
+      llvm::errs() << "ERROR: block input tensor " << block_input_name
+                   << " already exists\n";
       return mlir::failure();
     }
     tensor_map[block_input_name] = input_value;
@@ -1344,12 +1373,13 @@ mlir::LogicalResult TosaMlirBlockBuilder::BuildAllOpsInBlock(
   queue_ready_operators();
 
   while (!operator_queue.empty()) {
-    TosaSerializationOperator* op = operator_queue.front();
+    TosaSerializationOperator *op = operator_queue.front();
     operator_queue.pop();
 
     // skip if operator has been built
     if (operator_built.count(op)) {
-      // this happens when same input appears twice or more in operator, eg, concat(%0, %0)
+      // this happens when same input appears twice or more in operator, eg,
+      // concat(%0, %0)
       continue;
     }
     operator_built.insert(op);
@@ -1357,20 +1387,22 @@ mlir::LogicalResult TosaMlirBlockBuilder::BuildAllOpsInBlock(
     std::vector<mlir::Value> output_values;
     if (false) {
     }
-#define DEF_SCHEMA_OPERATOR(SCHEMA_OP_NAME)                                     \
-    else if (op->GetOp() == Op_##SCHEMA_OP_NAME) {                              \
-      output_values = tosa_op_builder.build<Op_##SCHEMA_OP_NAME>(op);           \
-    }
+#define DEF_SCHEMA_OPERATOR(SCHEMA_OP_NAME)                                    \
+  else if (op->GetOp() == Op_##SCHEMA_OP_NAME) {                               \
+    output_values = tosa_op_builder.build<Op_##SCHEMA_OP_NAME>(op);            \
+  }
 #include "schema_operator.def"
 #undef DEF_SCHEMA_OPERATOR
     else {
-      llvm::errs() << "ERROR: unsupported opcode=" << EnumNamesOp()[op->GetOp()] << "\n";
+      llvm::errs() << "ERROR: unsupported opcode=" << EnumNamesOp()[op->GetOp()]
+                   << "\n";
       return mlir::failure();
     }
 
     // Sanity check if number of built mlir::Value is expected
     if (op->GetOutputTensorNames().size() != output_values.size()) {
-      llvm::errs() << "ERROR: number of built mlir::Value is not matching number of operator output tensor\n";
+      llvm::errs() << "ERROR: number of built mlir::Value is not matching "
+                      "number of operator output tensor\n";
       return mlir::failure();
     }
 
@@ -1378,7 +1410,8 @@ mlir::LogicalResult TosaMlirBlockBuilder::BuildAllOpsInBlock(
       // Sanity check tensor hasn't been built
       std::string op_output_name = op->GetOutputTensorNames()[i];
       if (tensor_map.count(op_output_name)) {
-        llvm::errs() << "ERROR: tensor " << op_output_name << " is already built\n";
+        llvm::errs() << "ERROR: tensor " << op_output_name
+                     << " is already built\n";
         return mlir::failure();
       }
       tensor_map[op_output_name] = output_values[i];
@@ -1389,7 +1422,7 @@ mlir::LogicalResult TosaMlirBlockBuilder::BuildAllOpsInBlock(
 
   // Construct return values
   std::vector<mlir::Value> return_operands;
-  for (const auto& output_name : ser_block->GetOutputs()) {
+  for (const auto &output_name : ser_block->GetOutputs()) {
     // Sanity check if terminator mlir::Value is built
     if (!tensor_map.count(output_name)) {
       llvm::errs() << "ERROR: terminator mlir::Value " << output_name
@@ -1400,7 +1433,8 @@ mlir::LogicalResult TosaMlirBlockBuilder::BuildAllOpsInBlock(
     return_operands.push_back(output_value);
     return_values.push_back(output_value);
   }
-  auto terminator_op = op_builder->create<mlir::func::ReturnOp>(loc, return_operands);
+  auto terminator_op =
+      op_builder->create<mlir::func::ReturnOp>(loc, return_operands);
   block->push_back(terminator_op);
 
   // need topological sorting?
@@ -1409,9 +1443,9 @@ mlir::LogicalResult TosaMlirBlockBuilder::BuildAllOpsInBlock(
 }
 
 mlir::LogicalResult TosaMlirRegionBuilder::BuildAllBlocksInRegion(
-    std::vector<mlir::Value>& return_values) {
-  for (auto& ser_block : ser_region->GetBlocks()) {
-    auto& block = region->emplaceBlock();
+    std::vector<mlir::Value> &return_values) {
+  for (auto &ser_block : ser_region->GetBlocks()) {
+    auto &block = region->emplaceBlock();
     TosaMlirBlockBuilder block_builder(ser_block, this, &block);
 
     if (block_builder.BuildAllOpsInBlock(return_values).failed()) {
@@ -1430,13 +1464,13 @@ mlir::LogicalResult buildTosaMlir(mlir::func::FuncOp &func,
                                   tosa::TosaSerializationHandler &tsh,
                                   std::vector<mlir::Value> &main_returns) {
 
-  mlir::Region* main_region = func.getCallableRegion();
+  mlir::Region *main_region = func.getCallableRegion();
   if (!main_region) {
     llvm::errs() << "Invalid MLIR: doesn't have valid \"main\" region\n";
     return mlir::failure();
   }
 
-  TosaSerializationRegion* ser_main_region = tsh.GetRegions().front();
+  TosaSerializationRegion *ser_main_region = tsh.GetRegions().front();
 
   auto loc = func.getLoc();
 
@@ -1457,7 +1491,7 @@ mlir::LogicalResult buildTosaMlir(mlir::func::FuncOp &func,
 }
 
 // Load Tosa Schema into TosaSerializationHandler, required for JSON save/load
-mlir::LogicalResult loadTosaSchema(tosa::TosaSerializationHandler& tsh) {
+mlir::LogicalResult loadTosaSchema(tosa::TosaSerializationHandler &tsh) {
   const char *tosa_schema = tosa_deserialize_schema.c_str();
 
   if (!tosa_schema) {
@@ -1622,7 +1656,7 @@ class TosaDeserialize : public TosaDeserializationPassBase<TosaDeserialize> {
 public:
   void runOnOperation() final {
     auto function = getOperation();
-    auto& context = getContext();
+    auto &context = getContext();
 
     auto new_module_ref = BuildMlirFromTosaFile(
         tosa_deserialize_filename.c_str(), &context, /* file_is_fbs = */ true);
diff --git a/src/TosaSerialize.cpp b/src/TosaSerialize.cpp
index 4fd5014..73c84e8 100644
--- a/src/TosaSerialize.cpp
+++ b/src/TosaSerialize.cpp
@@ -146,13 +146,13 @@ private:
 class TosaSerializationBlockBuilder {
 public:
   // constructor
-  TosaSerializationBlockBuilder(TosaSerializationBasicBlock* _ser_block,
-                                TosaSerializationRegionBuilder* _region_builder,
-                                mlir::Block* _block)
+  TosaSerializationBlockBuilder(TosaSerializationBasicBlock *_ser_block,
+                                TosaSerializationRegionBuilder *_region_builder,
+                                mlir::Block *_block)
       : ser_block(_ser_block), region_builder(_region_builder), block(_block) {}
 
   mlir::LogicalResult
-  BuildAllOpsInBlock(std::vector<mlir::Value>& return_values);
+  BuildAllOpsInBlock(std::vector<mlir::Value> &return_values);
   TosaSerializationBasicBlock *GetBlock() const { return ser_block; }
   TosaSerializationRegionBuilder *GetRegionBuilder() const {
     return region_builder;
@@ -164,13 +164,13 @@ public:
 
 private:
   TosaSerializationOperator *BuildTosaSerializationOperator(
-      const TosaSerializationOperatorBuilder& op_builder, mlir::Operation& op);
-  TosaSerializationTensor*
+      const TosaSerializationOperatorBuilder &op_builder, mlir::Operation &op);
+  TosaSerializationTensor *
   BuildTosaSerializationTensor(mlir::Value val, const std::string &name);
 
-  TosaSerializationBasicBlock* ser_block;
-  TosaSerializationRegionBuilder* region_builder;
-  mlir::Block* block;
+  TosaSerializationBasicBlock *ser_block;
+  TosaSerializationRegionBuilder *region_builder;
+  mlir::Block *block;
   std::unordered_map<mlir::Value, std::string> tensor_map;
   std::unordered_map<mlir::Value, std::string> input_tensor_map;
 };
@@ -195,11 +195,11 @@ public:
   }
 
 private:
-  TosaSerializationRegion* ser_region;
+  TosaSerializationRegion *ser_region;
   mlir::Region *region;
   TosaSerializationRegionBuilder *parent_value_scope;
-  TosaSerializationHandler* tsh;
-  std::vector<TosaSerializationBlockBuilder*> block_builders;
+  TosaSerializationHandler *tsh;
+  std::vector<TosaSerializationBlockBuilder *> block_builders;
 };
 
 TosaSerializationHandler *TosaSerializationOperatorBuilder::GetTsh() const {
@@ -290,10 +290,10 @@ TosaSerializationOperatorBuilder::BuildPoolOpFromMlirOp(mlir::Operation &op,
   DType type = Type2PoolAccumDType(tensor.getElementType());
   TosaPoolAttribute attribute(pad, kernel, stride, input_zp, output_zp, type);
 
-  TosaSerializationOperator *tyop = new TosaSerializationOperator(
-      opcode, Attribute_PoolAttribute, &attribute,
-      std::vector<std::string>{input_name},
-      std::vector<std::string>{output_name});
+  TosaSerializationOperator *tyop =
+      new TosaSerializationOperator(opcode, Attribute_PoolAttribute, &attribute,
+                                    std::vector<std::string>{input_name},
+                                    std::vector<std::string>{output_name});
 
   return tyop;
 }
@@ -320,8 +320,7 @@ TosaSerializationOperatorBuilder::BuildEwiseUnaryOpFromMlirOp(
   std::string output_name = GetTensorName(op.getResult(0));
 
   TosaSerializationOperator *tyop = new TosaSerializationOperator(
-      opcode, Attribute_NONE, nullptr,
-      std::vector<std::string>{input_name},
+      opcode, Attribute_NONE, nullptr, std::vector<std::string>{input_name},
       std::vector<std::string>{output_name});
 
   return tyop;
@@ -336,10 +335,10 @@ TosaSerializationOperatorBuilder::BuildReductionOpFromMlirOp(
   int32_t axis = op.getAttr("axis").dyn_cast<mlir::IntegerAttr>().getInt();
   TosaAxisAttribute attribute(axis);
 
-  TosaSerializationOperator *tyop = new TosaSerializationOperator(
-      opcode, Attribute_AxisAttribute, &attribute,
-      std::vector<std::string>{input_name},
-      std::vector<std::string>{output_name});
+  TosaSerializationOperator *tyop =
+      new TosaSerializationOperator(opcode, Attribute_AxisAttribute, &attribute,
+                                    std::vector<std::string>{input_name},
+                                    std::vector<std::string>{output_name});
 
   return tyop;
 }
@@ -568,8 +567,8 @@ TosaSerializationOperatorBuilder::build<mlir::tosa::ConstOp>(
   ts->SetData(u8_data);
 
   TosaSerializationOperator *tyop = new TosaSerializationOperator(
-      Op_CONST, Attribute_NONE, nullptr,
-      std::vector<std::string>{}, std::vector<std::string>{output_name});
+      Op_CONST, Attribute_NONE, nullptr, std::vector<std::string>{},
+      std::vector<std::string>{output_name});
 
   return tyop;
 }
@@ -592,7 +591,6 @@ TosaSerializationOperatorBuilder::build<mlir::tosa::Conv2DOp>(
   std::string input2_name = GetTensorName(op.getOperand(2));
   std::string output_name = GetTensorName(op.getResult(0));
 
-
   auto quant_info =
       op.getAttrOfType<mlir::tosa::ConvOpQuantizationAttr>("quantization_info");
 
@@ -709,7 +707,8 @@ TosaSerializationOperatorBuilder::build<mlir::tosa::TransposeConv2DOp>(
   mlir::RankedTensorType tensor =
       op.getOperand(0).getType().cast<mlir::RankedTensorType>();
 
-  TosaTransposeConvAttribute attribute(out_pad, stride, out_shape, input_zp, weight_zp);
+  TosaTransposeConvAttribute attribute(out_pad, stride, out_shape, input_zp,
+                                       weight_zp);
 
   TosaSerializationOperator *tyop = new TosaSerializationOperator(
       Op_TRANSPOSE_CONV2D, Attribute_TransposeConvAttribute, &attribute,
@@ -855,8 +854,8 @@ TosaSerializationOperatorBuilder::build<mlir::tosa::ConcatOp>(
   TosaAxisAttribute attribute(axis);
 
   TosaSerializationOperator *tyop = new TosaSerializationOperator(
-      Op_CONCAT, Attribute_AxisAttribute, &attribute,
-      inputs, std::vector<std::string>{output_name});
+      Op_CONCAT, Attribute_AxisAttribute, &attribute, inputs,
+      std::vector<std::string>{output_name});
 
   return tyop;
 }
@@ -943,10 +942,10 @@ TosaSerializationOperatorBuilder::build<mlir::tosa::PadOp>(
 
   TosaPadAttribute attribute(paddings, pad_const_int, pad_const_fp);
 
-  TosaSerializationOperator *tyop = new TosaSerializationOperator(
-      Op_PAD, Attribute_PadAttribute, &attribute,
-      std::vector<std::string>{input_name},
-      std::vector<std::string>{output_name});
+  TosaSerializationOperator *tyop =
+      new TosaSerializationOperator(Op_PAD, Attribute_PadAttribute, &attribute,
+                                    std::vector<std::string>{input_name},
+                                    std::vector<std::string>{output_name});
   return tyop;
 }
 
@@ -1131,8 +1130,7 @@ TosaSerializationOperatorBuilder::build<mlir::tosa::ArithmeticRightShiftOp>(
 
   TosaSerializationOperator *tyop = new TosaSerializationOperator(
       Op_ARITHMETIC_RIGHT_SHIFT, Attribute_ArithmeticRightShiftAttribute,
-      &attribute,
-      std::vector<std::string>{input0_name, input1_name},
+      &attribute, std::vector<std::string>{input0_name, input1_name},
       std::vector<std::string>{output_name});
 
   return tyop;
@@ -1181,7 +1179,8 @@ TosaSerializationOperatorBuilder::build<mlir::tosa::RescaleOp>(
 
   auto multiplier =
       op.getAttr("multiplier").dyn_cast<mlir::DenseI32ArrayAttr>().asArrayRef();
-  auto shift = op.getAttr("shift").dyn_cast<mlir::DenseI32ArrayAttr>().asArrayRef();
+  auto shift =
+      op.getAttr("shift").dyn_cast<mlir::DenseI32ArrayAttr>().asArrayRef();
 
   std::string input_name = GetTensorName(op.getOperand(0));
   std::string output_name = GetTensorName(op.getResult(0));
@@ -1383,14 +1382,13 @@ TosaSerializationOperatorBuilder::build<mlir::tosa::RFFT2dOp>(
   std::string output_imag_name = GetTensorName(op.getResult(1));
 
   TosaSerializationOperator *tyop = new TosaSerializationOperator(
-    Op_RFFT2D, Attribute_NONE, nullptr,
-    std::vector<std::string>{input_name},
-    std::vector<std::string>{output_real_name, output_imag_name});
+      Op_RFFT2D, Attribute_NONE, nullptr, std::vector<std::string>{input_name},
+      std::vector<std::string>{output_real_name, output_imag_name});
 
   return tyop;
 }
 
-template<>
+template <>
 TosaSerializationOperator *
 TosaSerializationOperatorBuilder::build<mlir::tosa::FFT2dOp>(
     mlir::Operation &op) const {
@@ -1405,9 +1403,9 @@ TosaSerializationOperatorBuilder::build<mlir::tosa::FFT2dOp>(
   TosaFFTAttribute attribute(inverse);
 
   TosaSerializationOperator *tyop = new TosaSerializationOperator(
-    Op_FFT2D, Attribute_FFTAttribute, &attribute,
-    std::vector<std::string>{input_real_name, input_imag_name},
-    std::vector<std::string>{output_real_name, output_imag_name});
+      Op_FFT2D, Attribute_FFTAttribute, &attribute,
+      std::vector<std::string>{input_real_name, input_imag_name},
+      std::vector<std::string>{output_real_name, output_imag_name});
 
   return tyop;
 }
@@ -1417,7 +1415,7 @@ mlir::LogicalResult TosaSerializationRegionBuilder::BuildAllBlocksInRegion(
     bool is_top, std::vector<mlir::Value> &return_values) {
   std::string region_name = ser_region->GetName();
   int block_index = 0;
-  for (auto& block : this->region->getBlocks()) {
+  for (auto &block : this->region->getBlocks()) {
     // must name first block of top region "main"
     const std::string block_name =
         (is_top && block_index == 0)
@@ -1519,7 +1517,6 @@ mlir::LogicalResult TosaSerializationBlockBuilder::BuildAllOpsInBlock(
   for (auto pair : tensor_map)
     tensor_name_sort[pair.second] = pair.first;
 
-
   for (auto pair : tensor_name_sort) {
     ser_tensor = BuildTosaSerializationTensor(pair.second /* val */,
                                               pair.first /* name */);