Sebastián Ramírez <******@****.***> 1688749933 +0200

module {
  func.func @main() -> tensor<1xi64> {
  %0 = "tfl.custom"() {custom_code = "stablehlo.constant", custom_option = #tfl<const_bytes : "0x76616C75650001020109010101062C022401">} : () -> tensor<1xi64>
  func.return %0 : tensor<1xi64>
  }
}

// CHECK:  module {
// CHECK-NEXT:    func @main() -> tensor<1xi64> {
// CHECK-NEXT:    %[[c0:.+]] = stablehlo.constant dense<2> : tensor<1xi64>
// CHECK-NEXT:    return %[[c0]] : tensor<1xi64>
// CHECK-NEXT:    }

// typexpr    <expr> (               <mode>                    )
//
// constant   <expr> (<untyped kind> <mode>                    )
// constant   <expr> (               <mode>       of type <typ>)
// constant   <expr> (<untyped kind> <mode> <val>              )
// constant   <expr> (               <mode> <val> of type <typ>)
//
// variable   <expr> (<untyped kind> <mode>                    )

// Checks if the value is a float constant and its splat value is equal to `x`.
class IsSplatValueEqual<string x> : Constraint<CPred<
  "IsSplatValueEqual<float>($0, "# x #")">>;

// Checks if two values are float constants and their values are equal.
def AreSplatValuesEqual : Constraint<CPred<
  "AreSplatValuesEqual<float>($0, $1)">>;

// Checks if the value is an integer constant and its splat value is equal to x.

calvin <******@****.***> 1706611761 +0800

// CHECK-LABEL: conv
// CHECK-DAG:  %[[CONSTANT:.*]] = arith.constant dense<0.000000e+00> : tensor<16xf32>
// CHECK-DAG:  %[[CONSTANT0:.*]] = arith.constant dense<[3, 0, 1, 2]> : tensor<4xi32>
// CHECK-DAG:  %[[CONSTANT1:.*]] = arith.constant dense<[{{\[}}0, 0], [1, 1], [1, 1], [0, 0]]> : tensor<4x2xi32>
// CHECK:  %0 = "tf.Transpose"(%arg1, %[[CONSTANT0]]) : (tensor<3x3x3x16xf32>, tensor<4xi32>) -> tensor<16x3x3x3xf32>

import static gradle.unit.test.Constant7.CONSTANT7;
import static gradle.unit.test.Constant8.CONSTANT8;
import static gradle.unit.test.Constant9.CONSTANT9;
import static gradle.unit.test.Constant10.CONSTANT10;

@Annotation(CONSTANT1 $addition)
class A {
    @Annotation(CONSTANT2 $addition)
    private Map<@Annotation(CONSTANT3 $addition) String, String> field;

    @Annotation(CONSTANT4 $addition)

// only be used as the shape-determining operand; it will not replace other
// usages of the original constant. If the operands are not constants (i.e.
// results of some other computation), then the pass recursively traverses the
// call tree upwards and duplicates all constants found in the subtree in a
// similar manner.
//
// This pass may be used to avoid placing shape-determining constants in the CPU

  Option<bool> fold_all_constants_flag_{
      *this, "fold-all-constants",
      llvm::cl::desc("Whether to fold all constants or just i32."),
      llvm::cl::init(false)};
};

void CopyConstantIntoFunc(int argument_index, Operation* const_op,
                          func::FuncOp func) {
  assert(
      (llvm::isa<TFL::ConstOp, TFL::QConstOp, arith::ConstantOp>(const_op)) &&
      "Expect QConst or Const op.");

// CHECK:  return %1
}

// CHECK-LABEL: fakeQuantFolded
func.func @fakeQuantFolded() -> (tensor<8xf32>) {
  %in = arith.constant dense<0.0> : tensor<8xf32>
  %min = arith.constant dense<0.0> : tensor<f32>
  %max = arith.constant dense<15.0> : tensor<f32>
  %mini = "tf.Identity"(%min) : (tensor<f32>) -> tensor<f32>
  %maxi = "tf.Identity"(%max) : (tensor<f32>) -> tensor<f32>