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

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

1 files changed, 202 insertions, 168 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);