DRAFT circle-mlir version up externals

on-going draft to version up externals and fix changes.

Signed-off-by: SaeHie Park <saehie.park@gmail.com>

Author: seanshpark

circle-mlir/circle-mlir/lib/dialect/include/circle-mlir/dialect/CircleDialect.h

@@ -20,6 +20,7 @@
 #ifndef __CIRCLE_MLIR_DIALECT_CIRCLE_DIALECT_H__
 #define __CIRCLE_MLIR_DIALECT_CIRCLE_DIALECT_H__
 
+#include <mlir/Bytecode/BytecodeOpInterface.h>           // from @llvm-project
 #include <mlir/Dialect/Traits.h>                         // from @llvm-project
 #include <mlir/IR/Dialect.h>                             // from @llvm-project
 #include <mlir/IR/DialectImplementation.h>               // from @llvm-project
@@ -46,6 +47,7 @@ class ControlType : public Type::TypeBase<ControlType, Type, TypeStorage>
 {
 public:
   using Base::Base;
+  static constexpr StringLiteral name = "cir.control";
 };
 
 #include "mlir/CircleOpInterface.h.inc"

circle-mlir/circle-mlir/lib/dialect/mlir/CircleOps.td

@@ -20,7 +20,7 @@
 #ifndef CIRCLE_OPS
 #define CIRCLE_OPS
 
-include "mlir/IR/FunctionInterfaces.td"
+// include "mlir/IR/FunctionInterfaces.td"
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
@@ -81,6 +81,7 @@ class CIR_VariadicTensorOf<list<Type> allowedRuntimeTypes,
   Variadic<TensorOf<allowedOpTypes>>,
   CIR_RuntimeType<Variadic<TensorOf<allowedRuntimeTypes>>>;
 
+def CIR_I4 : I<4>;
 def CIR_Int32Or64 : SignlessIntOfWidths<[32, 64]>;
 
 def CIR_BoolTensor : CIR_TensorOf<[I1]>;
@@ -260,6 +261,8 @@ class CIR_Op<string mnemonic, list<Trait> traits = []> :
 
   // Whether the Circle operator has options in the schema representation.
   bit hasOptions = 0b0;
+  // Whether the Circle operator has options2 in the schema representation.
+  bit hasOptions2 = 0b0;
 
   // Use to specify a custom options type for Circle operators where
   // the option's name does not match the Cirlce operator's name.

circle-mlir/circle-mlir/lib/dialect/src/CircleDialect.cpp

@@ -73,7 +73,7 @@ ParseResult parseOneResultSameOperandTypeOp(OpAsmParser &parser, OperationState
         parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
         parser.parseType(type))
       return failure();
