mlir/test/mlir-tblgen/trait.mlir

   1 // RUN: mlir-opt -test-trait-folder %s | FileCheck %s
   2
   3 //===----------------------------------------------------------------------===//
   4 // Test that involutions fold correctly
   5 //===----------------------------------------------------------------------===//
   6
   7 // CHECK-LABEL: func @testSingleInvolution
   8 // CHECK-SAME:  ([[ARG0:%.+]]: i32)
   9 func.func @testSingleInvolution(%arg0 : i32) -> i32 {
  10   // CHECK: [[INVOLUTION:%.+]] = "test.op_involution_trait_no_operation_fold"([[ARG0]])
  11   %0 = "test.op_involution_trait_no_operation_fold"(%arg0) : (i32) -> i32
  12   // CHECK: return [[INVOLUTION]]
  13   return %0: i32
  14 }
  15
  16 // CHECK-LABEL: func @testDoubleInvolution
  17 // CHECK-SAME:  ([[ARG0:%.+]]: i32)
  18 func.func @testDoubleInvolution(%arg0: i32) -> i32 {
  19   %0 = "test.op_involution_trait_no_operation_fold"(%arg0) : (i32) -> i32
  20   %1 = "test.op_involution_trait_no_operation_fold"(%0) : (i32) -> i32
  21   // CHECK: return [[ARG0]]
  22   return %1: i32
  23 }
  24
  25 // CHECK-LABEL: func @testTripleInvolution
  26 // CHECK-SAME:  ([[ARG0:%.+]]: i32)
  27 func.func @testTripleInvolution(%arg0: i32) -> i32 {
  28   // CHECK: [[INVOLUTION:%.+]] = "test.op_involution_trait_no_operation_fold"([[ARG0]])
  29   %0 = "test.op_involution_trait_no_operation_fold"(%arg0) : (i32) -> i32
  30   %1 = "test.op_involution_trait_no_operation_fold"(%0) : (i32) -> i32
  31   %2 = "test.op_involution_trait_no_operation_fold"(%1) : (i32) -> i32
  32   // CHECK: return [[INVOLUTION]]
  33   return %2: i32
  34 }
  35
  36 //===----------------------------------------------------------------------===//
  37 // Test that involutions fold occurs if operation fold fails
  38 //===----------------------------------------------------------------------===//
  39
  40 // CHECK-LABEL: func @testFailingOperationFolder
  41 // CHECK-SAME:  ([[ARG0:%.+]]: i32)
  42 func.func @testFailingOperationFolder(%arg0: i32) -> i32 {
  43   %0 = "test.op_involution_trait_failing_operation_fold"(%arg0) : (i32) -> i32
  44   %1 = "test.op_involution_trait_failing_operation_fold"(%0) : (i32) -> i32
  45   // CHECK: return [[ARG0]]
  46   return %1: i32
  47 }
  48
  49 //===----------------------------------------------------------------------===//
  50 // Test that involution fold does not occur if operation fold succeeds
  51 //===----------------------------------------------------------------------===//
  52
  53 // CHECK-LABEL: func @testInhibitInvolution
  54 // CHECK-SAME:  ([[ARG0:%.+]]: i32)
  55 func.func @testInhibitInvolution(%arg0: i32) -> i32 {
  56   // CHECK: [[OP:%.+]] = "test.op_involution_trait_succesful_operation_fold"([[ARG0]])
  57   %0 = "test.op_involution_trait_succesful_operation_fold"(%arg0) : (i32) -> i32
  58   %1 = "test.op_involution_trait_succesful_operation_fold"(%0) : (i32) -> i32
  59   // CHECK: return [[OP]]
  60   return %1: i32
  61 }
  62
  63 //===----------------------------------------------------------------------===//
  64 // Test that idempotent folding works correctly
  65 //===----------------------------------------------------------------------===//
  66
  67 // CHECK-LABEL: func @testSingleIdempotent
  68 // CHECK-SAME:  ([[ARG0:%.+]]: i32)
  69 func.func @testSingleIdempotent(%arg0 : i32) -> i32 {
  70   // CHECK: [[IDEMPOTENT:%.+]] = "test.op_idempotent_trait"([[ARG0]])
  71   %0 = "test.op_idempotent_trait"(%arg0) : (i32) -> i32
  72   // CHECK: return [[IDEMPOTENT]]
  73   return %0: i32
  74 }
  75
  76 // CHECK-LABEL: func @testDoubleIdempotent
  77 // CHECK-SAME:  ([[ARG0:%.+]]: i32)
  78 func.func @testDoubleIdempotent(%arg0: i32) -> i32 {
  79   // CHECK: [[IDEMPOTENT:%.+]] = "test.op_idempotent_trait"([[ARG0]])
  80   %0 = "test.op_idempotent_trait"(%arg0) : (i32) -> i32
  81   %1 = "test.op_idempotent_trait"(%0) : (i32) -> i32
  82   // CHECK: return [[IDEMPOTENT]]
  83   return %1: i32
  84 }
  85
  86 // CHECK-LABEL: func @testTripleIdempotent
  87 // CHECK-SAME:  ([[ARG0:%.+]]: i32)
  88 func.func @testTripleIdempotent(%arg0: i32) -> i32 {
  89   // CHECK: [[IDEMPOTENT:%.+]] = "test.op_idempotent_trait"([[ARG0]])
  90   %0 = "test.op_idempotent_trait"(%arg0) : (i32) -> i32
  91   %1 = "test.op_idempotent_trait"(%0) : (i32) -> i32
  92   %2 = "test.op_idempotent_trait"(%1) : (i32) -> i32
  93   // CHECK: return [[IDEMPOTENT]]
  94   return %2: i32
  95 }
  96
  97 // CHECK-LABEL: func @testBinaryIdempotent
  98 // CHECK-SAME:  ([[ARG0:%.+]]: i32)
  99 func.func @testBinaryIdempotent(%arg0 : i32) -> i32 {
 100   %0 = "test.op_idempotent_trait_binary"(%arg0, %arg0) : (i32, i32) -> i32
 101   // CHECK: return [[ARG0]]
 102   return %0: i32
 103 }