Integrate LLVM at 3e223e3 (#19978)

Integrate LLVM at llvm/llvm-project@3e223e3a2

Clean, no local changes.

The .bc file update is a MLIR bytecode test file that contains a
`tosa.mul` op, which had a breaking change so had to be adjusted.

A TFLite import test is disabled pending the longer term fix outlined in
#19777 .

---------

Signed-off-by: Benoit Jacob <[email protected]>

Author: bjacob

.github/workflows/pkgci_unit_test.yml

@@ -77,5 +77,8 @@ jobs:
         run: |
           source ${VENV_DIR}/bin/activate
           bash ./build_tools/scripts/setup_tf_python.sh
-          python compiler/bindings/python/test/tools/compiler_tflite_test.py
+          # TODO: reenable. Temporarily disabled due to a breaking change in
+          # tosa.mul. This can be reenabled after the TensorFlow tools are
+          # rebuilt with a newer llvm-project with the new tosa.mul.
+          # python compiler/bindings/python/test/tools/compiler_tflite_test.py
           python compiler/bindings/python/test/tools/compiler_tf_test.py

compiler/bindings/python/test/api/testdata/bytecode_zero_terminated_testfile.bc

@@ -41,14 +41,16 @@
 //       CHECK:       tosa.negate %[[RESULT]]
 
 func.func @mlp_invocation(%lhs: tensor<2x4xf32>, %rhs : tensor<4x8xf32>) -> tensor<2x8xf32> {
-  %lhs_3D = tosa.reshape %lhs {new_shape = array<i64 : 1, 2, 4>} : (tensor<2x4xf32>) -> tensor<1x2x4xf32>
-  %rhs_3D = tosa.reshape %rhs {new_shape = array<i64 : 1, 4, 8>} : (tensor<4x8xf32>) -> tensor<1x4x8xf32>
+  %lhs_shape = tosa.const_shape {value = dense<[1, 2, 4]> : tensor<3xindex>} : () -> !tosa.shape<3>
+  %rhs_shape = tosa.const_shape {value = dense<[1, 4, 8]> : tensor<3xindex>} : () -> !tosa.shape<3>
+  %lhs_3D = tosa.reshape %lhs, %lhs_shape : (tensor<2x4xf32>, !tosa.shape<3>) -> tensor<1x2x4xf32>
+  %rhs_3D = tosa.reshape %rhs, %rhs_shape : (tensor<4x8xf32>, !tosa.shape<3>) -> tensor<1x4x8xf32>
   %0 = tosa.matmul %lhs_3D, %rhs_3D : (tensor<1x2x4xf32>, tensor<1x4x8xf32>) -> tensor<1x2x8xf32>
   %1 = tosa.clamp %0 {
-      min_int = 0 : i64, max_int = 9223372036854775807 : i64,
-      min_fp = 0.0 : f32, max_fp = 3.4028235e+38 : f32}
+      min_val = 0.0 : f32, max_val = 3.4028235e+38 : f32}
       : (tensor<1x2x8xf32>) -> tensor<1x2x8xf32>
   %2 = tosa.negate %1 : (tensor<1x2x8xf32>) -> tensor<1x2x8xf32>
-  %3 = tosa.reshape %2 {new_shape = array<i64 : 2, 8>}  : (tensor<1x2x8xf32>) -> tensor<2x8xf32>
+  %result_shape = tosa.const_shape {value = dense<[2, 8]> : tensor<2xindex>} : () -> !tosa.shape<2>
+  %3 = tosa.reshape %2, %result_shape : (tensor<1x2x8xf32>, !tosa.shape<2>) -> tensor<2x8xf32>
   return %3 : tensor<2x8xf32>
 }

compiler/plugins/input/TOSA/InputConversion/test/apply_pdl_patterns_tosa.mlir

