llvm/test/CodeGen/SPIRV/instructions/scalar-integer-arithmetic.ll

; RUN: llc -verify-machineinstrs -O0 -mtriple=spirv64-unknown-unknown %s -o - | FileCheck %s
; RUN: %if spirv-tools %{ llc -O0 -mtriple=spirv64-unknown-unknown %s -o - -filetype=obj | spirv-val %}

; RUN: llc -verify-machineinstrs -O0 -mtriple=spirv32-unknown-unknown %s -o - | FileCheck %s
; RUN: %if spirv-tools %{ llc -O0 -mtriple=spirv32-unknown-unknown %s -o - -filetype=obj | spirv-val %}

; CHECK-DAG: OpName [[BOOL_ADD:%.+]] "bool_add"
; CHECK-DAG: OpName [[BOOL_SUB:%.+]] "bool_sub"
; CHECK-DAG: OpName [[SCALAR_ADD:%.+]] "scalar_add"
; CHECK-DAG: OpName [[SCALAR_SUB:%.+]] "scalar_sub"
; CHECK-DAG: OpName [[BOOL_MUL:%.+]] "bool_mul"
; CHECK-DAG: OpName [[BOOL_MUL_NSW:%.+]] "bool_mul_nsw"
; CHECK-DAG: OpName [[BOOL_MUL_NUW:%.+]] "bool_mul_nuw"
; CHECK-DAG: OpName [[SCALAR_MUL:%.+]] "scalar_mul"
; CHECK-DAG: OpName [[SCALAR_UDIV:%.+]] "scalar_udiv"
; CHECK-DAG: OpName [[SCALAR_SDIV:%.+]] "scalar_sdiv"
; CHECK-DAG: OpName [[SCALAR_UREM:%.+]] "scalar_urem"
; CHECK-DAG: OpName [[SCALAR_SREM:%.+]] "scalar_srem"
; CHECK-DAG: OpName [[SCALAR_SMOD:%.+]] "scalar_smod"
; CHECK-DAG: OpName [[SCALAR_SNEGATE:%.+]] "scalar_snegate"

; CHECK-NOT: DAG-FENCE

; CHECK-DAG: [[BOOL:%.+]] = OpTypeBool
; CHECK-DAG: [[SCALAR:%.+]] = OpTypeInt 32
; CHECK-DAG: [[SCALAR_FN:%.+]] = OpTypeFunction [[SCALAR]] [[SCALAR]] [[SCALAR]]
; CHECK-DAG: [[SCALAR_FN1:%.+]] = OpTypeFunction [[SCALAR]] [[SCALAR]]
; CHECK-DAG: [[BOOL_FN:%.+]] = OpTypeFunction [[BOOL]] [[BOOL]] [[BOOL]]
; CHECK-DAG: [[ZERO:%.+]] = OpConstantNull [[SCALAR]]

; CHECK-NOT: DAG-FENCE


;; Test add on scalar:
define i1 @bool_add(i1 %a, i1 %b) {
    %c = add i1 %a, %b
    ret i1 %c
}

; CHECK:      [[BOOL_ADD]] = OpFunction [[BOOL]] None [[BOOL_FN]]
; CHECK-NEXT: [[A:%.+]] = OpFunctionParameter [[BOOL]]
; CHECK-NEXT: [[B:%.+]] = OpFunctionParameter [[BOOL]]
; CHECK:      OpLabel
; CHECK:      [[C:%.+]] = OpLogicalNotEqual [[BOOL]] [[A]] [[B]]
; CHECK:      OpReturnValue [[C]]
; CHECK-NEXT: OpFunctionEnd

define i32 @scalar_add(i32 %a, i32 %b) {
    %c = add i32 %a, %b
    ret i32 %c
}