-    auto fnType = type.dyn_cast<FunctionType>();
+    auto fnType = mlir::dyn_cast<FunctionType>(type);
     if (!fnType)
     {
       parser.emitError(loc, "expected function type");
@@ -134,7 +134,7 @@ bool VerifyOperandsHaveSameShapesOrBroadcastableShape(Operation *op, ArrayRef<un
 
   for (unsigned index : indices)
   {
-    ShapedType shaped_type = op->getOperand(index).getType().dyn_cast<ShapedType>();
+    ShapedType shaped_type = mlir::dyn_cast<ShapedType>(op->getOperand(index).getType());
     if (!shaped_type || !shaped_type.hasRank())
     {
       // Marks that we have an unknown rank input.
@@ -212,8 +212,8 @@ bool EqualsZero(Value value)
     return false;
   }
 
-  Type element_type = value.getType().cast<ShapedType>().getElementType();
-  if (element_type.isa<FloatType>())
+  Type element_type = mlir::cast<ShapedType>(value.getType()).getElementType();
+  if (mlir::isa<FloatType>(element_type))
   {
     return constant.getSplatValue<APFloat>().isZero();
   }
@@ -315,7 +315,7 @@ bool ExtractConstantValues(mlir::Value &input, std::vector<int64_t> &values)
 
 void CIRDialect::printType(Type type, DialectAsmPrinter &os) const
 {
-  if (type.isa<ControlType>())
+  if (mlir::isa<ControlType>(type))
   {
     os << "control";
     return;
@@ -357,7 +357,7 @@ namespace
 // Returns true if it is a shaped type of f32 elements.
 inline bool IsF32ShapedType(Type t)
 {
-  if (auto shaped_type = t.dyn_cast_or_null<ShapedType>())
+  if (auto shaped_type = mlir::dyn_cast_or_null<ShapedType>(t))
   {
     return shaped_type.getElementType().isF32();
   }
@@ -367,7 +367,7 @@ inline bool IsF32ShapedType(Type t)
 // Returns true if it is a shaped type of i64 elements.
 inline bool IsI64ShapedType(Type t)
 {
-  if (auto shaped_type = t.dyn_cast_or_null<ShapedType>())
+  if (auto shaped_type = mlir::dyn_cast_or_null<ShapedType>(t))
   {
     return shaped_type.getElementType().isInteger(64);
   }
@@ -391,11 +391,11 @@ namespace
 
 bool InputOutputHasSameShape(mlir::Type input_type, mlir::Type output_type)
 {
-  auto input_shaped_type = input_type.dyn_cast_or_null<ShapedType>();
+  auto input_shaped_type = mlir::dyn_cast_or_null<ShapedType>(input_type);
   if (!input_shaped_type || !input_shaped_type.hasStaticShape())
     return false;
 
-  auto output_shaped_type = output_type.dyn_cast_or_null<ShapedType>();
+  auto output_shaped_type = mlir::dyn_cast_or_null<ShapedType>(output_type);
   if (!output_shaped_type || !output_shaped_type.hasStaticShape())
     return false;
 
@@ -500,13 +500,13 @@ Operation *CIRDialect::materializeConstant(OpBuilder &builder, Attribute value,
 {
   // If this is a constant bytes attribute or the result type doesn't match the
   // attribute type, then generate a tfl.pseudo_const.
-  if (value.isa<ConstBytesAttr>() ||
-      (value.isa<ElementsAttr>() && value.cast<ElementsAttr>().getType() != type))
-    return builder.create<ConstOp>(loc, type, value.cast<ElementsAttr>());
+  if (mlir::isa<ConstBytesAttr>(value) ||
+      (mlir::isa<ElementsAttr>(value) && mlir::cast<ElementsAttr>(value).getType() != type))
+    return builder.create<ConstOp>(loc, type, mlir::cast<ElementsAttr>(value));
   if (ConstOp::isBuildableWith(value, type))
-    return builder.create<ConstOp>(loc, type, value.cast<ElementsAttr>());
+    return builder.create<ConstOp>(loc, type, mlir::cast<ElementsAttr>(value));
   if (NoValueOp::isBuildableWith(value, type))
-    return builder.create<NoValueOp>(loc, type, value.cast<UnitAttr>());
+    return builder.create<NoValueOp>(loc, type, mlir::cast<UnitAttr>(value));
   return nullptr;
 }
 

circle-mlir/circle-mlir/lib/dialect/src/ConstFold.inc.cpp

@@ -150,7 +150,7 @@ Attribute ConstFoldBinaryOp(Type result_type, Attribute operand1, Attribute oper
       operand2.dyn_cast_or_null<DenseElementsAttr>())
   {
     return ConstFoldBinaryOpDenseDense<AttrElementT, ElementValueT>(
-      result_type, operand1.cast<DenseElementsAttr>(), operand2.cast<DenseElementsAttr>(),
+      result_type, mlir::cast<DenseElementsAttr>(operand1), mlir::cast<DenseElementsAttr>(operand2),
       calculate);
   }
 
@@ -169,13 +169,13 @@ Attribute ConstFoldBinaryOp(Type result_type, ArrayRef<Attribute> operands,
 {
   // Note: All types are wrapped in tensor types in Circle. E.g., f32 is
   // represented as tensor<f32>. So we are only handling tensor types here.
-  auto type = result_type.dyn_cast<ShapedType>();
+  auto type = mlir::dyn_cast<ShapedType>(result_type);
   if (!type)
     return {};
 
   auto elemType = type.getElementType();
 
-  if (elemType.isa<FloatType>())
+  if (mlir::isa<FloatType>(elemType))
     return ConstFoldBinaryOp<FloatAttr>(result_type, operands[0], operands[1], float_calculate);
 
   if (elemType.isSignlessInteger())
@@ -191,12 +191,12 @@ Attribute ConstFoldUnaryOp(Type result_type, Attribute operand,
                            llvm::function_ref<APFloat(APFloat)> calculate)
 {
   assert(IsF32ShapedType(result_type));
-  auto result_shape_type = result_type.cast<ShapedType>();
+  auto result_shape_type = mlir::cast<ShapedType>(result_type);
 
   if (!result_shape_type.hasStaticShape())
     return {};
 
-  if (auto dense_elements = operand.dyn_cast_or_null<DenseElementsAttr>())
+  if (auto dense_elements = mlir::dyn_cast_or_null<DenseElementsAttr>(operand))
   {
     SmallVector<APFloat, 16> new_values;
     const int num_elements = result_shape_type.getNumElements();

circle-mlir/circle-mlir/lib/dialect/src/NameUtils.cpp

@@ -40,27 +40,27 @@ std::string GetNameFromLoc(Location loc)
   {
     Location curr_loc = locs.pop_back_val();
 
-    if (auto name_loc = curr_loc.dyn_cast<NameLoc>())
+    if (auto name_loc = mlir::dyn_cast<NameLoc>(curr_loc))
     {
       // Add name in NameLoc. For NameLoc we also account for names due to ops
       // in functions where the op's name is first.
       auto name = name_loc.getName().strref().split('@').first;
       // Skip if the name is for op type.
-      if (!name.endswith(":"))
+      if (!name.ends_with(":"))
       {
         loc_names.push_back(name);
         if (!name.empty())
           names_is_nonempty = true;
       }
       continue;
     }
-    else if (auto call_loc = curr_loc.dyn_cast<CallSiteLoc>())
+    else if (auto call_loc = mlir::dyn_cast<CallSiteLoc>(curr_loc))
     {
       // Use location of the Callee to generate the name.
       locs.push_back(call_loc.getCallee());
       continue;
     }
-    else if (auto fused_loc = curr_loc.dyn_cast<FusedLoc>())
+    else if (auto fused_loc = mlir::dyn_cast<FusedLoc>(curr_loc))
     {
       // Push all locations in FusedLoc in reverse order, so locations are
       // visited based on order in FusedLoc.

circle-mlir/circle-mlir/lib/dialect/src/ops/CastOp.h

@@ -41,23 +41,23 @@ OpFoldResult CastOp::fold(FoldAdaptor adaptor)
   }
 
   // For now, only supports cast for the integer/float input type.
-  auto elements_attr = operands[0].dyn_cast_or_null<mlir::DenseElementsAttr>();
+  auto elements_attr = mlir::dyn_cast_or_null<mlir::DenseElementsAttr>(operands[0]);
   if (!elements_attr)
   {
     return nullptr;
   }
 
-  auto result_element_type = getType().cast<ShapedType>().getElementType();
-  auto operand_element_type = getInput().getType().cast<ShapedType>().getElementType();
-  auto operand_int_type = operand_element_type.dyn_cast<IntegerType>();
+  auto result_element_type = mlir::cast<ShapedType>(getType()).getElementType();
+  auto operand_element_type = mlir::cast<ShapedType>(getInput().getType()).getElementType();
+  auto operand_int_type = mlir::dyn_cast<IntegerType>(operand_element_type);
   if (!result_element_type || !operand_element_type)
   {
     return nullptr;
   }
 
   if (mlir::isa<mlir::IntegerType>(result_element_type))
   {
-    auto result_int_type = result_element_type.dyn_cast<IntegerType>();
+    auto result_int_type = mlir::dyn_cast<IntegerType>(result_element_type);
     const int output_bitwidth = result_int_type.getWidth();
     // check for INT64 <--> INT32
     if (operand_int_type)
@@ -97,7 +97,7 @@ OpFoldResult CastOp::fold(FoldAdaptor adaptor)
   else if (mlir::isa<mlir::FloatType>(result_element_type))
   {
     // Refer to https://llvm.org/doxygen/classllvm_1_1APFloat.html
-    auto result_float_type = result_element_type.dyn_cast<FloatType>();
+    auto result_float_type = mlir::dyn_cast<FloatType>(result_element_type);
     // To get the correct semantics of floating point from the type of this CastOp
     const llvm::fltSemantics &semantics = result_float_type.getFloatSemantics();
     auto cast = [&](const llvm::APInt &value) {

circle-mlir/circle-mlir/lib/dialect/src/ops/ConcatenationOp.h

@@ -150,7 +150,7 @@ bool IsConcatenationOpConstFoldable(ConcatenationOp op, ArrayRef<Attribute> oper
     return false;
 
   return llvm::all_of(
-    operands, [](Attribute operand) { return operand && operand.isa<DenseElementsAttr>(); });
+    operands, [](Attribute operand) { return operand && mlir::isa<DenseElementsAttr>(operand); });
 }
 
 DenseElementsAttr ConstFoldConcatenateOpDense(ArrayRef<Attribute> operands,

circle-mlir/circle-mlir/lib/dialect/src/ops/ConstOp.h

@@ -83,10 +83,10 @@ bool ConstOp::isBuildableWith(Attribute value, Type type)
   if (!typedAttr || typedAttr.getType() != type)
     return false;
   // Integer values must be signless.
-  if (type.isa<IntegerType>() && !type.cast<IntegerType>().isSignless())
+  if (mlir::isa<IntegerType>(type) && !mlir::cast<IntegerType>(type).isSignless())
     return false;
   // Integer, float, and element attributes are buildable.
-  return value.isa<IntegerAttr, FloatAttr, ElementsAttr>();
+  return mlir::isa<IntegerAttr, FloatAttr, ElementsAttr>(value);
 }
 
 } // namespace Circle

circle-mlir/circle-mlir/lib/dialect/src/ops/Conv2DOp.h

@@ -54,10 +54,11 @@ LogicalResult ComputeConvWindowedOutputSize(int64_t input_size, int64_t filter_s
 }
 
 LogicalResult Conv2DOp::inferReturnTypes(MLIRContext *, std::optional<Location> location,
-                                         ValueRange operands, DictionaryAttr attr, OpaqueProperties,
-                                         RegionRange, SmallVectorImpl<Type> &inferredReturnTypes)
+                                         ValueRange operands, DictionaryAttr attr,
+                                         OpaqueProperties properties, RegionRange,
+                                         SmallVectorImpl<Type> &inferredReturnTypes)
 {
-  Conv2DOpAdaptor op(operands, attr);
+  Conv2DOpAdaptor op(operands, attr, properties);
 
   const Value input = op.getInput();
   const Value filter = op.getFilter();

circle-mlir/circle-mlir/lib/dialect/src/ops/FullyConnectedOp.h

@@ -96,7 +96,7 @@ LogicalResult FullyConnectedOp::fold(FoldAdaptor adaptor, SmallVectorImpl<OpFold
     return failure();
 
   // Bias tensor is optional.
-  const bool has_bias = !(!getBias() || getBias().getType().isa<NoneType>());
+  const bool has_bias = !(!getBias() || mlir::isa<NoneType>(getBias().getType()));
 
   // Get the tensors.
   DenseElementsAttr input_tensor, weights_tensor, bias_tensor;