@@ -49,8 +49,6 @@ pdl.pattern @mlp : benefit(1) {
   %rhs_type = pdl.type
   %rhs = pdl.operand : %rhs_type
   %matmul_type = pdl.type
-  %min_int = pdl.attribute = 0 : i64
-  %max_int = pdl.attribute
   %min_fp = pdl.attribute = 0.0 : f32
   %max_fp = pdl.attribute
   %matmul = pdl.operation "tosa.matmul"(%lhs, %rhs : !pdl.value, !pdl.value)
@@ -63,8 +61,7 @@ pdl.pattern @mlp : benefit(1) {
   %matmul_result = pdl.result 0 of %matmul
   %relu_type = pdl.type
   %relu = pdl.operation "tosa.clamp"(%matmul_result : !pdl.value) {
-      "min_int" = %min_int, "max_int" = %max_int,
-      "min_fp" = %min_fp, "max_fp" = %max_fp}
+      "min_val" = %min_fp, "max_val" = %max_fp}
       -> (%relu_type : !pdl.type)
 
   pdl.rewrite %matmul {

compiler/plugins/input/TOSA/InputConversion/test/tosa.pdl.mlir

@@ -32,7 +32,8 @@
 #x86_64_target = #hal.executable.target<"llvm-cpu", "embedded-elf-x86_64", {
   data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128",
   native_vector_size = 32 : index,
-  target_triple = "x86_64-none-elf"
+  target_triple = "x86_64-none-elf",
+  cpu = "generic"
 }>
 
 // The target devices that the program will run on. We can compile and run with
@@ -45,15 +46,17 @@
 
 module @example attributes {hal.device.targets = [#cpu_target]} {
   func.func @mlp_invocation(%lhs: tensor<2x4xf32>, %rhs : tensor<4x8xf32>) -> tensor<2x8xf32> {
-    %lhs_3D = tosa.reshape %lhs {new_shape = array<i64 : 1, 2, 4>} : (tensor<2x4xf32>) -> tensor<1x2x4xf32>
-    %rhs_3D = tosa.reshape %rhs {new_shape = array<i64 : 1, 4, 8>} : (tensor<4x8xf32>) -> tensor<1x4x8xf32>
+    %lhs_shape = tosa.const_shape {value = dense<[1, 2, 4]> : tensor<3xindex>} : () -> !tosa.shape<3>
+    %rhs_shape = tosa.const_shape {value = dense<[1, 4, 8]> : tensor<3xindex>} : () -> !tosa.shape<3>
+    %lhs_3D = tosa.reshape %lhs, %lhs_shape : (tensor<2x4xf32>, !tosa.shape<3>) -> tensor<1x2x4xf32>
+    %rhs_3D = tosa.reshape %rhs, %rhs_shape : (tensor<4x8xf32>, !tosa.shape<3>) -> tensor<1x4x8xf32>
     %0 = tosa.matmul %lhs_3D, %rhs_3D : (tensor<1x2x4xf32>, tensor<1x4x8xf32>) -> tensor<1x2x8xf32>
     %1 = tosa.clamp %0 {
-        min_int = 0 : i64, max_int = 9223372036854775807 : i64,
-        min_fp = 0.0 : f32, max_fp = 3.4028235e+38 : f32}
+        min_val = 0.0 : f32, max_val = 3.4028235e+38 : f32}
         : (tensor<1x2x8xf32>) -> tensor<1x2x8xf32>
     %2 = tosa.negate %1 : (tensor<1x2x8xf32>) -> tensor<1x2x8xf32>
-    %3 = tosa.reshape %2 {new_shape = array<i64 : 2, 8>}  : (tensor<1x2x8xf32>) -> tensor<2x8xf32>
+    %result_shape = tosa.const_shape {value = dense<[2, 8]> : tensor<2xindex>} : () -> !tosa.shape<2>
+    %3 = tosa.reshape %2, %result_shape : (tensor<1x2x8xf32>, !tosa.shape<2>) -> tensor<2x8xf32>
     return %3 : tensor<2x8xf32>
   }
 }

samples/custom_dispatch/cpu/mlp_plugin/mlp_tosa.mlir

@@ -50,8 +50,6 @@ pdl.pattern @mlp : benefit(1) {
   %lhs = pdl.operand : %lhs_type
   %rhs = pdl.operand : %rhs_type
   %matmul_type = pdl.type
-  %min_int = pdl.attribute = 0 : i64
-  %max_int = pdl.attribute
   %min_fp = pdl.attribute = 0.0 : f32
   %max_fp = pdl.attribute
   %matmul = pdl.operation "tosa.matmul"(%lhs, %rhs : !pdl.value, !pdl.value)
@@ -63,8 +61,7 @@ pdl.pattern @mlp : benefit(1) {
   %matmul_result = pdl.result 0 of %matmul
   %relu_type = pdl.type
   %relu = pdl.operation "tosa.clamp"(%matmul_result : !pdl.value) {
-      "min_int" = %min_int, "max_int" = %max_int,
-      "min_fp" = %min_fp, "max_fp" = %max_fp}
+      "min_val" = %min_fp, "max_val" = %max_fp}
       -> (%relu_type : !pdl.type)
 
   pdl.rewrite %matmul {

samples/custom_dispatch/cpu/mlp_plugin/mlp_tosa_spec.pdl.mlir

@@ -1,6 +1,6 @@
 // Minimized from dynamic_tosa_quantized_fully_connected_issue_10859.mlir
 
 func.func @clamp(%arg0: tensor<?xi8>) ->tensor<?xi8>{
-  %1 = tosa.clamp %arg0 {max_fp = 0.000000e+00 : f32, max_int = 127 : i64, min_fp = 0.000000e+00 : f32, min_int = -128 : i64} : (tensor<?xi8>) -> tensor<?xi8>
+  %1 = tosa.clamp %arg0 {max_val = 127 : i8, min_val = -128 : i8} : (tensor<?xi8>) -> tensor<?xi8>
   return %1 : tensor<?xi8>
 }

tests/e2e/regression/dynamic_tosa_clamp.mlir

@@ -3,10 +3,10 @@
 func.func @main(%arg0: tensor<256xi8>, %arg1: tensor<2xi32>, %arg2: tensor<2x32xi8>, %arg3: tensor<32xi32>, %arg4: tensor<32x32xi8>, %arg5: tensor<32xi32>, %arg6: tensor<32x3360xi8>, %arg7: tensor<?x3360xi8>) -> (tensor<?x2xi8>) {
   %0 = tosa.fully_connected %arg7, %arg6, %arg5 {input_zp = -128 : i32, weight_zp = 0 : i32} : (tensor<?x3360xi8>, tensor<32x3360xi8>, tensor<32xi32>) -> tensor<?x32xi32>
   %1 = tosa.rescale %0 {double_round = true, input_zp = 0 : i32, multiplier = array<i32:1101627623>, output_zp = -128 : i32, per_channel = false, scale32 = true, shift = array<i8:36>} : (tensor<?x32xi32>) -> tensor<?x32xi8>
-  %2 = tosa.clamp %1 {max_fp = 0.000000e+00 : f32, max_int = 127 : i64, min_fp = 0.000000e+00 : f32, min_int = -128 : i64} : (tensor<?x32xi8>) -> tensor<?x32xi8>
+  %2 = tosa.clamp %1 {max_val = 127 : i8, min_val = -128 : i8} : (tensor<?x32xi8>) -> tensor<?x32xi8>
   %3 = tosa.fully_connected %2, %arg4, %arg3 {input_zp = -128 : i32, weight_zp = 0 : i32} : (tensor<?x32xi8>, tensor<32x32xi8>, tensor<32xi32>) -> tensor<?x32xi32>
   %4 = tosa.rescale %3 {double_round = true, input_zp = 0 : i32, multiplier = array<i32:1255393165>, output_zp = -128 : i32, per_channel = false, scale32 = true, shift = array<i8:35>} : (tensor<?x32xi32>) -> tensor<?x32xi8>
-  %5 = tosa.clamp %4 {max_fp = 0.000000e+00 : f32, max_int = 127 : i64, min_fp = 0.000000e+00 : f32, min_int = -128 : i64} : (tensor<?x32xi8>) -> tensor<?x32xi8>
+  %5 = tosa.clamp %4 {max_val = 127 : i8, min_val = -128 : i8} : (tensor<?x32xi8>) -> tensor<?x32xi8>
   %6 = tosa.fully_connected %5, %arg2, %arg1 {input_zp = -128 : i32, weight_zp = 0 : i32} : (tensor<?x32xi8>, tensor<2x32xi8>, tensor<2xi32>) -> tensor<?x2xi32>
   %7 = tosa.rescale %6 {double_round = true, input_zp = 0 : i32, multiplier = array<i32:1879992488>, output_zp = 44 : i32, per_channel = false, scale32 = true, shift = array<i8:39>} : (tensor<?x2xi32>) -> tensor<?x2xi8>
   %8 = tosa.table %7, %arg0 : (tensor<?x2xi8>, tensor<256xi8>) -> tensor<?x2xi8>

tests/e2e/regression/dynamic_tosa_quantized_fully_connected_issue_10859.mlir

@@ -1,13 +1,13 @@
 func.func @tensor_float() {
   %0 = util.unfoldable_constant dense<[1.0, 0.0, 4.5, 2.0]> : tensor<4xf32>
-  %result = tosa.clamp %0 {min_int = 1 : i64, max_int = 4 : i64, min_fp = 1.0 : f32, max_fp = 4.0 : f32} : (tensor<4xf32>) -> tensor<4xf32>
+  %result = tosa.clamp %0 {min_val = 1.0 : f32, max_val = 4.0 : f32} : (tensor<4xf32>) -> tensor<4xf32>
   check.expect_almost_eq_const(%result, dense<[1.0, 1.0, 4.0, 2.0]> : tensor<4xf32>) : tensor<4xf32>
   return
 }
 
 func.func @tensor_int() {
   %0 = util.unfoldable_constant dense<[1, 0, 5, 2]> : tensor<4xi32>
-  %result = tosa.clamp %0 {min_int = 1 : i64, max_int = 4 : i64, min_fp = 1.0 : f32, max_fp = 4.0 : f32} : (tensor<4xi32>) -> tensor<4xi32>
+  %result = tosa.clamp %0 {min_val = 1 : i32, max_val = 4 : i32} : (tensor<4xi32>) -> tensor<4xi32>
   check.expect_eq_const(%result, dense<[1, 1, 4, 2]> : tensor<4xi32>) : tensor<4xi32>
   return
 }

tests/e2e/tosa_ops/clamp.mlir

@@ -1,20 +1,23 @@
 func.func @tensor_downrank() {
   %0 = util.unfoldable_constant dense<[[1, 2], [3, 4]]> : tensor<2x2xi32>
-  %result = tosa.reshape %0 { new_shape = array<i64: 4> } : (tensor<2x2xi32>) -> tensor<4xi32>
+  %1 = tosa.const_shape {value = dense<[4]> : tensor<1xindex>} : () -> !tosa.shape<1>
+  %result = tosa.reshape %0, %1 : (tensor<2x2xi32>, !tosa.shape<1>) -> tensor<4xi32>
   check.expect_eq_const(%result, dense<[1, 2, 3, 4]> : tensor<4xi32>) : tensor<4xi32>
   return
 }
 
 func.func @tensor_uprank() {
   %0 = util.unfoldable_constant dense<[1, 2, 3, 4]> : tensor<4xi32>
-  %result = tosa.reshape %0 { new_shape = array<i64:2, 2> } : (tensor<4xi32>) -> tensor<2x2xi32>
+  %1 = tosa.const_shape {value = dense<[2, 2]> : tensor<2xindex>} : () -> !tosa.shape<2>
+  %result = tosa.reshape %0, %1 : (tensor<4xi32>, !tosa.shape<2>) -> tensor<2x2xi32>
   check.expect_eq_const(%result, dense<[[1, 2], [3, 4]]> : tensor<2x2xi32>) : tensor<2x2xi32>
   return
 }
 
 func.func @tensor_crossrank() {
   %0 = util.unfoldable_constant dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32>
-  %result = tosa.reshape %0 { new_shape = array<i64:3, 2> } : (tensor<2x3xi32>) -> tensor<3x2xi32>
+  %1 = tosa.const_shape {value = dense<[3, 2]> : tensor<2xindex>} : () -> !tosa.shape<2>
+  %result = tosa.reshape %0, %1 : (tensor<2x3xi32>, !tosa.shape<2>) -> tensor<3x2xi32>
   check.expect_eq_const(%result, dense<[[1, 2], [3, 4], [5, 6]]> : tensor<3x2xi32>) : tensor<3x2xi32>
   return
 }