; CHECK:      [[SCALAR_ADD]] = OpFunction [[SCALAR]] None [[SCALAR_FN]]
; CHECK-NEXT: [[A:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK-NEXT: [[B:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK:      OpLabel
; CHECK:      [[C:%.+]] = OpIAdd [[SCALAR]] [[A]] [[B]]
; CHECK:      OpReturnValue [[C]]
; CHECK-NEXT: OpFunctionEnd


;; Test sub on scalar:
define i1 @bool_sub(i1 %a, i1 %b) {
    %c = sub i1 %a, %b
    ret i1 %c
}

; CHECK:      [[BOOL_SUB]] = OpFunction [[BOOL]] None [[BOOL_FN]]
; CHECK-NEXT: [[A:%.+]] = OpFunctionParameter [[BOOL]]
; CHECK-NEXT: [[B:%.+]] = OpFunctionParameter [[BOOL]]
; CHECK:      OpLabel
; CHECK:      [[C:%.+]] = OpLogicalNotEqual [[BOOL]] [[A]] [[B]]
; CHECK:      OpReturnValue [[C]]
; CHECK-NEXT: OpFunctionEnd

define i32 @scalar_sub(i32 %a, i32 %b) {
    %c = sub i32 %a, %b
    ret i32 %c
}

; CHECK:      [[SCALAR_SUB]] = OpFunction [[SCALAR]] None [[SCALAR_FN]]
; CHECK-NEXT: [[A:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK-NEXT: [[B:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK:      OpLabel
; CHECK:      [[C:%.+]] = OpISub [[SCALAR]] [[A]] [[B]]
; CHECK:      OpReturnValue [[C]]
; CHECK-NEXT: OpFunctionEnd


;; Test mul on scalar:
define i1 @bool_mul(i1 %a, i1 %b) {
    %c = mul i1 %a, %b
    ret i1 %c
}

; CHECK:      [[BOOL_MUL]] = OpFunction [[BOOL]] None [[BOOL_FN]]
; CHECK-NEXT: [[A:%.+]] = OpFunctionParameter [[BOOL]]
; CHECK-NEXT: [[B:%.+]] = OpFunctionParameter [[BOOL]]
; CHECK:      OpLabel
; CHECK:      [[C:%.+]] = OpLogicalAnd [[BOOL]] [[A]] [[B]]
; CHECK:      OpReturnValue [[C]]
; CHECK-NEXT: OpFunctionEnd

define i1 @bool_mul_nsw(i1 %a, i1 %b) {
    %c = mul nsw i1 %a, %b
    ret i1 %c
}

; CHECK:      [[BOOL_MUL_NSW]] = OpFunction [[BOOL]] None [[BOOL_FN]]
; CHECK-NEXT: [[A:%.+]] = OpFunctionParameter [[BOOL]]
; CHECK-NEXT: [[B:%.+]] = OpFunctionParameter [[BOOL]]
; CHECK:      OpLabel
; CHECK:      [[C:%.+]] = OpLogicalAnd [[BOOL]] [[A]] [[B]]
; CHECK:      OpReturnValue [[C]]
; CHECK-NEXT: OpFunctionEnd

define i1 @bool_mul_nuw(i1 %a, i1 %b) {
    %c = mul nuw i1 %a, %b
    ret i1 %c
}

; CHECK:      [[BOOL_MUL_NUW]] = OpFunction [[BOOL]] None [[BOOL_FN]]
; CHECK-NEXT: [[A:%.+]] = OpFunctionParameter [[BOOL]]
; CHECK-NEXT: [[B:%.+]] = OpFunctionParameter [[BOOL]]
; CHECK:      OpLabel
; CHECK:      [[C:%.+]] = OpLogicalAnd [[BOOL]] [[A]] [[B]]
; CHECK:      OpReturnValue [[C]]
; CHECK-NEXT: OpFunctionEnd

define i32 @scalar_mul(i32 %a, i32 %b) {
    %c = mul i32 %a, %b
    ret i32 %c
}

; CHECK:      [[SCALAR_MUL]] = OpFunction [[SCALAR]] None [[SCALAR_FN]]
; CHECK-NEXT: [[A:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK-NEXT: [[B:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK:      OpLabel
; CHECK:      [[C:%.+]] = OpIMul [[SCALAR]] [[A]] [[B]]
; CHECK:      OpReturnValue [[C]]
; CHECK-NEXT: OpFunctionEnd


;; Test udiv on scalar:
define i32 @scalar_udiv(i32 %a, i32 %b) {
    %c = udiv i32 %a, %b
    ret i32 %c
}

; CHECK:      [[SCALAR_UDIV]] = OpFunction [[SCALAR]] None [[SCALAR_FN]]
; CHECK-NEXT: [[A:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK-NEXT: [[B:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK:      OpLabel
; CHECK:      [[C:%.+]] = OpUDiv [[SCALAR]] [[A]] [[B]]
; CHECK:      OpReturnValue [[C]]
; CHECK-NEXT: OpFunctionEnd


;; Test sdiv on scalar:
define i32 @scalar_sdiv(i32 %a, i32 %b) {
    %c = sdiv i32 %a, %b
    ret i32 %c
}

; CHECK:      [[SCALAR_SDIV]] = OpFunction [[SCALAR]] None [[SCALAR_FN]]
; CHECK-NEXT: [[A:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK-NEXT: [[B:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK:      OpLabel
; CHECK:      [[C:%.+]] = OpSDiv [[SCALAR]] [[A]] [[B]]
; CHECK:      OpReturnValue [[C]]
; CHECK-NEXT: OpFunctionEnd


;; Test urem on scalar:
define i32 @scalar_urem(i32 %a, i32 %b) {
    %c = urem i32 %a, %b
    ret i32 %c
}

; CHECK:      [[SCALAR_UREM]] = OpFunction [[SCALAR]] None [[SCALAR_FN]]
; CHECK-NEXT: [[A:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK-NEXT: [[B:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK:      OpLabel
; CHECK:      [[C:%.+]] = OpUMod [[SCALAR]] [[A]] [[B]]
; CHECK:      OpReturnValue [[C]]
; CHECK-NEXT: OpFunctionEnd


;; Test srem on scalar:
define i32 @scalar_srem(i32 %a, i32 %b) {
    %c = srem i32 %a, %b
    ret i32 %c
}

; CHECK:      [[SCALAR_SREM]] = OpFunction [[SCALAR]] None [[SCALAR_FN]]
; CHECK-NEXT: [[A:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK-NEXT: [[B:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK:      OpLabel
; CHECK:      [[C:%.+]] = OpSRem [[SCALAR]] [[A]] [[B]]
; CHECK:      OpReturnValue [[C]]
; CHECK-NEXT: OpFunctionEnd


;; Test smod on scalar:
define spir_func i32 @scalar_smod(i32 %a, i32 %b) {
    %c = call spir_func i32 @_Z12__spirv_SModii(i32 %a, i32 %b)
    ret i32 %c
}

declare spir_func i32 @_Z12__spirv_SModii(i32, i32)

; CHECK:      [[SCALAR_SMOD]] = OpFunction [[SCALAR]] None [[SCALAR_FN]]
; CHECK-NEXT: [[A:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK-NEXT: [[B:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK:      OpLabel
; CHECK:      [[C:%.+]] = OpSMod [[SCALAR]] [[A]] [[B]]
; CHECK:      OpReturnValue [[C]]
; CHECK-NEXT: OpFunctionEnd


;; Test snegate on scalar:
define i32 @scalar_snegate(i32 %a) {
    %c = sub i32 0, %a
    ret i32 %c
}

; CHECK:      [[SCALAR_SNEGATE]] = OpFunction [[SCALAR]] None [[SCALAR_FN1]]
; CHECK-NEXT: [[A:%.+]] = OpFunctionParameter [[SCALAR]]
; CHECK:      OpLabel
; CHECK:      [[C:%.+]] = OpISub [[SCALAR]] [[ZERO]] [[A]]
; CHECK:      OpReturnValue [[C]]
; CHECK-NEXT: OpFunctionEnd