NFC: (re-apply) Fix some post-review nits for the Tosa dialect.

[stellaraccident]

Summary

This reverts commit 330398052d049f90e6cfac80ab8b765b158a3e61.

[sjarus]

Thank you for these cleanup additions!

mlir/include/mlir/Dialect/Tosa/IR/TosaInterfaces.td

 
 #ifndef TOSA_OP_INTERFACES
 #define TOSA_OP_INTERFACES
 
 include "mlir/IR/OpBase.td"
 
 def TosaOpInterface : OpInterface<"TosaOp"> {
   let description = [{
-    Implements interfaces implemented by ops that correspond to the Tosa
-    specification.
+    Implemented by ops that correspond to the Tosa specification.
   }];
 }
 
 #endif

mlir/include/mlir/Dialect/Tosa/IR/TosaOpBase.td

 
 // This builder is called on all convolution operators except for TransposeConv,
 // which has specialized output shape semantics. The builder also defines the
 // bitwidth of the output given the bit width of the input & weight content.
 def Tosa_ConvOpQuantInfoBuilder : OpBuilderDAG<
   (ins "Type":$outputType, "Value":$input, "Value":$weight, "Value":$bias,
        "ArrayAttr":$pad, "ArrayAttr":$stride, "ArrayAttr":$dilation),
   [{
-    ::buildConvOpWithQuantInfo($_builder, $_state, outputType,
-                               input, weight, bias,
-                               pad, stride, dilation);
+    buildConvOpWithQuantInfo($_builder, $_state, outputType,
   }]>;
 
 // Handles tosa.transpose_conv2d which has an outpad and output shape attribute.
 def Tosa_TransConvOpQuantInfoBuilder : OpBuilderDAG<
   (ins "Type":$outputType, "Value":$input, "Value":$weight, "Value":$bias,
        "ArrayAttr":$outpad, "ArrayAttr":$stride, "ArrayAttr":$dilation,
        "ArrayAttr":$outputShape),
   [{
-    ::buildTransConvOpWithQuantInfo($_builder, $_state, outputType,
-                                    input, weight, bias,
-                                    outpad, stride, dilation,
-                                    outputShape);
+    buildTransConvOpWithQuantInfo($_builder, $_state, outputType,
   }]>;
 
 // The tosa.fully_connected op has its own builder as it does not have
 // strides/dilation/padding.
 def Tosa_FCOpQuantInfoBuilder : OpBuilderDAG<
   (ins "Type":$outputType, "Value":$input, "Value":$weight, "Value":$bias),
   [{
-    ::buildFCOpWithQuantInfo($_builder, $_state, outputType,
-                             input, weight, bias);
+    buildFCOpWithQuantInfo($_builder, $_state, outputType,
   }]>;
 
 // The tosa.matmul op is also intended to be generated where a fully_connected
 // op must be constructed where the weight is not a constant. In this case,
 // the fully_connected op must be expressed using matmul.
 // TODO: Add link to the leglization document explaining this.
 def Tosa_MatMulOpQuantInfoBuilder : OpBuilderDAG<
   (ins "Type":$outputType, "Value":$a, "Value":$b),
   [{
-    ::buildMatMulOpWithQuantInfo($_builder, $_state, outputType,
-                                 a, b);
+    buildMatMulOpWithQuantInfo($_builder, $_state, outputType,
   }]>;
 
 // Both the tosa.avg_pool2d and unary ops use the same
 // UnaruOpQuantizationAttr but the avg_pool operator has its own builder as it
 // has additional parameters not part of the unary ops.
 def Tosa_AvgPool2dOpQuantInfoBuilder : OpBuilderDAG<
   (ins "Type":$outputType, "Value":$input, "ArrayAttr":$kernel,
        "ArrayAttr":$stride, "ArrayAttr":$pad),
   [{
-    ::buildAvgPool2dOpWithQuantInfo($_builder, $_state, outputType,
-                                    input, kernel, stride, pad);
+    buildAvgPool2dOpWithQuantInfo($_builder, $_state, outputType,
   }]>;
 
 // This builder is called on single-parameter unary operators that have a scale
 // relationship between their input and output, expressed by the
 // UnaryOpQuantizationAttr.
 def Tosa_UnaryOpQuantInfoBuilder : OpBuilderDAG<
   (ins "Type":$outputType, "Value":$input),
   [{
-    ::buildUnaryOpWithQuantInfo($_builder, $_state, outputType, input);
+    buildUnaryOpWithQuantInfo($_builder, $_state, outputType, input);
   }]>;
 
 // This builder is called on the TOSA pad operator that needs to create its own
 // OptionalAttr quantization_attr parameter to scale the padding values
 // correctly.
 def Tosa_PadOpQuantInfoBuilder : OpBuilderDAG<
   (ins "Type":$outputType, "Value":$input, "Value":$paddings),
   [{
-    ::buildPadOpWithQuantInfo($_builder, $_state, outputType,
-                              input, paddings);
+    buildPadOpWithQuantInfo($_builder, $_state, outputType,
   }]>;
 
 //===----------------------------------------------------------------------===//
 // TOSA Operator.
 //===----------------------------------------------------------------------===//
 
 class Tosa_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<Tosa_Dialect, mnemonic, !listconcat(traits, [TosaOpInterface])> {
 }
 
 #endif // TOSA_OP_BASE

mlir/include/mlir/Dialect/Tosa/IR/TosaOps.td

def Tosa_Conv2DOp : Tosa_Op<"conv2d", [NoSideEffect]> {
   );
 
   let results = (outs
     Tosa_Tensor4D:$output
   );
 
   let builders = [Tosa_ConvOpQuantInfoBuilder];
 
-  let verifier = [{ return ::verifyConvOp(*this); }];
+  let verifier = [{ return verifyConvOp(*this); }];
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: conv3d
 //===----------------------------------------------------------------------===//
 def Tosa_Conv3DOp : Tosa_Op<"conv3d", [NoSideEffect]> {
   let summary = "3D Convolution operator";
 
def Tosa_Conv3DOp : Tosa_Op<"conv3d", [NoSideEffect]> {
   );
 
   let results = (outs
     Tosa_Tensor5D:$output
   );
 
   let builders = [Tosa_ConvOpQuantInfoBuilder];
 
-  let verifier = [{ return ::verifyConvOp(*this); }];
+  let verifier = [{ return verifyConvOp(*this); }];
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: depthwise_conv2d
 //===----------------------------------------------------------------------===//
 def Tosa_DepthwiseConv2DOp : Tosa_Op<"depthwise_conv2d", [NoSideEffect]> {
   let summary = "Depthwise 2D Convolution operator";
 
def Tosa_DepthwiseConv2DOp : Tosa_Op<"depthwise_conv2d", [NoSideEffect]> {
   );
 
   let results = (outs
     Tosa_Tensor4D:$output
   );
 
   let builders = [Tosa_ConvOpQuantInfoBuilder];
 
-  let verifier = [{ return ::verifyConvOp(*this); }];
+  let verifier = [{ return verifyConvOp(*this); }];
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: fully_connected
 //===----------------------------------------------------------------------===//
 def Tosa_FullyConnectedOp : Tosa_Op<"fully_connected", [NoSideEffect]> {
   let summary = "Fully Connected operator";
 
def Tosa_FullyConnectedOp : Tosa_Op<"fully_connected", [NoSideEffect]> {
   );
 
   let results = (outs
     Tosa_Tensor2D:$output
   );
 
   let builders = [Tosa_FCOpQuantInfoBuilder];
 
-  let verifier = [{ return ::verifyConvOp(*this); }];
+  let verifier = [{ return verifyConvOp(*this); }];
 }
 
 //===----------------------------------------------------------------------===//
 // Operator: matmul
 //===----------------------------------------------------------------------===//
 def Tosa_MatMulOp : Tosa_Op<"matmul", [NoSideEffect]> {
   let summary = "Matrix multiplication with bias";
 

mlir/include/mlir/Dialect/Tosa/Transforms/Passes.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_TOSA_TRANSFORMS_PASSES_H
 #define MLIR_DIALECT_TOSA_TRANSFORMS_PASSES_H
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
-
 namespace tosa {
 
 std::unique_ptr<Pass> createTosaMakeBroadcastablePass();
 std::unique_ptr<Pass> createTosaTestQuantUtilAPIPass();
 
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
 
 } // namespace tosa
 } // namespace mlir
 
 #endif // MLIR_DIALECT_TOSA_TRANSFORMS_PASSES_H

mlir/include/mlir/Dialect/Tosa/Utils/QuantUtils.h

 #ifndef DIALECT_TOSA_UTILS_QUANT_UTILS_H
 #define DIALECT_TOSA_UTILS_QUANT_UTILS_H
 
 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
 
 #include "mlir/Dialect/Quant/FakeQuantSupport.h"
 #include "mlir/Dialect/Quant/UniformSupport.h"
 
-using namespace mlir;
-using namespace mlir::tosa;
+namespace mlir {
+namespace tosa {
 
 //===----------------------------------------------------------------------===//
 // Utililty functions to support quantization handling in Tosa.
 //===----------------------------------------------------------------------===//
 
 /// From a scale value, computes multiplier and shift values
 /// for 16 or 32-bit scale widths.
 void computeMultiplierAndShift(double scale, int32_t &multiplier,
Type buildQTypeFromMinMax(OpBuilder builder, Type inputDType, Attribute minAttr,
                           BoolAttr narrowRange);
 
 /// Builds Tosa quantization attributes from min/max values.
 TypeAttr buildQTypeAttrFromMinMax(OpBuilder builder, Type inputDType,
                                   Attribute minAttr, Attribute maxAttr,
                                   IntegerAttr quantBits, int filterQuantDim,
                                   bool isSigned, BoolAttr narrowRange);
 
+} // namespace tosa
+} // namespace mlir
+
 #endif // DIALECT_TOSA_UTILS_QUANT_UTILS_H

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

#include "mlir/Dialect/Tosa/IR/TosaOps.cpp.inc"
       >();
   addInterfaces<TosaInlinerInterface>();
 }
 
 //===----------------------------------------------------------------------===//
 // TOSA Operator Verifiers.
 //===----------------------------------------------------------------------===//
 
-template <typename T> static LogicalResult verifyConvOp(T op) {
+template <typename T>
+static LogicalResult verifyConvOp(T op) {
   // All TOSA conv ops have an input() and weight().
   auto inputType = op.input().getType().template dyn_cast<RankedTensorType>();
   auto weightType = op.weight().getType().template dyn_cast<RankedTensorType>();
 
   // Must be ranked tensor types
   if (!inputType || !weightType)
     return failure();
 

 
 //===----------------------------------------------------------------------===//
 // TOSA Operator Quantization Builders.
 //===----------------------------------------------------------------------===//
 
 /// This builder is called on all convolution operators except TransposeConv,
 /// which has specialized output shape semantics. The builder also defines the
 /// bitwidth of the output given the bit width of the input & weight content.
-void buildConvOpWithQuantInfo(OpBuilder &builder, OperationState &result,
+static void buildConvOpWithQuantInfo(OpBuilder &builder, OperationState &result,
                                      Type outputType, Value input, Value weight,
-                              Value bias, ArrayAttr pad, ArrayAttr stride,
-                              ArrayAttr dilation) {
+                                     Value bias, ArrayAttr pad,
+                                     ArrayAttr stride, ArrayAttr dilation) {
 
   result.addOperands({input, weight, bias});
   result.addAttribute("pad", pad);
   result.addAttribute("stride", stride);
   result.addAttribute("dilation", dilation);
 
   auto quantAttr = buildConvOpQuantizationAttr(builder, input, weight);
   if (quantAttr) {
     result.addAttribute("quantization_info", quantAttr);
     result.addTypes(
         buildConvOpResultTypeInfo(builder, outputType, input, weight));
   } else {
     result.addTypes(outputType);
   }
 }
 
 /// Handles tosa.transpose_conv2d which has outpad and output shape attributes.
-void buildTransConvOpWithQuantInfo(OpBuilder &builder, OperationState &result,
-                                   Type outputType, Value input, Value weight,
-                                   Value bias, ArrayAttr outpad,
-                                   ArrayAttr stride, ArrayAttr dilation,
-                                   ArrayAttr outputShape) {
+static void
+buildTransConvOpWithQuantInfo(OpBuilder &builder, OperationState &result,
+                              Value bias, ArrayAttr outpad, ArrayAttr stride,
+                              ArrayAttr dilation, ArrayAttr outputShape) {
   result.addOperands({input, weight, bias});
   result.addAttribute("out_pad", outpad);
   result.addAttribute("stride", stride);
   result.addAttribute("dilation", dilation);
   result.addAttribute("out_shape", outputShape);
   auto quantAttr = ::buildConvOpQuantizationAttr(builder, input, weight);
 
   if (quantAttr) {
     result.addAttribute("quantization_info", quantAttr);
     result.addTypes(
         buildConvOpResultTypeInfo(builder, outputType, input, weight));
   } else {
     result.addTypes(outputType);
   }
 }
 
 /// The tosa.fully_connected op has its own builder as it does not have
 /// strides/dilation/padding.
-void buildFCOpWithQuantInfo(OpBuilder &builder, OperationState &result,
+static void buildFCOpWithQuantInfo(OpBuilder &builder, OperationState &result,
                                    Type outputType, Value input, Value weight,
                                    Value bias) {
 
   result.addOperands({input, weight, bias});
   auto quantAttr = ::buildConvOpQuantizationAttr(builder, input, weight);
   if (quantAttr) {
     result.addAttribute("quantization_info", quantAttr);
     result.addTypes(
         buildConvOpResultTypeInfo(builder, outputType, input, weight));
   } else {
     result.addTypes(outputType);
   }
 }
 
 /// The tosa.matmul op is also intended to be generated where a fully_connected
 /// op must be constructed where the weight is not a constant. In this case,
 /// the fully_connected op must be expressed using matmul.
 /// TODO: Add link to the leglization document explaining this.
-void buildMatMulOpWithQuantInfo(OpBuilder &builder, OperationState &result,
-                                Type outputType, Value a, Value b) {
+static void buildMatMulOpWithQuantInfo(OpBuilder &builder,
+                                       OperationState &result, Type outputType,
+                                       Value a, Value b) {
   result.addOperands({a, b});
   auto quantAttr = ::buildMatMulOpQuantizationAttr(builder, a, b);
 
   if (quantAttr) {
     result.addAttribute("quantization_info", quantAttr);
 
     auto inputType = a.getType().dyn_cast<RankedTensorType>();
     assert(inputType && "Input must be a ranked tensor type!");
static void buildMatMulOpWithQuantInfo(OpBuilder &builder,
   } else {
     result.addTypes(outputType);
   }
 }
 
 /// Both the tosa.avg_pool2d and unary ops use the same UnaruOpQuantizationAttr
 /// but avg_pool operator has its own builder as it has additional parameters
 /// not part of the unary ops.
-void buildAvgPool2dOpWithQuantInfo(OpBuilder &builder, OperationState &result,
+static void buildAvgPool2dOpWithQuantInfo(OpBuilder &builder,
+                                          OperationState &result,
                                           Type outputType, Value input,
                                           ArrayAttr kernel, ArrayAttr stride,
                                           ArrayAttr pad) {
   result.addOperands(input);
   result.addAttribute("kernel", kernel);
   result.addAttribute("stride", stride);
   result.addAttribute("pad", pad);
   auto quantAttr = buildUnaryOpQuantizationAttr(builder, input, outputType);
   if (quantAttr)
     result.addAttribute("quantization_info", quantAttr);
   result.types.push_back(outputType);
 }
 
 /// This builder is called on single-parameter unary operators that have scale
 /// relationship between their input and output, expressed by the
 /// UnaryOpQuantizationAttr.
-void buildUnaryOpWithQuantInfo(OpBuilder &builder, OperationState &result,
-                               Type outputType, Value input) {
+static void buildUnaryOpWithQuantInfo(OpBuilder &builder,
+                                      OperationState &result, Type outputType,
+                                      Value input) {
   result.addOperands(input);
   auto quantAttr = buildUnaryOpQuantizationAttr(builder, input, outputType);
   if (quantAttr)
     result.addAttribute("quantization_info", quantAttr);
   result.types.push_back(outputType);
 }
 
 /// This builder is called on TOSA pad operator that needs to create its own
 /// OptionalAttr quantization_attr parameter to scale the padding values
 /// correctly.
-void buildPadOpWithQuantInfo(OpBuilder &builder, OperationState &result,
-                             Type outputType, Value input, Value paddings) {
+static void buildPadOpWithQuantInfo(OpBuilder &builder, OperationState &result,
+                                    Type outputType, Value input,
+                                    Value paddings) {
   result.addOperands({input, paddings});
   auto quantAttr = buildPadOpQuantizationAttr(builder, input);
   if (quantAttr)
     result.addAttribute("quantization_info", quantAttr);
   result.types.push_back(outputType);
 }
 
 //===----------------------------------------------------------------------===//
 // TOSA Operator Definitions.
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Tosa/IR/TosaOps.cpp.inc"

mlir/lib/Dialect/Tosa/Transforms/TosaMakeBroadcastable.cpp

static int reshapeLowerToHigher(PatternRewriter &rewriter, Location loc,
   } else {
     higherTensorValue = input2;
     lowerTensorValue = input1;
   }
 
   ArrayRef<int64_t> outputRankShape = outputType.getShape();
   ArrayRef<int64_t> higherRankShape =
       higherTensorValue.getType().cast<RankedTensorType>().getShape();
+  (void)higherRankShape;
   ArrayRef<int64_t> lowerRankShape =
       lowerTensorValue.getType().cast<RankedTensorType>().getShape();
 
   // outputRank == higherRank == max(input1Rank, input2Rank)
   assert(higherRankShape.size() == outputRankShape.size());
 
   SmallVector<int64_t, 4> reshapeOutputShape;
 
if (input1Rank > input2Rank) {
     outInput1 = reshapeLower.getResult();
     outInput2 = higherTensorValue;
   }
 
   return 0;
 }
 
 namespace {
-template <typename OpTy> struct ConvertTosaOp : public OpRewritePattern<OpTy> {
+template <typename OpTy>
+struct ConvertTosaOp : public OpRewritePattern<OpTy> {
   using OpRewritePattern<OpTy>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(OpTy tosaBinaryOp,
                                 PatternRewriter &rewriter) const {
 
     Value input1 = tosaBinaryOp.input1();
     Value input2 = tosaBinaryOp.input2();
     Value output = tosaBinaryOp.getResult();

mlir/lib/Dialect/Tosa/Utils/QuantUtils.cpp

 #include "mlir/Dialect/Tosa/Utils/QuantUtils.h"
 
 using namespace mlir;
 using namespace mlir::tosa;
 
 /// From a scale value, generates multiplier and shift values where
 /// mantissa is in [-1.0,-0.5] or [0.5, 1.0] such that
 /// multiplier = mantissa*2^shift for 16-bit scaling.
-void computeMultiplierAndShiftTosaScale16(double scale, int32_t &multiplier,
+static void computeMultiplierAndShiftTosaScale16(double scale,
+                                                 int32_t &multiplier,
                                                  int32_t &shift) {
 
   const double mantissa = std::frexp(scale, &shift);
   auto shiftedM = std::round(mantissa * (int64_t(1) << 15));
 
   // Can't be greater than 1.0.
   assert(shiftedM <= (int64_t(1) << 15) &&
          "Shifted mantissa exceeds 16 signed bits");
 
assert(shiftedM <= std::numeric_limits<int32_t>::max() &&
          "Shifted mantissa exceeds 32-bit signed output type");
 
   multiplier = static_cast<int32_t>(shiftedM);
 }
 
 /// From a scale value, generates multiplier and shift values where
 /// mantissa is in [-1.0,-0.5] or [0.5, 1.0] such that
 /// multiplier = mantissa*2^shift for 32-bit scaling.
-void computeMultiplierAndShiftTosaScale32(double scale, int32_t &multiplier,
+static void computeMultiplierAndShiftTosaScale32(double scale,
+                                                 int32_t &multiplier,
                                                  int32_t &shift) {
 
   const double mantissa = std::frexp(scale, &shift);
   auto shiftedM = std::round(mantissa * (int64_t(1) << 31));
 
   // Can't be greater than 1.0.
   assert(shiftedM <= (int64_t(1) << 31) &&
          "Shifted mantissa exceeds 32 signed bits");
   if (shiftedM == (int64_t(1) << 31)) {
     shiftedM /= 2;
     shift++;
   }
 
   // TOSA expects right shift to be positive, and embed (1 << 31) into right
   // shift bits.
   shift = (-shift) + 31;
 
   assert(shiftedM <= std::numeric_limits<int32_t>::max() &&
          "Shifted mantissa exceeds 32-bit signed output type");
 
   multiplier = static_cast<int32_t>(shiftedM);
 }
 
 /// Generates a quantized multiplier/shift from double.
-void computeMultiplierAndShift(double scale, int32_t &multiplier,
+void mlir::tosa::computeMultiplierAndShift(double scale, int32_t &multiplier,
                                            int32_t &shift, int32_t scaleWidth) {
 
   switch (scaleWidth) {
   case 16:
     computeMultiplierAndShiftTosaScale16(scale, multiplier, shift);
     return;
   case 32:
     computeMultiplierAndShiftTosaScale32(scale, multiplier, shift);
     return;
   default:
     assert(0 && "Unsupported Tosa quantized_scale regime specified!");
   }
 }
 
 #define GET_UQTYPE(input_type)                                                 \
   ((input_type).getElementType().dyn_cast<quant::UniformQuantizedType>())
 #define GET_QTYPE(input_type)                                                  \
   ((input_type).getElementType().dyn_cast<quant::QuantizedType>())
 
 /// Method to build ConvOpQuantizationAttr, called from
 /// ConvOpQuantInfoBuilder/TransConvOpQuantInfoBuilder:
 /// input_zp: input zeropoint
 /// weight_zp: weight zeropoint.
-ConvOpQuantizationAttr buildConvOpQuantizationAttr(OpBuilder &builder,
-                                                   Value input, Value weight) {
+ConvOpQuantizationAttr
+mlir::tosa::buildConvOpQuantizationAttr(OpBuilder &builder, Value input,
+                                        Value weight) {
 
   auto inputType = input.getType().dyn_cast<RankedTensorType>();
   auto weightType = weight.getType().dyn_cast<RankedTensorType>();
 
   if (!inputType || !weightType)
     return nullptr;
 
   auto inputQType = GET_UQTYPE(inputType);
mlir::tosa::buildConvOpQuantizationAttr(OpBuilder &builder, Value input,
 
   return nullptr;
 }
 
 /// Builds MatMulOpQuantizationAttr, called from
 /// MatMulOpQuantInfoBuilder:
 /// aZp: input a zeropoint
 /// bZp: input b zeropoint.
-MatMulOpQuantizationAttr buildMatMulOpQuantizationAttr(OpBuilder &builder,
-                                                       Value a, Value b) {
+MatMulOpQuantizationAttr
+mlir::tosa::buildMatMulOpQuantizationAttr(OpBuilder &builder, Value a,
+                                          Value b) {
 
   auto aType = a.getType().dyn_cast<RankedTensorType>();
   auto bType = b.getType().dyn_cast<RankedTensorType>();
 
   if (!aType || !bType)
     return nullptr;
 
   auto aQType = GET_UQTYPE(aType);
mlir::tosa::buildMatMulOpQuantizationAttr(OpBuilder &builder, Value a,
 
   return nullptr;
 }
 
 /// Builds UnaryOpQuantizationAttr
 /// UnaryOpQuantInfoBuilder:
 /// inputZp: input zeropoint
 /// outputZp: output zeropoint.
-UnaryOpQuantizationAttr buildUnaryOpQuantizationAttr(OpBuilder &builder,
-                                                     Value input,
-                                                     Type outputRawType) {
+UnaryOpQuantizationAttr
+mlir::tosa::buildUnaryOpQuantizationAttr(OpBuilder &builder, Value input,
 
   auto inputType = input.getType().dyn_cast<RankedTensorType>();
   auto outputType = outputRawType.dyn_cast<RankedTensorType>();
 
   if (!inputType || !outputType)
     return nullptr;
 
   auto inputQType = GET_UQTYPE(inputType);
if (inputQType) {
     return quantAttr;
   }
 
   return nullptr;
 }
 
 /// Builds PadOpQuantizationAttr, called from PadOpQuantInfoBuilder:
 /// inputZp: input zeropoint.
-PadOpQuantizationAttr buildPadOpQuantizationAttr(OpBuilder &builder,
+PadOpQuantizationAttr mlir::tosa::buildPadOpQuantizationAttr(OpBuilder &builder,
                                                              Value input) {
 
   auto inputType = input.getType().dyn_cast<RankedTensorType>();
 
   if (!inputType)
     return nullptr;
 
   auto inputQType = GET_UQTYPE(inputType);
 
   if (inputQType) {
 
     int64_t inputZp = inputQType.getZeroPoint();
 
     auto quantAttr = tosa::PadOpQuantizationAttr::get(
         builder.getI32IntegerAttr(inputZp), builder.getContext());
 
     return quantAttr;
   }
 
   return nullptr;
 }
 
 /// Builds output type for a quantized ConvOp with the right bitwidth.
 /// This is called by the builder when dealing with quantized content.
-Type buildConvOpResultTypeInfo(OpBuilder &builder, Type outputType, Value input,
-                               Value weight) {
+Type mlir::tosa::buildConvOpResultTypeInfo(OpBuilder &builder, Type outputType,
+                                           Value input, Value weight) {
 
   auto inputType = input.getType().dyn_cast<RankedTensorType>();
   auto weightType = weight.getType().dyn_cast<RankedTensorType>();
 
   assert(inputType && weightType &&
          "Could not extract input or weight tensors from Conv op");
 
   auto inputQType = GET_QTYPE(inputType);
if (inputBits == 16 && weightBits == 8)
     accElementType = builder.getIntegerType(48);
   else
     accElementType = builder.getI32Type();
   auto accType = RankedTensorType::get(outputShape, accElementType);
   return accType;
 }
 
 /// Builds Tosa quantization attributes from min/max values.
-Type buildQTypeFromMinMax(OpBuilder builder, Type inputDType, Attribute minAttr,
-                          Attribute maxAttr, IntegerAttr quantBits,
-                          int filterQuantDim, bool isSigned,
-                          BoolAttr narrowRange) {
+Type mlir::tosa::buildQTypeFromMinMax(OpBuilder builder, Type inputDType,
+                                      Attribute minAttr, Attribute maxAttr,
+                                      IntegerAttr quantBits, int filterQuantDim,
+                                      bool isSigned, BoolAttr narrowRange) {
 
   quant::QuantizedType retType;
 
   auto convfunc =
       quant::ExpressedToQuantizedConverter::forInputType(inputDType);
 
   auto minElems = minAttr.dyn_cast<DenseFPElementsAttr>();
   auto maxElems = maxAttr.dyn_cast<DenseFPElementsAttr>();
Type mlir::tosa::buildQTypeFromMinMax(OpBuilder builder, Type inputDType,
 
   if (!retType)
     return {};
 
   return convfunc.convert(retType);
 }
 
 /// Builds Tosa quantization attributes from min/max values.
-TypeAttr buildQTypeAttrFromMinMax(OpBuilder builder, Type inputDtype,
+TypeAttr
+mlir::tosa::buildQTypeAttrFromMinMax(OpBuilder builder, Type inputDtype,
                                      Attribute minAttr, Attribute maxAttr,
                                      IntegerAttr quantBits, int filterQuantDim,
                                      bool isSigned, BoolAttr narrowRange) {
 
   return TypeAttr::get(buildQTypeFromMinMax(builder, inputDtype, minAttr,
                                             maxAttr, quantBits, filterQuantDim,
                                             isSigned, narrowRange));
 }