b2cdd80411
This patch upstreams CIRGen and LLVM lowering support for the `__builtin_assume_aligned` builtin function.
261 lines
8.2 KiB
C++
261 lines
8.2 KiB
C++
// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fclangir -emit-cir %s -o %t.cir
|
|
// RUN: FileCheck --input-file=%t.cir %s -check-prefix=CIR
|
|
// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fclangir -emit-llvm %s -o %t-cir.ll
|
|
// RUN: FileCheck --input-file=%t-cir.ll %s -check-prefix=LLVM
|
|
// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-linux-gnu -Wno-unused-value -emit-llvm %s -o %t.ll
|
|
// RUN: FileCheck --input-file=%t.ll %s -check-prefix=OGCG
|
|
|
|
constexpr extern int cx_var = __builtin_is_constant_evaluated();
|
|
|
|
// CIR: cir.global {{.*}} @cx_var = #cir.int<1> : !s32i
|
|
// LLVM: @cx_var = {{.*}} i32 1
|
|
// OGCG: @cx_var = {{.*}} i32 1
|
|
|
|
constexpr extern float cx_var_single = __builtin_huge_valf();
|
|
|
|
// CIR: cir.global {{.*}} @cx_var_single = #cir.fp<0x7F800000> : !cir.float
|
|
// LLVM: @cx_var_single = {{.*}} float 0x7FF0000000000000
|
|
// OGCG: @cx_var_single = {{.*}} float 0x7FF0000000000000
|
|
|
|
constexpr extern long double cx_var_ld = __builtin_huge_vall();
|
|
|
|
// CIR: cir.global {{.*}} @cx_var_ld = #cir.fp<0x7FFF8000000000000000> : !cir.long_double<!cir.f80>
|
|
// LLVM: @cx_var_ld = {{.*}} x86_fp80 0xK7FFF8000000000000000
|
|
// OGCG: @cx_var_ld = {{.*}} x86_fp80 0xK7FFF8000000000000000
|
|
|
|
int is_constant_evaluated() {
|
|
return __builtin_is_constant_evaluated();
|
|
}
|
|
|
|
// CIR: cir.func{{.*}} @_Z21is_constant_evaluatedv() -> !s32i
|
|
// CIR: %[[ZERO:.+]] = cir.const #cir.int<0>
|
|
|
|
// LLVM: define {{.*}}i32 @_Z21is_constant_evaluatedv()
|
|
// LLVM: %[[MEM:.+]] = alloca i32
|
|
// LLVM: store i32 0, ptr %[[MEM]]
|
|
// LLVM: %[[RETVAL:.+]] = load i32, ptr %[[MEM]]
|
|
// LLVM: ret i32 %[[RETVAL]]
|
|
// LLVM: }
|
|
|
|
// OGCG: define {{.*}}i32 @_Z21is_constant_evaluatedv()
|
|
// OGCG: ret i32 0
|
|
// OGCG: }
|
|
|
|
long double constant_fp_builtin_ld() {
|
|
return __builtin_fabsl(-0.1L);
|
|
}
|
|
|
|
// CIR: cir.func{{.*}} @_Z22constant_fp_builtin_ldv() -> !cir.long_double<!cir.f80>
|
|
// CIR: %[[PONE:.+]] = cir.const #cir.fp<1.000000e-01> : !cir.long_double<!cir.f80>
|
|
|
|
// LLVM: define {{.*}}x86_fp80 @_Z22constant_fp_builtin_ldv()
|
|
// LLVM: %[[MEM:.+]] = alloca x86_fp80
|
|
// LLVM: store x86_fp80 0xK3FFBCCCCCCCCCCCCCCCD, ptr %[[MEM]]
|
|
// LLVM: %[[RETVAL:.+]] = load x86_fp80, ptr %[[MEM]]
|
|
// LLVM: ret x86_fp80 %[[RETVAL]]
|
|
// LLVM: }
|
|
|
|
// OGCG: define {{.*}}x86_fp80 @_Z22constant_fp_builtin_ldv()
|
|
// OGCG: ret x86_fp80 0xK3FFBCCCCCCCCCCCCCCCD
|
|
// OGCG: }
|
|
|
|
float constant_fp_builtin_single() {
|
|
return __builtin_fabsf(-0.1f);
|
|
}
|
|
|
|
// CIR: cir.func{{.*}} @_Z26constant_fp_builtin_singlev() -> !cir.float
|
|
// CIR: %[[PONE:.+]] = cir.const #cir.fp<1.000000e-01> : !cir.float
|
|
|
|
// LLVM: define {{.*}}float @_Z26constant_fp_builtin_singlev()
|
|
// LLVM: %[[MEM:.+]] = alloca float
|
|
// LLVM: store float 0x3FB99999A0000000, ptr %[[MEM]]
|
|
// LLVM: %[[RETVAL:.+]] = load float, ptr %[[MEM]]
|
|
// LLVM: ret float %[[RETVAL]]
|
|
// LLVM: }
|
|
|
|
// OGCG: define {{.*}}float @_Z26constant_fp_builtin_singlev()
|
|
// OGCG: ret float 0x3FB99999A0000000
|
|
// OGCG: }
|
|
|
|
void library_builtins() {
|
|
__builtin_printf(nullptr);
|
|
__builtin_abort();
|
|
}
|
|
|
|
// CIR: cir.func{{.*}} @_Z16library_builtinsv() {
|
|
// CIR: %[[NULL:.+]] = cir.const #cir.ptr<null> : !cir.ptr<!s8i>
|
|
// CIR: cir.call @printf(%[[NULL]]) nothrow : (!cir.ptr<!s8i>) -> !s32i
|
|
// CIR: cir.call @abort() nothrow : () -> ()
|
|
|
|
// LLVM: define{{.*}} void @_Z16library_builtinsv()
|
|
// LLVM: call i32 (ptr, ...) @printf(ptr null)
|
|
// LLVM: call void @abort()
|
|
|
|
// OGCG: define{{.*}} void @_Z16library_builtinsv()
|
|
// OGCG: call i32 (ptr, ...) @printf(ptr noundef null)
|
|
// OGCG: call void @abort()
|
|
|
|
void assume(bool arg) {
|
|
__builtin_assume(arg);
|
|
}
|
|
|
|
// CIR: cir.func{{.*}} @_Z6assumeb
|
|
// CIR: cir.assume %{{.+}} : !cir.bool
|
|
// CIR: }
|
|
|
|
// LLVM: define {{.*}}void @_Z6assumeb
|
|
// LLVM: call void @llvm.assume(i1 %{{.+}})
|
|
// LLVM: }
|
|
|
|
// OGCG: define {{.*}}void @_Z6assumeb
|
|
// OGCG: call void @llvm.assume(i1 %{{.+}})
|
|
// OGCG: }
|
|
|
|
void *assume_aligned(void *ptr) {
|
|
return __builtin_assume_aligned(ptr, 16);
|
|
}
|
|
|
|
// CIR: @_Z14assume_alignedPv
|
|
// CIR: %{{.+}} = cir.assume_aligned %{{.+}} alignment 16 : !cir.ptr<!void>
|
|
// CIR: }
|
|
|
|
// LLVM: @_Z14assume_alignedPv
|
|
// LLVM: call void @llvm.assume(i1 true) [ "align"(ptr %{{.+}}, i64 16) ]
|
|
// LLVM: }
|
|
|
|
// OGCG: @_Z14assume_alignedPv
|
|
// OGCG: call void @llvm.assume(i1 true) [ "align"(ptr %{{.+}}, i64 16) ]
|
|
// OGCG: }
|
|
|
|
void *assume_aligned_misalignment(void *ptr, unsigned misalignment) {
|
|
return __builtin_assume_aligned(ptr, 16, misalignment);
|
|
}
|
|
|
|
// CIR: @_Z27assume_aligned_misalignmentPvj
|
|
// CIR: %{{.+}} = cir.assume_aligned %{{.+}} alignment 16[offset %{{.+}} : !u64i] : !cir.ptr<!void>
|
|
// CIR: }
|
|
|
|
// LLVM: @_Z27assume_aligned_misalignmentPvj
|
|
// LLVM: call void @llvm.assume(i1 true) [ "align"(ptr %{{.+}}, i64 16, i64 %{{.+}}) ]
|
|
// LLVM: }
|
|
|
|
// OGCG: @_Z27assume_aligned_misalignmentPvj
|
|
// OGCG: call void @llvm.assume(i1 true) [ "align"(ptr %{{.+}}, i64 16, i64 %{{.+}}) ]
|
|
// OGCG: }
|
|
|
|
void assume_separate_storage(void *p1, void *p2) {
|
|
__builtin_assume_separate_storage(p1, p2);
|
|
}
|
|
|
|
// CIR: cir.func{{.*}} @_Z23assume_separate_storagePvS_
|
|
// CIR: cir.assume_separate_storage %{{.+}}, %{{.+}} : !cir.ptr<!void>
|
|
// CIR: }
|
|
|
|
// LLVM: define {{.*}}void @_Z23assume_separate_storagePvS_
|
|
// LLVM: call void @llvm.assume(i1 true) [ "separate_storage"(ptr %{{.+}}, ptr %{{.+}}) ]
|
|
// LLVM: }
|
|
|
|
// OGCG: define {{.*}}void @_Z23assume_separate_storagePvS_
|
|
// OGCG: call void @llvm.assume(i1 true) [ "separate_storage"(ptr %{{.+}}, ptr %{{.+}}) ]
|
|
// OGCG: }
|
|
|
|
void expect(int x, int y) {
|
|
__builtin_expect(x, y);
|
|
}
|
|
|
|
// CIR-LABEL: cir.func{{.*}} @_Z6expectii
|
|
// CIR: %[[X:.+]] = cir.load align(4) %{{.+}} : !cir.ptr<!s32i>, !s32i
|
|
// CIR-NEXT: %[[X_LONG:.+]] = cir.cast(integral, %[[X]] : !s32i), !s64i
|
|
// CIR-NEXT: %[[Y:.+]] = cir.load align(4) %{{.+}} : !cir.ptr<!s32i>, !s32i
|
|
// CIR-NEXT: %[[Y_LONG:.+]] = cir.cast(integral, %[[Y]] : !s32i), !s64i
|
|
// CIR-NEXT: %{{.+}} = cir.expect(%[[X_LONG]], %[[Y_LONG]]) : !s64i
|
|
// CIR: }
|
|
|
|
// LLVM-LABEL: define{{.*}} void @_Z6expectii
|
|
// LLVM: %[[X:.+]] = load i32, ptr %{{.+}}, align 4
|
|
// LLVM-NEXT: %[[X_LONG:.+]] = sext i32 %[[X]] to i64
|
|
// LLVM-NEXT: %[[Y:.+]] = load i32, ptr %{{.+}}, align 4
|
|
// LLVM-NEXT: %[[Y_LONG:.+]] = sext i32 %[[Y]] to i64
|
|
// LLVM-NEXT: %{{.+}} = call i64 @llvm.expect.i64(i64 %[[X_LONG]], i64 %[[Y_LONG]])
|
|
// LLVM: }
|
|
|
|
void expect_prob(int x, int y) {
|
|
__builtin_expect_with_probability(x, y, 0.25);
|
|
}
|
|
|
|
// CIR-LABEL: cir.func{{.*}} @_Z11expect_probii
|
|
// CIR: %[[X:.+]] = cir.load align(4) %{{.+}} : !cir.ptr<!s32i>, !s32i
|
|
// CIR-NEXT: %[[X_LONG:.+]] = cir.cast(integral, %[[X]] : !s32i), !s64i
|
|
// CIR-NEXT: %[[Y:.+]] = cir.load align(4) %{{.+}} : !cir.ptr<!s32i>, !s32i
|
|
// CIR-NEXT: %[[Y_LONG:.+]] = cir.cast(integral, %[[Y]] : !s32i), !s64i
|
|
// CIR-NEXT: %{{.+}} = cir.expect(%[[X_LONG]], %[[Y_LONG]], 2.500000e-01) : !s64i
|
|
// CIR: }
|
|
|
|
// LLVM: define{{.*}} void @_Z11expect_probii
|
|
// LLVM: %[[X:.+]] = load i32, ptr %{{.+}}, align 4
|
|
// LLVM-NEXT: %[[X_LONG:.+]] = sext i32 %[[X]] to i64
|
|
// LLVM-NEXT: %[[Y:.+]] = load i32, ptr %{{.+}}, align 4
|
|
// LLVM-NEXT: %[[Y_LONG:.+]] = sext i32 %[[Y]] to i64
|
|
// LLVM-NEXT: %{{.+}} = call i64 @llvm.expect.with.probability.i64(i64 %[[X_LONG]], i64 %[[Y_LONG]], double 2.500000e-01)
|
|
// LLVM: }
|
|
|
|
void unreachable() {
|
|
__builtin_unreachable();
|
|
}
|
|
|
|
// CIR-LABEL: @_Z11unreachablev
|
|
// CIR: cir.unreachable
|
|
// CIR: }
|
|
|
|
// LLVM-LABEL: @_Z11unreachablev
|
|
// LLVM: unreachable
|
|
// LLVM: }
|
|
|
|
void f1();
|
|
void unreachable2() {
|
|
__builtin_unreachable();
|
|
f1();
|
|
}
|
|
|
|
// CIR-LABEL: @_Z12unreachable2v
|
|
// CIR: cir.unreachable
|
|
// CIR-NEXT: ^{{.+}}:
|
|
// CIR-NEXT: cir.call @_Z2f1v() : () -> ()
|
|
// CIR: }
|
|
|
|
// LLVM-LABEL: @_Z12unreachable2v
|
|
// LLVM: unreachable
|
|
// LLVM: {{.+}}:
|
|
// LLVM-NEXT: call void @_Z2f1v()
|
|
// LLVM: }
|
|
|
|
void trap() {
|
|
__builtin_trap();
|
|
}
|
|
|
|
// CIR-LABEL: @_Z4trapv
|
|
// CIR: cir.trap
|
|
// CIR: }
|
|
|
|
// LLVM-LABEL: @_Z4trapv
|
|
// LLVM: call void @llvm.trap()
|
|
// LLVM: }
|
|
|
|
void trap2() {
|
|
__builtin_trap();
|
|
f1();
|
|
}
|
|
|
|
// CIR-LABEL: @_Z5trap2v
|
|
// CIR: cir.trap
|
|
// CIR-NEXT: ^{{.+}}:
|
|
// CIR-NEXT: cir.call @_Z2f1v() : () -> ()
|
|
// CIR: }
|
|
|
|
// LLVM-LABEL: @_Z5trap2v
|
|
// LLVM: call void @llvm.trap()
|
|
// LLVM-NEXT: unreachable
|
|
// LLVM: {{.+}}:
|
|
// LLVM-NEXT: call void @_Z2f1v()
|
|
// LLVM: }
|