blob: 83d0d36e5776a707d95068c7b69844b5defa7d86 [file] [edit]
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -ffixed-point -fclangir -emit-cir %s -o %t.cir
// RUN: FileCheck --input-file=%t.cir %s --check-prefix=CIR
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -ffixed-point -fclangir -emit-llvm %s -o %t-cir.ll
// RUN: FileCheck --input-file=%t-cir.ll %s --check-prefix=LLVM
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -ffixed-point -emit-llvm %s -o %t.ll
// RUN: FileCheck --input-file=%t.ll %s --check-prefix=LLVM,OGCG
extern "C" {
// CIR-LABEL: cir.func {{.*}}@add(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
// CIR-NEXT: %[[RESULT:.*]] = cir.add %[[LOAD_A]], %[[WIDEN_F]] : !s32i
// CIR-NEXT: cir.store %[[RESULT]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @add(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[EXT_F:.*]] = sext i16 %[[LOAD_F]] to i32
// LLVM-NEXT: %[[ADD:.*]] = add i32 %[[LOAD_A]], %[[EXT_F]]
_Accum add(_Accum a, _Fract f) {
return a + f;
}
// CIR-LABEL: cir.func {{.*}}@add2(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_A:.*]] = cir.cast integral %[[LOAD_A]] : !s32i -> !cir.int<s, 47>
// CIR-NEXT: %[[SHIFT_VAL:.*]] = cir.const #cir.int<15> : !cir.int<s, 47>
// CIR-NEXT: %[[SHIFT_A:.*]] = cir.shift(left, %[[WIDEN_A]] : !cir.int<s, 47>, %[[SHIFT_VAL]] : !cir.int<s, 47>) -> !cir.int<s, 47>
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !cir.int<s, 47>
// CIR-NEXT: %[[ADD_A_F:.*]] = cir.add %[[SHIFT_A]], %[[WIDEN_F]] : !cir.int<s, 47>
// CIR-NEXT: %[[TRUNC_RES:.*]] = cir.cast integral %[[ADD_A_F]] : !cir.int<s, 47> -> !s16i
// CIR-NEXT: %[[WIDEN_RES:.*]] = cir.cast integral %[[TRUNC_RES]] : !s16i -> !s32i
// CIR-NEXT: cir.store %[[WIDEN_RES]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @add2(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[EXT_A:.*]] = sext i32 %[[LOAD_A]] to i47
// LLVM-NEXT: %[[SHIFT_A:.*]] = shl i47 %[[EXT_A]], 15
// LLVM-NEXT: %[[EXT_F:.*]] = sext i16 %[[LOAD_F]] to i47
// LLVM-NEXT: %[[ADD:.*]] = add i47 %[[SHIFT_A]], %[[EXT_F]]
// LLVM-NEXT: %[[TRUNC:.*]] = trunc i47 %[[ADD]] to i16
// LLVM-NEXT: %[[EXT:.*]] = sext i16 %[[TRUNC]] to i32
_Accum add2(int a, _Fract f) {
return a + f;
}
// CIR-LABEL: cir.func {{.*}}@sub(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
// CIR-NEXT: %[[DIFF:.*]] = cir.sub %[[LOAD_A]], %[[WIDEN_F]] : !s32i
// CIR-NEXT: cir.store %[[DIFF]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @sub(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[EXT_F:.*]] = sext i16 %[[LOAD_F]] to i32
// LLVM-NEXT: %[[SUB:.*]] = sub i32 %[[LOAD_A]], %[[EXT_F]]
_Accum sub(_Accum a, _Fract f) {
return a - f;
}
// CIR-LABEL: cir.func {{.*}}@sub2(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
// CIR-NEXT: %[[WIDEN_A47:.*]] = cir.cast integral %[[LOAD_A]] : !s32i -> !cir.int<s, 47>
// CIR-NEXT: %[[WIDEN_F47:.*]] = cir.cast integral %[[WIDEN_F]] : !s32i -> !cir.int<s, 47>
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !cir.int<s, 47>
// CIR-NEXT: %[[SHIFT_F:.*]] = cir.shift(left, %[[WIDEN_F47]] : !cir.int<s, 47>, %[[SHIFT_NUM]] : !cir.int<s, 47>) -> !cir.int<s, 47>
// CIR-NEXT: %[[DIFF:.*]] = cir.sub %[[WIDEN_A47]], %[[SHIFT_F]] : !cir.int<s, 47>
// CIR-NEXT: %[[TRUNC_DIFF:.*]] = cir.cast integral %[[DIFF]] : !cir.int<s, 47> -> !s32i
// CIR-NEXT: cir.store %[[TRUNC_DIFF]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @sub2(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[EXT_F32:.*]] = sext i16 %[[LOAD_F]] to i32
// LLVM-NEXT: %[[EXT_A:.*]] = sext i32 %[[LOAD_A]] to i47
// LLVM-NEXT: %[[EXT_F:.*]] = sext i32 %[[EXT_F32]] to i47
// LLVM-NEXT: %[[SHIFT:.*]] = shl i47 %[[EXT_F]], 15
// LLVM-NEXT: %[[SUB:.*]] = sub i47 %[[EXT_A]], %[[SHIFT]]
// LLVM-NEXT: %[[TRUNC:.*]] = trunc i47 %[[SUB]] to i32
_Accum sub2(_Accum a, short f) {
return a - f;
}
// CIR-LABEL: cir.func {{.*}}@mul(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
// CIR-NEXT: %[[SCALE:.*]] = cir.const #cir.int<15> : !s32i
// CIR-NEXT: %[[RES:.*]] = cir.call_llvm_intrinsic "smul.fix" %[[LOAD_A]], %[[WIDEN_F]], %[[SCALE]] : (!s32i, !s32i, !s32i) -> !s32i
// CIR-NEXT: cir.store %[[RES]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @mul(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[EXT_F:.*]] = sext i16 %[[LOAD_F]] to i32
// LLVM-NEXT: %[[MUL:.*]] = call i32 @llvm.smul.fix.i32(i32 %[[LOAD_A]], i32 %[[EXT_F]], i32 15)
_Accum mul(_Accum a, _Fract f) {
return a * f;
}
// CIR-LABEL: cir.func {{.*}}@mul2(
// CIR-NEXT: %[[S:.*]] = cir.alloca "s" align(2) init : !cir.ptr<!u16i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_S:.*]] = cir.load align(2) %[[S]] : !cir.ptr<!u16i>, !u16i
// CIR-NEXT: %[[WIDEN_S:.*]] = cir.cast integral %[[LOAD_S]] : !u16i -> !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_S47:.*]] = cir.cast integral %[[WIDEN_S]] : !s32i -> !cir.int<s, 47>
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !cir.int<s, 47>
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[WIDEN_S47]] : !cir.int<s, 47>, %[[SHIFT_NUM]] : !cir.int<s, 47>) -> !cir.int<s, 47>
// CIR-NEXT: %[[WIDEN_F47:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !cir.int<s, 47>
// CIR-NEXT: %[[SCALE:.*]] = cir.const #cir.int<15> : !s32i
// CIR-NEXT: %[[RES:.*]] = cir.call_llvm_intrinsic "smul.fix" %[[SHIFT]], %[[WIDEN_F47]], %[[SCALE]] : (!cir.int<s, 47>, !cir.int<s, 47>, !s32i) -> !cir.int<s, 47>
// CIR-NEXT: %[[TRUNC_RES:.*]] = cir.cast integral %[[RES]] : !cir.int<s, 47> -> !s16i
// CIR-NEXT: %[[WIDEN_RES:.*]] = cir.cast integral %[[TRUNC_RES]] : !s16i -> !s32i
// CIR-NEXT: cir.store %[[WIDEN_RES]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @mul2(i16
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[S:.*]] = alloca i16, align 2
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_S:.*]] = load i16, ptr %[[S]], align 2
// LLVM-NEXT: %[[EXT_S:.*]] = zext i16 %[[LOAD_S]] to i32
// LLVM-NEXT: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[EXT_S2:.*]] = sext i32 %[[EXT_S]] to i47
// LLVM-NEXT: %[[SHIFT_S:.*]] = shl i47 %[[EXT_S2]], 15
// LLVM-NEXT: %[[EXT_F:.*]] = sext i16 %[[LOAD_F]] to i47
// LLVM-NEXT: %[[MUL:.*]] = call i47 @llvm.smul.fix.i47(i47 %[[SHIFT_S]], i47 %[[EXT_F]], i32 15)
// LLVM-NEXT: %[[TRUNC_RES:.*]] = trunc i47 %[[MUL]] to i16
// LLVM-NEXT: %[[EXT_RES:.*]] = sext i16 %[[TRUNC_RES]] to i32
_Accum mul2(unsigned short s, _Fract f) {
return s * f;
}
// CIR-LABEL: cir.func {{.*}}@div(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
// CIR-NEXT: %[[SCALE:.*]] = cir.const #cir.int<15> : !s32i
// CIR-NEXT: %[[DIV:.*]] = cir.call_llvm_intrinsic "sdiv.fix" %[[LOAD_A]], %[[WIDEN_F]], %[[SCALE]] : (!s32i, !s32i, !s32i) -> !s32i
// CIR-NEXT: cir.store %[[DIV]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @div(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[EXT_F:.*]] = sext i16 %[[LOAD_F]] to i32
// LLVM-NEXT: %[[DIV:.*]] = call i32 @llvm.sdiv.fix.i32(i32 %[[LOAD_A]], i32 %[[EXT_F]], i32 15)
_Accum div(_Accum a, _Fract f) {
return a / f;
}
// CIR-LABEL: cir.func {{.*}}@div2(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(4) init : !cir.ptr<!cir.float>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[FLOAT_A:.*]] = cir.cast int_to_float %[[LOAD_A]] : !s32i -> !cir.float
// CIR-NEXT: %[[SCALE:.*]] = cir.const #cir.fp<3.05175781E-5> : !cir.float
// CIR-NEXT: %[[SCALE_A:.*]] = cir.fmul %[[FLOAT_A]], %[[SCALE]] : !cir.float
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(4) %[[F]] : !cir.ptr<!cir.float>, !cir.float
// CIR-NEXT: %[[DIV:.*]] = cir.fdiv %[[SCALE_A]], %[[LOAD_F]] : !cir.float
// CIR-NEXT: %[[SCALE:.*]] = cir.const #cir.fp<3.276800e+04> : !cir.float
// CIR-NEXT: %[[RES:.*]] = cir.fmul %[[DIV]], %[[SCALE]] : !cir.float
// CIR-NEXT: %[[RES_TO_INT:.*]] = cir.cast float_to_int %[[RES]] : !cir.float -> !s32i
// CIR-NEXT: cir.store %[[RES_TO_INT]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @div2(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca float, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[A_TO_FLOAT:.*]] = sitofp i32 %[[LOAD_A]] to float
// LLVM-NEXT: %[[SCALE_A:.*]] = fmul float %[[A_TO_FLOAT]], f0x38000000
// LLVM-NEXT: %[[LOAD_F:.*]] = load float, ptr %[[F]], align 4
// LLVM-NEXT: %[[DIV:.*]] = fdiv float %[[SCALE_A]], %[[LOAD_F]]
// LLVM-NEXT: %[[SCALE_RES:.*]] = fmul float %[[DIV]], 3.276800e+04
// LLVM-NEXT: %[[RES_TO_INT:.*]] = fptosi float %[[SCALE_RES]] to i32
_Accum div2(_Accum a, float f) {
return a / f;
}
// CIR-LABEL: cir.func {{.*}}@umul(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!u32i>
// CIR-NEXT: %[[B:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!u32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!u32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!u32i>, !u32i
// CIR-NEXT: %[[LOAD_B:.*]] = cir.load align(4) %[[B]] : !cir.ptr<!u32i>, !u32i
// CIR-NEXT: %[[SCALE:.*]] = cir.const #cir.int<16> : !u32i
// CIR-NEXT: %[[MUL:.*]] = cir.call_llvm_intrinsic "umul.fix" %[[LOAD_A]], %[[LOAD_B]], %[[SCALE]] : (!u32i, !u32i, !u32i) -> !u32i
// CIR-NEXT: cir.store %[[MUL]], %[[RET]] : !u32i, !cir.ptr<!u32i>
// LLVM-LABEL: define {{.*}}i32 @umul(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[B:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_B:.*]] = load i32, ptr %[[B]], align 4
// LLVM-NEXT: %[[MUL:.*]] = call i32 @llvm.umul.fix.i32(i32 %[[LOAD_A]], i32 %[[LOAD_B]], i32 16)
unsigned _Accum umul(unsigned _Accum a, unsigned _Accum b) {
return a * b;
}
// CIR-LABEL: cir.func {{.*}}@cmp(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(1) : !cir.ptr<!cir.bool>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
// CIR-NEXT: %[[LT:.*]] = cir.cmp lt %[[LOAD_A]], %[[WIDEN_F]] : !s32i
// CIR-NEXT: cir.store %[[LT]], %[[RET]] : !cir.bool, !cir.ptr<!cir.bool>
// LLVM-LABEL: define {{.*}}i1 @cmp(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[EXT_F:.*]] = sext i16 %[[LOAD_F]] to i32
// LLVM-NEXT: %[[CMP:.*]] = icmp slt i32 %[[LOAD_A]], %[[EXT_F]]
bool cmp(_Accum a, _Fract f) {
return a < f;
}
// CIR-LABEL: cir.func {{.*}}@cmp2(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(1) : !cir.ptr<!cir.bool>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
// CIR-NEXT: %[[GT:.*]] = cir.cmp gt %[[LOAD_A]], %[[WIDEN_F]] : !s32i
// CIR-NEXT: cir.store %[[GT]], %[[RET]] : !cir.bool, !cir.ptr<!cir.bool>
// LLVM-LABEL: define {{.*}}i1 @cmp2(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[EXT_F:.*]] = sext i16 %[[LOAD_F]] to i32
// LLVM-NEXT: %[[CMP:.*]] = icmp sgt i32 %[[LOAD_A]], %[[EXT_F]]
bool cmp2(_Accum a, _Fract f) {
return a > f;
}
// CIR-LABEL: cir.func {{.*}}@cmp3(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(1) : !cir.ptr<!cir.bool>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[WIDEN_F:.*]] = cir.cast integral %[[LOAD_F]] : !s16i -> !s32i
// CIR-NEXT: %[[EQ:.*]] = cir.cmp eq %[[LOAD_A]], %[[WIDEN_F]] : !s32i
// CIR-NEXT: cir.store %[[EQ]], %[[RET]] : !cir.bool, !cir.ptr<!cir.bool>
// LLVM-LABEL: define {{.*}}i1 @cmp3(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[EXT_F:.*]] = sext i16 %[[LOAD_F]] to i32
// LLVM-NEXT: %[[CMP:.*]] = icmp eq i32 %[[LOAD_A]], %[[EXT_F]]
bool cmp3(_Accum a, _Fract f) {
return a == f;
}
// CIR-LABEL: cir.func {{.*}}@shl(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<2> : !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[LOAD_A]] : !s32i, %[[SHIFT_NUM]] : !s32i) -> !s32i
// CIR-NEXT: cir.store %[[SHIFT]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @shl(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[SHIFT:.*]] = shl i32 %[[LOAD_A]], 2
_Accum shl(_Accum a) {
return a << 2;
}
// CIR-LABEL: cir.func {{.*}}@shl2(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[C:.*]] = cir.alloca "c" align(1) init : !cir.ptr<!u8i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_C:.*]] = cir.load align(1) %[[C]] : !cir.ptr<!u8i>, !u8i
// CIR-NEXT: %[[WIDEN_C:.*]] = cir.cast integral %[[LOAD_C]] : !u8i -> !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[LOAD_A]] : !s32i, %[[WIDEN_C]] : !s32i) -> !s32i
// CIR-NEXT: cir.store %[[SHIFT]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @shl2(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[C:.*]] = alloca i8, align 1
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_C:.*]] = load i8, ptr %[[C]], align 1
// LLVM-NEXT: %[[C_EXT:.*]] = zext i8 %[[LOAD_C]] to i32
// LLVM-NEXT: %[[SHIFT:.*]] = shl i32 %[[LOAD_A]], %[[C_EXT]]
_Accum shl2(_Accum a, unsigned char c) {
return a << c;
}
// CIR-LABEL: cir.func {{.*}}@shl3(
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[C:.*]] = cir.alloca "c" align(1) init : !cir.ptr<!u8i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[LOAD_C:.*]] = cir.load align(1) %[[C]] : !cir.ptr<!u8i>, !u8i
// CIR-NEXT: %[[WIDEN_C:.*]] = cir.cast integral %[[LOAD_C]] : !u8i -> !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[LOAD_F]] : !s16i, %[[WIDEN_C]] : !s32i) -> !s16i
// CIR-NEXT: cir.store %[[SHIFT]], %[[RET]] : !s16i, !cir.ptr<!s16i>
// LLVM-LABEL: define {{.*}}i16 @shl3(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM-NEXT: %[[C:.*]] = alloca i8, align 1
// LLVM: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[LOAD_C:.*]] = load i8, ptr %[[C]], align 1
// LLVM-NEXT: %[[EXT_C:.*]] = zext i8 %[[LOAD_C]] to i32
// LLVM-NEXT: %[[TRUNC_C:.*]] = trunc i32 %[[EXT_C]] to i16
// LLVM-NEXT: %[[SHIFT:.*]] = shl i16 %[[LOAD_F]], %[[TRUNC_C]]
_Fract shl3(_Fract f, unsigned char c) {
return f << c;
}
// CIR-LABEL: cir.func {{.*}}@shr(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<2> : !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(right, %[[LOAD_A]] : !s32i, %[[SHIFT_NUM]] : !s32i) -> !s32i
// CIR-NEXT: cir.store %[[SHIFT]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @shr(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[SHIFT:.*]] = ashr i32 %[[LOAD_A]], 2
_Accum shr(_Accum a) {
return a >> 2;
}
// CIR-LABEL: cir.func {{.*}}@shr2(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(4) init : !cir.ptr<!u32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_U:.*]] = cir.load align(4) %[[U]] : !cir.ptr<!u32i>, !u32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(right, %[[LOAD_A]] : !s32i, %[[LOAD_U]] : !u32i) -> !s32i
// CIR-NEXT: cir.store %[[SHIFT]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @shr2(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[U:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_U:.*]] = load i32, ptr %[[U]], align 4
// LLVM-NEXT: %[[SHIFT:.*]] = ashr i32 %[[LOAD_A]], %[[LOAD_U]]
_Accum shr2(_Accum a, unsigned u) {
return a >> u;
}
// CIR-LABEL: cir.func {{.*}}@shr3(
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[U:.*]] = cir.alloca "u" align(4) init : !cir.ptr<!u32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[LOAD_U:.*]] = cir.load align(4) %[[U]] : !cir.ptr<!u32i>, !u32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(right, %[[LOAD_F]] : !s16i, %[[LOAD_U]] : !u32i) -> !s16i
// CIR-NEXT: cir.store %[[SHIFT]], %[[RET]] : !s16i, !cir.ptr<!s16i>
// LLVM-LABEL: define {{.*}}i16 @shr3(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM-NEXT: %[[U:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[LOAD_U:.*]] = load i32, ptr %[[U]], align 4
// LLVM-NEXT: %[[TRUNC_U:.*]] = trunc i32 %[[LOAD_U]] to i16
// LLVM-NEXT: %[[SHIFT:.*]] = ashr i16 %[[LOAD_F]], %[[TRUNC_U]]
_Fract shr3(_Fract f, unsigned u) {
return f >> u;
}
// CIR-LABEL: cir.func {{.*}}@inc(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[NEG_1]] : !s32i, %[[SHIFT_NUM]] : !s32i) -> !s32i
// CIR-NEXT: %[[SUB:.*]] = cir.sub %[[LOAD_A]], %[[SHIFT]] : !s32i
// CIR-NEXT: cir.store align(4) %[[SUB:.*]], %[[A]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: cir.store %[[SUB]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @inc(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[INC:.*]] = sub i32 %[[LOAD_A]], -32768
_Accum inc(_Accum a) {
return ++a;
}
// CIR-LABEL: cir.func {{.*}}@inc2(
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !s16i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !s16i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[NEG_1:.*]] : !s16i, %[[SHIFT_NUM]] : !s16i) -> !s16i
// CIR-NEXT: %[[SUB:.*]] = cir.sub %[[LOAD_F]], %[[SHIFT]] : !s16i
// CIR-NEXT: cir.store align(2) %[[SUB]], %[[F]] : !s16i, !cir.ptr<!s16i>
// CIR-NEXT: cir.store %[[LOAD_F]], %[[RET]] : !s16i, !cir.ptr<!s16i>
// LLVM-LABEL: define {{.*}}i16 @inc2(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i16, ptr %[[A]], align 2
// LLVM-NEXT: %[[INC:.*]] = sub i16 %[[LOAD_A]], -32768
_Fract inc2(_Fract f) {
return f++;
}
// CIR-LABEL: cir.func {{.*}}@dec(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[NEG_1]] : !s32i, %[[SHIFT_NUM]] : !s32i) -> !s32i
// CIR-NEXT: %[[ADD:.*]] = cir.add %[[LOAD_A]], %[[SHIFT]] : !s32i
// CIR-NEXT: cir.store align(4) %[[ADD]], %[[A]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: cir.store %[[ADD]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @dec(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[DEC:.*]] = add i32 %[[LOAD_A]], -32768
_Accum dec(_Accum a) {
return --a;
}
// CIR-LABEL: cir.func {{.*}}@dec2(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR: %[[LOAD_A:.*]] = cir.load align(2) %[[A]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !s16i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !s16i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[NEG_1]] : !s16i, %[[SHIFT_NUM]] : !s16i) -> !s16i
// CIR-NEXT: %[[SUB:.*]] = cir.add %[[LOAD_A]], %[[SHIFT]] : !s16i
// CIR-NEXT: cir.store align(2) %[[SUB]], %[[A]] : !s16i, !cir.ptr<!s16i>
// CIR-NEXT: cir.store %[[LOAD_A:.*]], %[[RET]] : !s16i, !cir.ptr<!s16i>
// LLVM-LABEL: define {{.*}}i16 @dec2(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i16, ptr %[[A]], align 2
// LLVM-NEXT: %[[DEC:.*]] = add i16 %[[LOAD_A]], -32768
_Fract dec2(_Fract a) {
return a--;
}
// CIR-LABEL: cir.func {{.*}}@satAdd(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[B:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_B:.*]] = cir.load align(4) %[[B]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[ADD:.*]] = cir.add sat %[[LOAD_A]], %[[LOAD_B]] : !s32i
// CIR-NEXT: cir.store %[[ADD]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @satAdd(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[B:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_B:.*]] = load i32, ptr %[[B]], align 4
// LLVM-NEXT: %[[SUB:.*]] = call i32 @llvm.sadd.sat.i32(i32 %[[LOAD_A]], i32 %[[LOAD_B]])
_Sat _Accum satAdd(_Sat _Accum a, _Accum b) {
return a + b;
}
// CIR-LABEL: cir.func {{.*}}@satSub(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[B:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_B:.*]] = cir.load align(4) %[[B]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SUB:.*]] = cir.sub sat %[[LOAD_A]], %[[LOAD_B]] : !s32i
// CIR-NEXT: cir.store %[[SUB]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @satSub(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[B:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_B:.*]] = load i32, ptr %[[B]], align 4
// LLVM-NEXT: %[[SUB:.*]] = call i32 @llvm.ssub.sat.i32(i32 %[[LOAD_A]], i32 %[[LOAD_B]])
_Sat _Accum satSub(_Sat _Accum a, _Sat _Accum b) {
return a - b;
}
// CIR-LABEL: cir.func {{.*}}@satMul(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[B:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_B:.*]] = cir.load align(4) %[[B]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SCALE:.*]] = cir.const #cir.int<15> : !s32i
// CIR-NEXT: %[[MUL:.*]] = cir.call_llvm_intrinsic "smul.fix.sat" %[[LOAD_A]], %[[LOAD_B]], %[[SCALE]] : (!s32i, !s32i, !s32i) -> !s32i
// CIR-NEXT: cir.store %[[MUL]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @satMul(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[B:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_B:.*]] = load i32, ptr %[[B]], align 4
// LLVM-NEXT: %[[SHIFT:.*]] = call i32 @llvm.smul.fix.sat.i32(i32 %[[LOAD_A]], i32 %[[LOAD_B]], i32 15)
_Sat _Accum satMul(_Sat _Accum a, _Sat _Accum b) {
return a * b;
}
// CIR-LABEL: cir.func {{.*}}@satDiv(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[B:.*]] = cir.alloca "b" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[LOAD_B:.*]] = cir.load align(4) %[[B]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SCALE:.*]] = cir.const #cir.int<15> : !s32i
// CIR-NEXT: %[[DIV:.*]] = cir.call_llvm_intrinsic "sdiv.fix.sat" %[[LOAD_A]], %[[LOAD_B]], %[[SCALE]] : (!s32i, !s32i, !s32i) -> !s32i
// CIR-NEXT: cir.store %[[DIV]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @satDiv(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM-NEXT: %[[B:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[LOAD_B:.*]] = load i32, ptr %[[B]], align 4
// LLVM-NEXT: %[[SHIFT:.*]] = call i32 @llvm.sdiv.fix.sat.i32(i32 %[[LOAD_A]], i32 %[[LOAD_B]], i32 15)
_Sat _Accum satDiv(_Sat _Accum a, _Sat _Accum b) {
return a / b;
}
// CIR-LABEL: cir.func {{.*}}@satShl(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<2> : !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.call_llvm_intrinsic "sshl.sat" %[[LOAD_A]], %[[SHIFT_NUM]] : (!s32i, !s32i) -> !s32i
// CIR-NEXT: cir.store %[[SHIFT]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @satShl(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[SHIFT:.*]] = call i32 @llvm.sshl.sat.i32(i32 %[[LOAD_A]], i32 2)
_Sat _Accum satShl(_Sat _Accum a) {
return a << 2;
}
// CIR-LABEL: cir.func {{.*}}@satShl2(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[C:.*]] = cir.alloca "c" align(1) init : !cir.ptr<!s8i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR: %[[LOAD_A:.*]] = cir.load align(2) %[[A]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[LOAD_C:.*]] = cir.load align(1) %[[C]] : !cir.ptr<!s8i>, !s8i
// CIR-NEXT: %[[WIDEN_C:.*]] = cir.cast integral %[[LOAD_C]] : !s8i -> !s32i
// CIR-NEXT: %[[UNSIGNED_C:.*]] = cir.cast integral %[[WIDEN_C]] : !s32i -> !u32i
// CIR-NEXT: %[[TRUNC_C:.*]] = cir.cast integral %[[UNSIGNED_C]] : !u32i -> !s16i
// CIR-NEXT: %[[SHIFT:.*]] = cir.call_llvm_intrinsic "sshl.sat" %[[LOAD_A]], %[[TRUNC_C]] : (!s16i, !s16i) -> !s16i
// CIR-NEXT: cir.store %[[SHIFT]], %[[RET]] : !s16i, !cir.ptr<!s16i>
// LLVM-LABEL: define {{.*}}i16 @satShl2(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM-NEXT: %[[C:.*]] = alloca i8, align 1
// LLVM: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[LOAD_C:.*]] = load i8, ptr %[[C]], align 1
// LLVM-NEXT: %[[EXT_C:.*]] = sext i8 %[[LOAD_C]] to i32
// LLVM-NEXT: %[[TRUNC_C:.*]] = trunc i32 %[[EXT_C]] to i16
// LLVM-NEXT: %[[SHIFT:.*]] = call i16 @llvm.sshl.sat.i16(i16 %[[LOAD_F]], i16 %[[TRUNC_C]])
_Sat _Fract satShl2(_Sat _Fract a, char c) {
return a << c;
}
// CIR-LABEL: cir.func {{.*}}@satShr(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<2> : !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(right, %[[LOAD_A]] : !s32i, %[[SHIFT_NUM]] : !s32i) -> !s32i
// CIR-NEXT: cir.store %[[SHIFT]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @satShr(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[SHIFT:.*]] = ashr i32 %[[LOAD_A]], 2
_Sat _Accum satShr(_Sat _Accum a) {
return a >> 2;
}
// CIR-LABEL: cir.func {{.*}}@satShr2(
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[I:.*]] = cir.alloca "i" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[LOAD_I:.*]] = cir.load align(4) %[[I]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(right, %[[LOAD_F]] : !s16i, %[[LOAD_I]] : !s32i) -> !s16i
// CIR-NEXT: cir.store %[[SHIFT]], %[[RET]] : !s16i, !cir.ptr<!s16i>
// LLVM-LABEL: define {{.*}}i16 @satShr2(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM-NEXT: %[[I:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[LOAD_I:.*]] = load i32, ptr %[[I]], align 4
// LLVM-NEXT: %[[TRUNC:.*]] = trunc i32 %[[LOAD_I]] to i16
// LLVM-NEXT: %[[SHIFT:.*]] = ashr i16 %[[LOAD_F]], %[[TRUNC]]
_Sat _Fract satShr2(_Sat _Fract f, int i) {
return f >> i;
}
// CIR-LABEL: cir.func {{.*}}@satInc(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(4) init : !cir.ptr<!s32i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(4) : !cir.ptr<!s32i>
// CIR: %[[LOAD_A:.*]] = cir.load align(4) %[[A]] : !cir.ptr<!s32i>, !s32i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !cir.int<s, 47>
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !cir.int<s, 47>
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[NEG_1]] : !cir.int<s, 47>, %[[SHIFT_NUM]] : !cir.int<s, 47>) -> !cir.int<s, 47>
// CIR-NEXT: %[[MAX:.*]] = cir.const #cir.int<2147483647> : !cir.int<s, 47>
// CIR-NEXT: %[[CMP:.*]] = cir.cmp gt %[[SHIFT]], %[[MAX]] : !cir.int<s, 47>
// CIR-NEXT: %[[SELECT:.*]] = cir.select if %[[CMP]] then %[[MAX]] else %[[SHIFT]] : (!cir.bool, !cir.int<s, 47>, !cir.int<s, 47>) -> !cir.int<s, 47>
// CIR-NEXT: %[[MIN:.*]] = cir.const #cir.int<-2147483648> : !cir.int<s, 47>
// CIR-NEXT: %[[CMP:.*]] = cir.cmp lt %[[SELECT]], %[[MIN]] : !cir.int<s, 47>
// CIR-NEXT: %[[SELECT2:.*]] = cir.select if %[[CMP]] then %[[MIN]] else %[[SELECT]] : (!cir.bool, !cir.int<s, 47>, !cir.int<s, 47>) -> !cir.int<s, 47>
// CIR-NEXT: %[[TRUNC:.*]] = cir.cast integral %[[SELECT2]] : !cir.int<s, 47> -> !s32i
// CIR-NEXT: %[[SUB:.*]] = cir.sub sat %[[LOAD_A]], %[[TRUNC]] : !s32i
// CIR-NEXT: cir.store align(4) %[[SUB]], %[[A]] : !s32i, !cir.ptr<!s32i>
// CIR-NEXT: cir.store %[[SUB]], %[[RET]] : !s32i, !cir.ptr<!s32i>
// LLVM-LABEL: define {{.*}}i32 @satInc(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i32, align 4
// LLVM: %[[LOAD_A:.*]] = load i32, ptr %[[A]], align 4
// LLVM-NEXT: %[[ADD:.*]] = call i32 @llvm.ssub.sat.i32(i32 %[[LOAD_A]], i32 -32768)
// LLVM-NEXT: store i32 %[[ADD]], ptr %[[A]], align 4
_Sat _Accum satInc(_Sat _Accum a) {
return ++a;
}
// CIR-LABEL: cir.func {{.*}}@satDec(
// CIR-NEXT: %[[F:.*]] = cir.alloca "f" align(2) init : !cir.ptr<!s16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!s16i>
// CIR: %[[LOAD_F:.*]] = cir.load align(2) %[[F]] : !cir.ptr<!s16i>, !s16i
// CIR-NEXT: %[[NEG_1:.*]] = cir.const #cir.int<-1> : !cir.int<s, 31>
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<15> : !cir.int<s, 31>
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[NEG_1]] : !cir.int<s, 31>, %[[SHIFT_NUM]] : !cir.int<s, 31>) -> !cir.int<s, 31>
// CIR-NEXT: %[[MAX:.*]] = cir.const #cir.int<32767> : !cir.int<s, 31>
// CIR-NEXT: %[[CMP:.*]] = cir.cmp gt %[[SHIFT]], %[[MAX]] : !cir.int<s, 31>
// CIR-NEXT: %[[SELECT:.*]] = cir.select if %[[CMP]] then %[[MAX]] else %[[SHIFT]] : (!cir.bool, !cir.int<s, 31>, !cir.int<s, 31>) -> !cir.int<s, 31>
// CIR-NEXT: %[[MIN:.*]] = cir.const #cir.int<-32768> : !cir.int<s, 31>
// CIR-NEXT: %[[CMP:.*]] = cir.cmp lt %[[SELECT]], %[[MIN]] : !cir.int<s, 31>
// CIR-NEXT: %[[SELECT2:.*]] = cir.select if %[[CMP]] then %[[MIN]] else %[[SELECT]] : (!cir.bool, !cir.int<s, 31>, !cir.int<s, 31>) -> !cir.int<s, 31>
// CIR-NEXT: %[[TRUNC:.*]] = cir.cast integral %[[SELECT2]] : !cir.int<s, 31> -> !s16i
// CIR-NEXT: %[[ADD:.*]] = cir.add sat %[[LOAD_F]], %[[TRUNC]] : !s16i
// CIR-NEXT: cir.store align(2) %[[ADD]], %[[F]] : !s16i, !cir.ptr<!s16i>
// CIR-NEXT: cir.store %[[LOAD_F]], %[[RET]] : !s16i, !cir.ptr<!s16i>
// LLVM-LABEL: define {{.*}}i16 @satDec(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[F:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_F:.*]] = load i16, ptr %[[F]], align 2
// LLVM-NEXT: %[[ADD:.*]] = call i16 @llvm.sadd.sat.i16(i16 %[[LOAD_F]], i16 -32768)
// LLVM-NEXT: store i16 %[[ADD]], ptr %[[F]], align 2
_Sat _Fract satDec(_Sat _Fract f) {
return f--;
}
// CIR-LABEL: cir.func {{.*}}@satIncUFract(
// CIR-NEXT: %[[A:.*]] = cir.alloca "a" align(2) init : !cir.ptr<!u16i>
// CIR-NEXT: %[[RET:.*]] = cir.alloca "__retval" align(2) : !cir.ptr<!u16i>
// CIR: %[[LOAD_A:.*]] = cir.load align(2) %[[A]] : !cir.ptr<!u16i>, !u16i
// CIR-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i
// CIR-NEXT: %[[SHIFT_NUM:.*]] = cir.const #cir.int<16> : !s32i
// CIR-NEXT: %[[SHIFT:.*]] = cir.shift(left, %[[ONE]] : !s32i, %[[SHIFT_NUM]] : !s32i) -> !s32i
// CIR-NEXT: %[[MAX:.*]] = cir.const #cir.int<65535> : !s32i
// CIR-NEXT: %[[CMP:.*]] = cir.cmp gt %[[SHIFT]], %[[MAX]] : !s32i
// CIR-NEXT: %[[SELECT:.*]] = cir.select if %[[CMP]] then %[[MAX]] else %[[SHIFT]] : (!cir.bool, !s32i, !s32i) -> !s32i
// CIR-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i
// CIR-NEXT: %[[CMP:.*]] = cir.cmp lt %[[SELECT]], %[[ZERO]] : !s32i
// CIR-NEXT: %[[SELECT2:.*]] = cir.select if %[[CMP]] then %[[ZERO]] else %[[SELECT]] : (!cir.bool, !s32i, !s32i) -> !s32i
// CIR-NEXT: %[[TRUNC:.*]] = cir.cast integral %[[SELECT2]] : !s32i -> !u16i
// CIR-NEXT: %[[ADD:.*]] = cir.add sat %[[LOAD_A]], %[[TRUNC]] : !u16i
// CIR-NEXT: cir.store align(2) %[[ADD]], %[[A]] : !u16i, !cir.ptr<!u16i>
// CIR-NEXT: cir.store %[[ADD]], %[[RET]] : !u16i, !cir.ptr<!u16i>
// LLVM-LABEL: define {{.*}}i16 @satIncUFract(
// OGCG-NEXT: entry:
// LLVM-NEXT: %[[A:.*]] = alloca i16, align 2
// LLVM: %[[LOAD_A:.*]] = load i16, ptr %[[A]], align 2
// LLVM-NEXT: %[[ADD:.*]] = call i16 @llvm.uadd.sat.i16(i16 %[[LOAD_A]], i16 -1)
// LLVM-NEXT: store i16 %[[ADD]], ptr %[[A]], align 2
_Sat unsigned _Fract satIncUFract(_Sat unsigned _Fract a) {
return ++a;
}
}