| // 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 |
| |
| void b0(int a, int b) { |
| int x = a * b; |
| x = x / b; |
| x = x % b; |
| x = x + b; |
| x = x - b; |
| x = x & b; |
| x = x ^ b; |
| x = x | b; |
| } |
| |
| // CIR-LABEL: cir.func{{.*}} @_Z2b0ii( |
| // CIR: %{{.+}} = cir.binop(mul, %{{.+}}, %{{.+}}) nsw : !s32i |
| // CIR: %{{.+}} = cir.binop(div, %{{.+}}, %{{.+}}) : !s32i |
| // CIR: %{{.+}} = cir.binop(rem, %{{.+}}, %{{.+}}) : !s32i |
| // CIR: %{{.+}} = cir.binop(add, %{{.+}}, %{{.+}}) nsw : !s32i |
| // CIR: %{{.+}} = cir.binop(sub, %{{.+}}, %{{.+}}) nsw : !s32i |
| // CIR: %{{.+}} = cir.binop(and, %{{.+}}, %{{.+}}) : !s32i |
| // CIR: %{{.+}} = cir.binop(xor, %{{.+}}, %{{.+}}) : !s32i |
| // CIR: %{{.+}} = cir.binop(or, %{{.+}}, %{{.+}}) : !s32i |
| // CIR: cir.return |
| |
| // LLVM-LABEL: define{{.*}} void @_Z2b0ii( |
| // LLVM-SAME: i32 %[[A:.*]], i32 %[[B:.*]]) |
| // LLVM: %[[A_ADDR:.*]] = alloca i32 |
| // LLVM: %[[B_ADDR:.*]] = alloca i32 |
| // LLVM: %[[X:.*]] = alloca i32 |
| // LLVM: store i32 %[[A]], ptr %[[A_ADDR]] |
| // LLVM: store i32 %[[B]], ptr %[[B_ADDR]] |
| |
| // LLVM: %[[A:.*]] = load i32, ptr %[[A_ADDR]] |
| // LLVM: %[[B:.*]] = load i32, ptr %[[B_ADDR]] |
| // LLVM: %[[MUL:.*]] = mul nsw i32 %[[A]], %[[B]] |
| // LLVM: store i32 %[[MUL]], ptr %[[X]] |
| |
| // LLVM: %[[X1:.*]] = load i32, ptr %[[X]] |
| // LLVM: %[[B1:.*]] = load i32, ptr %[[B_ADDR]] |
| // LLVM: %[[DIV:.*]] = sdiv i32 %[[X1]], %[[B1]] |
| // LLVM: store i32 %[[DIV]], ptr %[[X]] |
| |
| // LLVM: %[[X2:.*]] = load i32, ptr %[[X]] |
| // LLVM: %[[B2:.*]] = load i32, ptr %[[B_ADDR]] |
| // LLVM: %[[REM:.*]] = srem i32 %[[X2]], %[[B2]] |
| // LLVM: store i32 %[[REM]], ptr %[[X]] |
| |
| // LLVM: %[[X3:.*]] = load i32, ptr %[[X]] |
| // LLVM: %[[B3:.*]] = load i32, ptr %[[B_ADDR]] |
| // LLVM: %[[ADD:.*]] = add nsw i32 %[[X3]], %[[B3]] |
| // LLVM: store i32 %[[ADD]], ptr %[[X]] |
| |
| // LLVM: %[[X4:.*]] = load i32, ptr %[[X]] |
| // LLVM: %[[B4:.*]] = load i32, ptr %[[B_ADDR]] |
| // LLVM: %[[SUB:.*]] = sub nsw i32 %[[X4]], %[[B4]] |
| // LLVM: store i32 %[[SUB]], ptr %[[X]] |
| |
| // LLVM: %[[X5:.*]] = load i32, ptr %[[X]] |
| // LLVM: %[[B5:.*]] = load i32, ptr %[[B_ADDR]] |
| // LLVM: %[[AND:.*]] = and i32 %[[X5]], %[[B5]] |
| // LLVM: store i32 %[[AND]], ptr %[[X]] |
| |
| // LLVM: %[[X6:.*]] = load i32, ptr %[[X]] |
| // LLVM: %[[B6:.*]] = load i32, ptr %[[B_ADDR]] |
| // LLVM: %[[XOR:.*]] = xor i32 %[[X6]], %[[B6]] |
| // LLVM: store i32 %[[XOR]], ptr %[[X]] |
| |
| // LLVM: %[[X7:.*]] = load i32, ptr %[[X]] |
| // LLVM: %[[B7:.*]] = load i32, ptr %[[B_ADDR]] |
| // LLVM: %[[OR:.*]] = or i32 %[[X7]], %[[B7]] |
| // LLVM: store i32 %[[OR]], ptr %[[X]] |
| |
| // LLVM: ret void |
| |
| // OGCG-LABEL: define{{.*}} void @_Z2b0ii(i32 {{.*}} %a, i32 {{.*}} %b) {{.*}} { |
| // OGCG: %[[A_ADDR:.*]] = alloca i32 |
| // OGCG: %[[B_ADDR:.*]] = alloca i32 |
| // OGCG: %[[X:.*]] = alloca i32 |
| // OGCG: store i32 %a, ptr %[[A_ADDR]] |
| // OGCG: store i32 %b, ptr %[[B_ADDR]] |
| |
| // OGCG: %[[A:.*]] = load i32, ptr %[[A_ADDR]] |
| // OGCG: %[[B:.*]] = load i32, ptr %[[B_ADDR]] |
| // OGCG: %[[MUL:.*]] = mul nsw i32 %[[A]], %[[B]] |
| // OGCG: store i32 %[[MUL]], ptr %[[X]] |
| |
| // OGCG: %[[X1:.*]] = load i32, ptr %[[X]] |
| // OGCG: %[[B1:.*]] = load i32, ptr %[[B_ADDR]] |
| // OGCG: %[[DIV:.*]] = sdiv i32 %[[X1]], %[[B1]] |
| // OGCG: store i32 %[[DIV]], ptr %[[X]] |
| |
| // OGCG: %[[X2:.*]] = load i32, ptr %[[X]] |
| // OGCG: %[[B2:.*]] = load i32, ptr %[[B_ADDR]] |
| // OGCG: %[[REM:.*]] = srem i32 %[[X2]], %[[B2]] |
| // OGCG: store i32 %[[REM]], ptr %[[X]] |
| |
| // OGCG: %[[X3:.*]] = load i32, ptr %[[X]] |
| // OGCG: %[[B3:.*]] = load i32, ptr %[[B_ADDR]] |
| // OGCG: %[[ADD:.*]] = add nsw i32 %[[X3]], %[[B3]] |
| // OGCG: store i32 %[[ADD]], ptr %[[X]] |
| |
| // OGCG: %[[X4:.*]] = load i32, ptr %[[X]] |
| // OGCG: %[[B4:.*]] = load i32, ptr %[[B_ADDR]] |
| // OGCG: %[[SUB:.*]] = sub nsw i32 %[[X4]], %[[B4]] |
| // OGCG: store i32 %[[SUB]], ptr %[[X]] |
| |
| // OGCG: %[[X5:.*]] = load i32, ptr %[[X]] |
| // OGCG: %[[B5:.*]] = load i32, ptr %[[B_ADDR]] |
| // OGCG: %[[AND:.*]] = and i32 %[[X5]], %[[B5]] |
| // OGCG: store i32 %[[AND]], ptr %[[X]] |
| |
| // OGCG: %[[X6:.*]] = load i32, ptr %[[X]] |
| // OGCG: %[[B6:.*]] = load i32, ptr %[[B_ADDR]] |
| // OGCG: %[[XOR:.*]] = xor i32 %[[X6]], %[[B6]] |
| // OGCG: store i32 %[[XOR]], ptr %[[X]] |
| |
| // OGCG: %[[X7:.*]] = load i32, ptr %[[X]] |
| // OGCG: %[[B7:.*]] = load i32, ptr %[[B_ADDR]] |
| // OGCG: %[[OR:.*]] = or i32 %[[X7]], %[[B7]] |
| // OGCG: store i32 %[[OR]], ptr %[[X]] |
| |
| // OGCG: ret void |
| |
| void testFloatingPointBinOps(float a, float b) { |
| a * b; |
| a / b; |
| a + b; |
| a - b; |
| } |
| |
| // CIR-LABEL: cir.func{{.*}} @_Z23testFloatingPointBinOpsff( |
| // CIR: cir.binop(mul, %{{.+}}, %{{.+}}) : !cir.float |
| // CIR: cir.binop(div, %{{.+}}, %{{.+}}) : !cir.float |
| // CIR: cir.binop(add, %{{.+}}, %{{.+}}) : !cir.float |
| // CIR: cir.binop(sub, %{{.+}}, %{{.+}}) : !cir.float |
| // CIR: cir.return |
| |
| // LLVM-LABEL: define{{.*}} void @_Z23testFloatingPointBinOpsff( |
| // LLVM-SAME: float %[[A:.*]], float %[[B:.*]]) |
| // LLVM: %[[A_ADDR:.*]] = alloca float, i64 1 |
| // LLVM: %[[B_ADDR:.*]] = alloca float, i64 1 |
| // LLVM: store float %[[A]], ptr %[[A_ADDR]] |
| // LLVM: store float %[[B]], ptr %[[B_ADDR]] |
| |
| // LLVM: %[[A1:.*]] = load float, ptr %[[A_ADDR]] |
| // LLVM: %[[B1:.*]] = load float, ptr %[[B_ADDR]] |
| // LLVM: fmul float %[[A1]], %[[B1]] |
| |
| // LLVM: %[[A2:.*]] = load float, ptr %[[A_ADDR]] |
| // LLVM: %[[B2:.*]] = load float, ptr %[[B_ADDR]] |
| // LLVM: fdiv float %[[A2]], %[[B2]] |
| |
| // LLVM: %[[A3:.*]] = load float, ptr %[[A_ADDR]] |
| // LLVM: %[[B3:.*]] = load float, ptr %[[B_ADDR]] |
| // LLVM: fadd float %[[A3]], %[[B3]] |
| |
| // LLVM: %[[A4:.*]] = load float, ptr %[[A_ADDR]] |
| // LLVM: %[[B4:.*]] = load float, ptr %[[B_ADDR]] |
| // LLVM: fsub float %[[A4]], %[[B4]] |
| |
| // LLVM: ret void |
| |
| // OGCG-LABEL: define{{.*}} void @_Z23testFloatingPointBinOpsff(float {{.*}} %a, float {{.*}} %b) |
| // OGCG: %a.addr = alloca float |
| // OGCG: %b.addr = alloca float |
| // OGCG: store float %a, ptr %a.addr |
| // OGCG: store float %b, ptr %b.addr |
| |
| // OGCG: %[[A1:.*]] = load float, ptr %a.addr |
| // OGCG: %[[B1:.*]] = load float, ptr %b.addr |
| // OGCG: fmul float %[[A1]], %[[B1]] |
| |
| // OGCG: %[[A2:.*]] = load float, ptr %a.addr |
| // OGCG: %[[B2:.*]] = load float, ptr %b.addr |
| // OGCG: fdiv float %[[A2]], %[[B2]] |
| |
| // OGCG: %[[A3:.*]] = load float, ptr %a.addr |
| // OGCG: %[[B3:.*]] = load float, ptr %b.addr |
| // OGCG: fadd float %[[A3]], %[[B3]] |
| |
| // OGCG: %[[A4:.*]] = load float, ptr %a.addr |
| // OGCG: %[[B4:.*]] = load float, ptr %b.addr |
| // OGCG: fsub float %[[A4]], %[[B4]] |
| |
| // OGCG: ret void |
| |
| void signed_shift(int a, int b) { |
| int x = a >> b; |
| x = a << b; |
| } |
| |
| // CIR-LABEL: cir.func{{.*}} @_Z12signed_shiftii( |
| // CIR-SAME: %[[ARG0:.*]]: !s32i{{.*}}, %[[ARG1:.*]]: !s32i{{.*}}) |
| // CIR: %[[A_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] |
| // CIR: %[[B_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] |
| // CIR: %[[X_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] |
| |
| // CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !s32i, !cir.ptr<!s32i> |
| // CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !s32i, !cir.ptr<!s32i> |
| |
| // CIR: %[[A1:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!s32i>, !s32i |
| // CIR: %[[B1:.*]] = cir.load{{.*}} %[[B_PTR]] : !cir.ptr<!s32i>, !s32i |
| // CIR: %[[ASHR:.*]] = cir.shift(right, %[[A1]] : !s32i, %[[B1]] : !s32i) -> !s32i |
| // CIR: cir.store{{.*}} %[[ASHR]], %[[X_PTR]] : !s32i, !cir.ptr<!s32i> |
| |
| // CIR: %[[A2:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!s32i>, !s32i |
| // CIR: %[[B2:.*]] = cir.load{{.*}} %[[B_PTR]] : !cir.ptr<!s32i>, !s32i |
| // CIR: %[[SHL:.*]] = cir.shift(left, %[[A2]] : !s32i, %[[B2]] : !s32i) -> !s32i |
| // CIR: cir.store{{.*}} %[[SHL]], %[[X_PTR]] : !s32i, !cir.ptr<!s32i> |
| |
| // CIR: cir.return |
| |
| // LLVM-LABEL: define{{.*}} void @_Z12signed_shiftii |
| // LLVM-SAME: (i32 %[[A:.*]], i32 %[[B:.*]]) |
| // LLVM: %[[A_ADDR:.*]] = alloca i32 |
| // LLVM: %[[B_ADDR:.*]] = alloca i32 |
| // LLVM: %[[X:.*]] = alloca i32 |
| // LLVM: store i32 %[[A]], ptr %[[A_ADDR]] |
| // LLVM: store i32 %[[B]], ptr %[[B_ADDR]] |
| |
| // LLVM: %[[A1:.*]] = load i32, ptr %[[A_ADDR]] |
| // LLVM: %[[B1:.*]] = load i32, ptr %[[B_ADDR]] |
| // LLVM: %[[ASHR:.*]] = ashr i32 %[[A1]], %[[B1]] |
| // LLVM: store i32 %[[ASHR]], ptr %[[X]] |
| |
| // LLVM: %[[A2:.*]] = load i32, ptr %[[A_ADDR]] |
| // LLVM: %[[B2:.*]] = load i32, ptr %[[B_ADDR]] |
| // LLVM: %[[SHL:.*]] = shl i32 %[[A2]], %[[B2]] |
| // LLVM: store i32 %[[SHL]], ptr %[[X]] |
| |
| // LLVM: ret void |
| |
| // OGCG-LABEL: define{{.*}} void @_Z12signed_shiftii |
| // OGCG-SAME: (i32 {{.*}} %[[A:.*]], i32 {{.*}} %[[B:.*]]) |
| // OGCG: %[[A_ADDR:.*]] = alloca i32 |
| // OGCG: %[[B_ADDR:.*]] = alloca i32 |
| // OGCG: %[[X:.*]] = alloca i32 |
| // OGCG: store i32 %[[A]], ptr %[[A_ADDR]] |
| // OGCG: store i32 %[[B]], ptr %[[B_ADDR]] |
| |
| // OGCG: %[[A1:.*]] = load i32, ptr %[[A_ADDR]] |
| // OGCG: %[[B1:.*]] = load i32, ptr %[[B_ADDR]] |
| // OGCG: %[[ASHR:.*]] = ashr i32 %[[A1]], %[[B1]] |
| // OGCG: store i32 %[[ASHR]], ptr %[[X]] |
| |
| // OGCG: %[[A2:.*]] = load i32, ptr %[[A_ADDR]] |
| // OGCG: %[[B2:.*]] = load i32, ptr %[[B_ADDR]] |
| // OGCG: %[[SHL:.*]] = shl i32 %[[A2]], %[[B2]] |
| // OGCG: store i32 %[[SHL]], ptr %[[X]] |
| |
| // OGCG: ret void |
| |
| void unsigned_shift(unsigned a, unsigned b) { |
| unsigned x = a >> b; |
| x = a << b; |
| } |
| |
| // CIR-LABEL: cir.func{{.*}} @_Z14unsigned_shiftjj( |
| // CIR-SAME: %[[ARG0:.*]]: !u32i{{.*}}, %[[ARG1:.*]]: !u32i{{.*}}) |
| // CIR: %[[A_PTR:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["a", init] |
| // CIR: %[[B_PTR:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["b", init] |
| // CIR: %[[X_PTR:.*]] = cir.alloca !u32i, !cir.ptr<!u32i>, ["x", init] |
| |
| // CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !u32i, !cir.ptr<!u32i> |
| // CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !u32i, !cir.ptr<!u32i> |
| |
| // CIR: %[[A1:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!u32i>, !u32i |
| // CIR: %[[B1:.*]] = cir.load{{.*}} %[[B_PTR]] : !cir.ptr<!u32i>, !u32i |
| // CIR: %[[ASHR:.*]] = cir.shift(right, %[[A1]] : !u32i, %[[B1]] : !u32i) -> !u32i |
| // CIR: cir.store{{.*}} %[[ASHR]], %[[X_PTR]] : !u32i, !cir.ptr<!u32i> |
| |
| // CIR: %[[A2:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!u32i>, !u32i |
| // CIR: %[[B2:.*]] = cir.load{{.*}} %[[B_PTR]] : !cir.ptr<!u32i>, !u32i |
| // CIR: %[[SHL:.*]] = cir.shift(left, %[[A2]] : !u32i, %[[B2]] : !u32i) -> !u32i |
| // CIR: cir.store{{.*}} %[[SHL]], %[[X_PTR]] : !u32i, !cir.ptr<!u32i> |
| |
| // CIR: cir.return |
| |
| // LLVM-LABEL: define{{.*}} void @_Z14unsigned_shiftjj |
| // LLVM-SAME: (i32 %[[A:.*]], i32 %[[B:.*]]) |
| // LLVM: %[[A_ADDR:.*]] = alloca i32 |
| // LLVM: %[[B_ADDR:.*]] = alloca i32 |
| // LLVM: %[[X:.*]] = alloca i32 |
| // LLVM: store i32 %[[A]], ptr %[[A_ADDR]] |
| // LLVM: store i32 %[[B]], ptr %[[B_ADDR]] |
| |
| // LLVM: %[[A1:.*]] = load i32, ptr %[[A_ADDR]] |
| // LLVM: %[[B1:.*]] = load i32, ptr %[[B_ADDR]] |
| // LLVM: %[[ASHR:.*]] = lshr i32 %[[A1]], %[[B1]] |
| // LLVM: store i32 %[[ASHR]], ptr %[[X]] |
| |
| // LLVM: %[[A2:.*]] = load i32, ptr %[[A_ADDR]] |
| // LLVM: %[[B2:.*]] = load i32, ptr %[[B_ADDR]] |
| // LLVM: %[[SHL:.*]] = shl i32 %[[A2]], %[[B2]] |
| // LLVM: store i32 %[[SHL]], ptr %[[X]] |
| |
| // LLVM: ret void |
| |
| // OGCG-LABEL: define{{.*}} void @_Z14unsigned_shiftjj |
| // OGCG-SAME: (i32 {{.*}} %[[A:.*]], i32 {{.*}} %[[B:.*]]) |
| // OGCG: %[[A_ADDR:.*]] = alloca i32 |
| // OGCG: %[[B_ADDR:.*]] = alloca i32 |
| // OGCG: %[[X:.*]] = alloca i32 |
| // OGCG: store i32 %[[A]], ptr %[[A_ADDR]] |
| // OGCG: store i32 %[[B]], ptr %[[B_ADDR]] |
| |
| // OGCG: %[[A1:.*]] = load i32, ptr %[[A_ADDR]] |
| // OGCG: %[[B1:.*]] = load i32, ptr %[[B_ADDR]] |
| // OGCG: %[[ASHR:.*]] = lshr i32 %[[A1]], %[[B1]] |
| // OGCG: store i32 %[[ASHR]], ptr %[[X]] |
| |
| // OGCG: %[[A2:.*]] = load i32, ptr %[[A_ADDR]] |
| // OGCG: %[[B2:.*]] = load i32, ptr %[[B_ADDR]] |
| // OGCG: %[[SHL:.*]] = shl i32 %[[A2]], %[[B2]] |
| // OGCG: store i32 %[[SHL]], ptr %[[X]] |
| |
| // OGCG: ret void |
| |
| void zext_shift_example(int a, unsigned char b) { |
| int x = a >> b; |
| x = a << b; |
| } |
| |
| // CIR-LABEL: cir.func{{.*}} @_Z18zext_shift_exampleih( |
| // CIR-SAME: %[[ARG0:.*]]: !s32i{{.*}}, %[[ARG1:.*]]: !u8i{{.*}}) |
| // CIR: %[[A_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] |
| // CIR: %[[B_PTR:.*]] = cir.alloca !u8i, !cir.ptr<!u8i>, ["b", init] |
| // CIR: %[[X_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] |
| |
| // CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !s32i, !cir.ptr<!s32i> |
| // CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !u8i, !cir.ptr<!u8i> |
| |
| // CIR: %[[A1:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!s32i>, !s32i |
| // CIR: %[[B1:.*]] = cir.load{{.*}} %[[B_PTR]] : !cir.ptr<!u8i>, !u8i |
| // CIR: %[[B1_EXT:.*]] = cir.cast(integral, %[[B1]] : !u8i), !s32i |
| // CIR: %[[ASHR:.*]] = cir.shift(right, %[[A1]] : !s32i, %[[B1_EXT]] : !s32i) -> !s32i |
| // CIR: cir.store{{.*}} %[[ASHR]], %[[X_PTR]] : !s32i, !cir.ptr<!s32i> |
| |
| // CIR: %[[A2:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!s32i>, !s32i |
| // CIR: %[[B2:.*]] = cir.load{{.*}} %[[B_PTR]] : !cir.ptr<!u8i>, !u8i |
| // CIR: %[[B2_EXT:.*]] = cir.cast(integral, %[[B2]] : !u8i), !s32i |
| // CIR: %[[SHL:.*]] = cir.shift(left, %[[A2]] : !s32i, %[[B2_EXT]] : !s32i) -> !s32i |
| // CIR: cir.store{{.*}} %[[SHL]], %[[X_PTR]] : !s32i, !cir.ptr<!s32i> |
| |
| // CIR: cir.return |
| |
| // LLVM-LABEL: define{{.*}} void @_Z18zext_shift_exampleih |
| // LLVM-SAME: (i32 %[[A:.*]], i8 %[[B:.*]]) |
| // LLVM: %[[A_ADDR:.*]] = alloca i32 |
| // LLVM: %[[B_ADDR:.*]] = alloca i8 |
| // LLVM: %[[X:.*]] = alloca i32 |
| // LLVM: store i32 %[[A]], ptr %[[A_ADDR]] |
| // LLVM: store i8 %[[B]], ptr %[[B_ADDR]] |
| |
| // LLVM: %[[A1:.*]] = load i32, ptr %[[A_ADDR]] |
| // LLVM: %[[B1:.*]] = load i8, ptr %[[B_ADDR]] |
| // LLVM: %[[B1_EXT:.*]] = zext i8 %[[B1]] to i32 |
| // LLVM: %[[ASHR:.*]] = ashr i32 %[[A1]], %[[B1_EXT]] |
| // LLVM: store i32 %[[ASHR]], ptr %[[X]] |
| |
| // LLVM: %[[A2:.*]] = load i32, ptr %[[A_ADDR]] |
| // LLVM: %[[B2:.*]] = load i8, ptr %[[B_ADDR]] |
| // LLVM: %[[B2_EXT:.*]] = zext i8 %[[B2]] to i32 |
| // LLVM: %[[SHL:.*]] = shl i32 %[[A2]], %[[B2_EXT]] |
| // LLVM: store i32 %[[SHL]], ptr %[[X]] |
| |
| // LLVM: ret void |
| |
| // OGCG-LABEL: define{{.*}} void @_Z18zext_shift_exampleih |
| // OGCG-SAME: (i32 {{.*}} %[[A:.*]], i8 {{.*}} %[[B:.*]]) |
| // OGCG: %[[A_ADDR:.*]] = alloca i32 |
| // OGCG: %[[B_ADDR:.*]] = alloca i8 |
| // OGCG: %[[X:.*]] = alloca i32 |
| // OGCG: store i32 %[[A]], ptr %[[A_ADDR]] |
| // OGCG: store i8 %[[B]], ptr %[[B_ADDR]] |
| |
| // OGCG: %[[A1:.*]] = load i32, ptr %[[A_ADDR]] |
| // OGCG: %[[B1:.*]] = load i8, ptr %[[B_ADDR]] |
| // OGCG: %[[B1_EXT:.*]] = zext i8 %[[B1]] to i32 |
| // OGCG: %[[ASHR:.*]] = ashr i32 %[[A1]], %[[B1_EXT]] |
| // OGCG: store i32 %[[ASHR]], ptr %[[X]] |
| |
| // OGCG: %[[A2:.*]] = load i32, ptr %[[A_ADDR]] |
| // OGCG: %[[B2:.*]] = load i8, ptr %[[B_ADDR]] |
| // OGCG: %[[B2_EXT:.*]] = zext i8 %[[B2]] to i32 |
| // OGCG: %[[SHL:.*]] = shl i32 %[[A2]], %[[B2_EXT]] |
| // OGCG: store i32 %[[SHL]], ptr %[[X]] |
| |
| // OGCG: ret void |
| |
| void sext_shift_example(int a, signed char b) { |
| int x = a >> b; |
| x = a << b; |
| } |
| |
| // CIR-LABEL: cir.func{{.*}} @_Z18sext_shift_exampleia( |
| // CIR-SAME: %[[ARG0:.*]]: !s32i{{.*}}, %[[ARG1:.*]]: !s8i{{.*}}) |
| // CIR: %[[A_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] |
| // CIR: %[[B_PTR:.*]] = cir.alloca !s8i, !cir.ptr<!s8i>, ["b", init] |
| // CIR: %[[X_PTR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["x", init] |
| |
| // CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !s32i, !cir.ptr<!s32i> |
| // CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !s8i, !cir.ptr<!s8i> |
| |
| // CIR: %[[A1:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!s32i>, !s32i |
| // CIR: %[[B1:.*]] = cir.load{{.*}} %[[B_PTR]] : !cir.ptr<!s8i>, !s8i |
| // CIR: %[[B1_EXT:.*]] = cir.cast(integral, %[[B1]] : !s8i), !s32i |
| // CIR: %[[ASHR:.*]] = cir.shift(right, %[[A1]] : !s32i, %[[B1_EXT]] : !s32i) -> !s32i |
| // CIR: cir.store{{.*}} %[[ASHR]], %[[X_PTR]] : !s32i, !cir.ptr<!s32i> |
| |
| // CIR: %[[A2:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!s32i>, !s32i |
| // CIR: %[[B2:.*]] = cir.load{{.*}} %[[B_PTR]] : !cir.ptr<!s8i>, !s8i |
| // CIR: %[[B2_EXT:.*]] = cir.cast(integral, %[[B2]] : !s8i), !s32i |
| // CIR: %[[SHL:.*]] = cir.shift(left, %[[A2]] : !s32i, %[[B2_EXT]] : !s32i) -> !s32i |
| // CIR: cir.store{{.*}} %[[SHL]], %[[X_PTR]] : !s32i, !cir.ptr<!s32i> |
| |
| // CIR: cir.return |
| |
| // LLVM-LABEL: define{{.*}} void @_Z18sext_shift_exampleia |
| // LLVM-SAME: (i32 %[[A:.*]], i8 %[[B:.*]]) |
| // LLVM: %[[A_ADDR:.*]] = alloca i32 |
| // LLVM: %[[B_ADDR:.*]] = alloca i8 |
| // LLVM: %[[X:.*]] = alloca i32 |
| // LLVM: store i32 %[[A]], ptr %[[A_ADDR]] |
| // LLVM: store i8 %[[B]], ptr %[[B_ADDR]] |
| |
| // LLVM: %[[A1:.*]] = load i32, ptr %[[A_ADDR]] |
| // LLVM: %[[B1:.*]] = load i8, ptr %[[B_ADDR]] |
| // LLVM: %[[B1_EXT:.*]] = sext i8 %[[B1]] to i32 |
| // LLVM: %[[ASHR:.*]] = ashr i32 %[[A1]], %[[B1_EXT]] |
| // LLVM: store i32 %[[ASHR]], ptr %[[X]] |
| |
| // LLVM: %[[A2:.*]] = load i32, ptr %[[A_ADDR]] |
| // LLVM: %[[B2:.*]] = load i8, ptr %[[B_ADDR]] |
| // LLVM: %[[B2_EXT:.*]] = sext i8 %[[B2]] to i32 |
| // LLVM: %[[SHL:.*]] = shl i32 %[[A2]], %[[B2_EXT]] |
| // LLVM: store i32 %[[SHL]], ptr %[[X]] |
| |
| // LLVM: ret void |
| |
| // OGCG-LABEL: define{{.*}} void @_Z18sext_shift_exampleia |
| // OGCG-SAME: (i32 {{.*}} %[[A:.*]], i8 {{.*}} %[[B:.*]]) |
| // OGCG: %[[A_ADDR:.*]] = alloca i32 |
| // OGCG: %[[B_ADDR:.*]] = alloca i8 |
| // OGCG: %[[X:.*]] = alloca i32 |
| // OGCG: store i32 %[[A]], ptr %[[A_ADDR]] |
| // OGCG: store i8 %[[B]], ptr %[[B_ADDR]] |
| |
| // OGCG: %[[A1:.*]] = load i32, ptr %[[A_ADDR]] |
| // OGCG: %[[B1:.*]] = load i8, ptr %[[B_ADDR]] |
| // OGCG: %[[B1_EXT:.*]] = sext i8 %[[B1]] to i32 |
| // OGCG: %[[ASHR:.*]] = ashr i32 %[[A1]], %[[B1_EXT]] |
| // OGCG: store i32 %[[ASHR]], ptr %[[X]] |
| |
| // OGCG: %[[A2:.*]] = load i32, ptr %[[A_ADDR]] |
| // OGCG: %[[B2:.*]] = load i8, ptr %[[B_ADDR]] |
| // OGCG: %[[B2_EXT:.*]] = sext i8 %[[B2]] to i32 |
| // OGCG: %[[SHL:.*]] = shl i32 %[[A2]], %[[B2_EXT]] |
| // OGCG: store i32 %[[SHL]], ptr %[[X]] |
| |
| // OGCG: ret void |
| |
| void long_shift_example(long long a, short b) { |
| long long x = a >> b; |
| x = a << b; |
| } |
| |
| // CIR-LABEL: cir.func{{.*}} @_Z18long_shift_examplexs( |
| // CIR-SAME: %[[ARG0:.*]]: !s64i{{.*}}, %[[ARG1:.*]]: !s16i{{.*}}) |
| // CIR: %[[A_PTR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["a", init] |
| // CIR: %[[B_PTR:.*]] = cir.alloca !s16i, !cir.ptr<!s16i>, ["b", init] |
| // CIR: %[[X_PTR:.*]] = cir.alloca !s64i, !cir.ptr<!s64i>, ["x", init] |
| |
| // CIR: cir.store{{.*}} %[[ARG0]], %[[A_PTR]] : !s64i, !cir.ptr<!s64i> |
| // CIR: cir.store{{.*}} %[[ARG1]], %[[B_PTR]] : !s16i, !cir.ptr<!s16i> |
| |
| // CIR: %[[A1:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!s64i>, !s64i |
| // CIR: %[[B1:.*]] = cir.load{{.*}} %[[B_PTR]] : !cir.ptr<!s16i>, !s16i |
| // CIR: %[[B1_EXT:.*]] = cir.cast(integral, %[[B1]] : !s16i), !s32i |
| // CIR: %[[ASHR:.*]] = cir.shift(right, %[[A1]] : !s64i, %[[B1_EXT]] : !s32i) -> !s64i |
| // CIR: cir.store{{.*}} %[[ASHR]], %[[X_PTR]] : !s64i, !cir.ptr<!s64i> |
| |
| // CIR: %[[A2:.*]] = cir.load{{.*}} %[[A_PTR]] : !cir.ptr<!s64i>, !s64i |
| // CIR: %[[B2:.*]] = cir.load{{.*}} %[[B_PTR]] : !cir.ptr<!s16i>, !s16i |
| // CIR: %[[B2_EXT:.*]] = cir.cast(integral, %[[B2]] : !s16i), !s32i |
| // CIR: %[[SHL:.*]] = cir.shift(left, %[[A2]] : !s64i, %[[B2_EXT]] : !s32i) -> !s64i |
| // CIR: cir.store{{.*}} %[[SHL]], %[[X_PTR]] : !s64i, !cir.ptr<!s64i> |
| |
| // CIR: cir.return |
| |
| // LLVM-LABEL: define{{.*}} void @_Z18long_shift_examplexs |
| // LLVM-SAME: (i64 %[[A:.*]], i16 %[[B:.*]]) |
| // LLVM: %[[A_ADDR:.*]] = alloca i64 |
| // LLVM: %[[B_ADDR:.*]] = alloca i16 |
| // LLVM: %[[X:.*]] = alloca i64 |
| // LLVM: store i64 %[[A]], ptr %[[A_ADDR]] |
| // LLVM: store i16 %[[B]], ptr %[[B_ADDR]] |
| |
| // LLVM: %[[A1:.*]] = load i64, ptr %[[A_ADDR]] |
| // LLVM: %[[B1:.*]] = load i16, ptr %[[B_ADDR]] |
| // LLVM: %[[B1_SEXT:.*]] = sext i16 %[[B1]] to i32 |
| // LLVM: %[[B1_ZEXT:.*]] = zext i32 %[[B1_SEXT]] to i64 |
| // LLVM: %[[ASHR:.*]] = ashr i64 %[[A1]], %[[B1_ZEXT]] |
| // LLVM: store i64 %[[ASHR]], ptr %[[X]] |
| |
| // LLVM: %[[A2:.*]] = load i64, ptr %[[A_ADDR]] |
| // LLVM: %[[B2:.*]] = load i16, ptr %[[B_ADDR]] |
| // LLVM: %[[B2_SEXT:.*]] = sext i16 %[[B2]] to i32 |
| // LLVM: %[[B2_ZEXT:.*]] = zext i32 %[[B2_SEXT]] to i64 |
| // LLVM: %[[SHL:.*]] = shl i64 %[[A2]], %[[B2_ZEXT]] |
| // LLVM: store i64 %[[SHL]], ptr %[[X]] |
| |
| // LLVM: ret void |
| |
| // OGCG-LABEL: define{{.*}} void @_Z18long_shift_examplexs |
| // OGCG-SAME: (i64 {{.*}} %[[A:.*]], i16 {{.*}} %[[B:.*]]) |
| // OGCG: %[[A_ADDR:.*]] = alloca i64 |
| // OGCG: %[[B_ADDR:.*]] = alloca i16 |
| // OGCG: %[[X:.*]] = alloca i64 |
| // OGCG: store i64 %[[A]], ptr %[[A_ADDR]] |
| // OGCG: store i16 %[[B]], ptr %[[B_ADDR]] |
| |
| // OGCG: %[[A1:.*]] = load i64, ptr %[[A_ADDR]] |
| // OGCG: %[[B1:.*]] = load i16, ptr %[[B_ADDR]] |
| // OGCG: %[[B1_SEXT:.*]] = sext i16 %[[B1]] to i32 |
| // OGCG: %[[B1_ZEXT:.*]] = zext i32 %[[B1_SEXT]] to i64 |
| // OGCG: %[[ASHR:.*]] = ashr i64 %[[A1]], %[[B1_ZEXT]] |
| // OGCG: store i64 %[[ASHR]], ptr %[[X]] |
| |
| // OGCG: %[[A2:.*]] = load i64, ptr %[[A_ADDR]] |
| // OGCG: %[[B2:.*]] = load i16, ptr %[[B_ADDR]] |
| // OGCG: %[[B2_SEXT:.*]] = sext i16 %[[B2]] to i32 |
| // OGCG: %[[B2_ZEXT:.*]] = zext i32 %[[B2_SEXT]] to i64 |
| // OGCG: %[[SHL:.*]] = shl i64 %[[A2]], %[[B2_ZEXT]] |
| // OGCG: store i64 %[[SHL]], ptr %[[X]] |
| |
| // OGCG: ret void |
| |
| void b1(bool a, bool b) { |
| bool x = a && b; |
| x = x || b; |
| } |
| |
| // CIR-LABEL: cir.func{{.*}} @_Z2b1bb( |
| // CIR-SAME: %[[ARG0:.*]]: !cir.bool {{.*}}, %[[ARG1:.*]]: !cir.bool {{.*}}) |
| // CIR: [[A:%[0-9]+]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["a", init] |
| // CIR: [[B:%[0-9]+]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["b", init] |
| // CIR: [[X:%[0-9]+]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] |
| // CIR: cir.store %[[ARG0]], [[A]] : !cir.bool, !cir.ptr<!cir.bool> |
| // CIR: cir.store %[[ARG1]], [[B]] : !cir.bool, !cir.ptr<!cir.bool> |
| // CIR: [[AVAL:%[0-9]+]] = cir.load align(1) [[A]] : !cir.ptr<!cir.bool>, !cir.bool |
| // CIR: [[RES1:%[0-9]+]] = cir.ternary([[AVAL]], true { |
| // CIR: [[BVAL:%[0-9]+]] = cir.load align(1) [[B]] : !cir.ptr<!cir.bool>, !cir.bool |
| // CIR: cir.yield [[BVAL]] : !cir.bool |
| // CIR: }, false { |
| // CIR: [[FALSE:%[0-9]+]] = cir.const #false |
| // CIR: cir.yield [[FALSE]] : !cir.bool |
| // CIR: }) : (!cir.bool) -> !cir.bool |
| // CIR: cir.store align(1) [[RES1]], [[X]] : !cir.bool, !cir.ptr<!cir.bool> |
| // CIR: [[XVAL:%[0-9]+]] = cir.load align(1) [[X]] : !cir.ptr<!cir.bool>, !cir.bool |
| // CIR: [[RES2:%[0-9]+]] = cir.ternary([[XVAL]], true { |
| // CIR: [[TRUE:%[0-9]+]] = cir.const #true |
| // CIR: cir.yield [[TRUE]] : !cir.bool |
| // CIR: }, false { |
| // CIR: [[BVAL2:%[0-9]+]] = cir.load align(1) [[B]] : !cir.ptr<!cir.bool>, !cir.bool |
| // CIR: cir.yield [[BVAL2]] : !cir.bool |
| // CIR: }) : (!cir.bool) -> !cir.bool |
| // CIR: cir.store align(1) [[RES2]], [[X]] : !cir.bool, !cir.ptr<!cir.bool> |
| // CIR: cir.return |
| |
| |
| // LLVM-LABEL: define{{.*}} void @_Z2b1bb( |
| // LLVM-SAME: i1 %[[ARG0:.+]], i1 %[[ARG1:.+]]) |
| // LLVM: %[[A_ADDR:.*]] = alloca i8 |
| // LLVM: %[[B_ADDR:.*]] = alloca i8 |
| // LLVM: %[[X:.*]] = alloca i8 |
| // LLVM: %[[ZEXT0:.*]] = zext i1 %[[ARG0]] to i8 |
| // LLVM: store i8 %[[ZEXT0]], ptr %[[A_ADDR]] |
| // LLVM: %[[ZEXT1:.*]] = zext i1 %[[ARG1]] to i8 |
| // LLVM: store i8 %[[ZEXT1]], ptr %[[B_ADDR]] |
| // LLVM: %[[A_VAL:.*]] = load i8, ptr %[[A_ADDR]] |
| // LLVM: %[[A_BOOL:.*]] = trunc i8 %[[A_VAL]] to i1 |
| // LLVM: br i1 %[[A_BOOL]], label %[[AND_TRUE:.+]], label %[[AND_FALSE:.+]] |
| // LLVM: [[AND_TRUE]]: |
| // LLVM: %[[B_VAL:.*]] = load i8, ptr %[[B_ADDR]] |
| // LLVM: %[[B_BOOL:.*]] = trunc i8 %[[B_VAL]] to i1 |
| // LLVM: br label %[[AND_MERGE:.+]] |
| // LLVM: [[AND_FALSE]]: |
| // LLVM: br label %[[AND_MERGE]] |
| // LLVM: [[AND_MERGE]]: |
| // LLVM: %[[AND_PHI:.*]] = phi i1 [ false, %[[AND_FALSE]] ], [ %[[B_BOOL]], %[[AND_TRUE]] ] |
| // LLVM: %[[ZEXT_AND:.*]] = zext i1 %[[AND_PHI]] to i8 |
| // LLVM: store i8 %[[ZEXT_AND]], ptr %[[X]] |
| // LLVM: %[[X_VAL:.*]] = load i8, ptr %[[X]] |
| // LLVM: %[[X_BOOL:.*]] = trunc i8 %[[X_VAL]] to i1 |
| // LLVM: br i1 %[[X_BOOL]], label %[[OR_TRUE:.+]], label %[[OR_FALSE:.+]] |
| // LLVM: [[OR_TRUE]]: |
| // LLVM: br label %[[OR_MERGE:.+]] |
| // LLVM: [[OR_FALSE]]: |
| // LLVM: %[[B_VAL2:.*]] = load i8, ptr %[[B_ADDR]] |
| // LLVM: %[[B_BOOL2:.*]] = trunc i8 %[[B_VAL2]] to i1 |
| // LLVM: br label %[[OR_MERGE]] |
| // LLVM: [[OR_MERGE]]: |
| // LLVM: %[[OR_PHI:.*]] = phi i1 [ %[[B_BOOL2]], %[[OR_FALSE]] ], [ true, %[[OR_TRUE]] ] |
| // LLVM: %[[ZEXT_OR:.*]] = zext i1 %[[OR_PHI]] to i8 |
| // LLVM: store i8 %[[ZEXT_OR]], ptr %[[X]] |
| // LLVM: ret void |
| |
| // OGCG-LABEL: define{{.*}} void @_Z2b1bb |
| // OGCG-SAME: (i1 {{.*}} %[[ARG0:.+]], i1 {{.*}} %[[ARG1:.+]]) |
| // OGCG: [[ENTRY:.*]]: |
| // OGCG: %[[A_ADDR:.*]] = alloca i8 |
| // OGCG: %[[B_ADDR:.*]] = alloca i8 |
| // OGCG: %[[X:.*]] = alloca i8 |
| // OGCG: %[[ZEXT0:.*]] = zext i1 %[[ARG0]] to i8 |
| // OGCG: store i8 %[[ZEXT0]], ptr %[[A_ADDR]] |
| // OGCG: %[[ZEXT1:.*]] = zext i1 %[[ARG1]] to i8 |
| // OGCG: store i8 %[[ZEXT1]], ptr %[[B_ADDR]] |
| // OGCG: %[[A_VAL:.*]] = load i8, ptr %[[A_ADDR]] |
| // OGCG: %[[A_BOOL:.*]] = trunc i8 %[[A_VAL]] to i1 |
| // OGCG: br i1 %[[A_BOOL]], label %[[AND_TRUE:.+]], label %[[AND_MERGE:.+]] |
| // OGCG: [[AND_TRUE]]: |
| // OGCG: %[[B_VAL:.*]] = load i8, ptr %[[B_ADDR]] |
| // OGCG: %[[B_BOOL:.*]] = trunc i8 %[[B_VAL]] to i1 |
| // OGCG: br label %[[AND_MERGE:.+]] |
| // OGCG: [[AND_MERGE]]: |
| // OGCG: %[[AND_PHI:.*]] = phi i1 [ false, %[[ENTRY]] ], [ %[[B_BOOL]], %[[AND_TRUE]] ] |
| // OGCG: %[[ZEXT_AND:.*]] = zext i1 %[[AND_PHI]] to i8 |
| // OGCG: store i8 %[[ZEXT_AND]], ptr %[[X]] |
| // OGCG: %[[X_VAL:.*]] = load i8, ptr %[[X]] |
| // OGCG: %[[X_BOOL:.*]] = trunc i8 %[[X_VAL]] to i1 |
| // OGCG: br i1 %[[X_BOOL]], label %[[OR_MERGE:.+]], label %[[OR_FALSE:.+]] |
| // OGCG: [[OR_FALSE]]: |
| // OGCG: %[[B_VAL2:.*]] = load i8, ptr %[[B_ADDR]] |
| // OGCG: %[[B_BOOL2:.*]] = trunc i8 %[[B_VAL2]] to i1 |
| // OGCG: br label %[[OR_MERGE]] |
| // OGCG: [[OR_MERGE]]: |
| // OGCG: %[[OR_PHI:.*]] = phi i1 [ true, %[[AND_MERGE]] ], [ %[[B_BOOL2]], %[[OR_FALSE]] ] |
| // OGCG: %[[ZEXT_OR:.*]] = zext i1 %[[OR_PHI]] to i8 |
| // OGCG: store i8 %[[ZEXT_OR]], ptr %[[X]] |
| // OGCG: ret void |
| |
| void b3(int a, int b, int c, int d) { |
| bool x = (a == b) && (c == d); |
| x = (a == b) || (c == d); |
| } |
| |
| // CIR-LABEL: cir.func{{.*}} @_Z2b3iiii( |
| // CIR-SAME: %[[ARG0:.*]]: !s32i {{.*}}, %[[ARG1:.*]]: !s32i {{.*}}, %[[ARG2:.*]]: !s32i {{.*}}, %[[ARG3:.*]]: !s32i {{.*}}) |
| // CIR: [[A:%[0-9]+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["a", init] |
| // CIR: [[B:%[0-9]+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] |
| // CIR: [[C:%[0-9]+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["c", init] |
| // CIR: [[D:%[0-9]+]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["d", init] |
| // CIR: [[X:%[0-9]+]] = cir.alloca !cir.bool, !cir.ptr<!cir.bool>, ["x", init] |
| // CIR: cir.store %[[ARG0]], [[A]] : !s32i, !cir.ptr<!s32i> |
| // CIR: cir.store %[[ARG1]], [[B]] : !s32i, !cir.ptr<!s32i> |
| // CIR: cir.store %[[ARG2]], [[C]] : !s32i, !cir.ptr<!s32i> |
| // CIR: cir.store %[[ARG3]], [[D]] : !s32i, !cir.ptr<!s32i> |
| // CIR: [[AVAL1:%[0-9]+]] = cir.load align(4) [[A]] : !cir.ptr<!s32i>, !s32i |
| // CIR: [[BVAL1:%[0-9]+]] = cir.load align(4) [[B]] : !cir.ptr<!s32i>, !s32i |
| // CIR: [[CMP1:%[0-9]+]] = cir.cmp(eq, [[AVAL1]], [[BVAL1]]) : !s32i, !cir.bool |
| // CIR: [[AND_RESULT:%[0-9]+]] = cir.ternary([[CMP1]], true { |
| // CIR: [[CVAL1:%[0-9]+]] = cir.load align(4) [[C]] : !cir.ptr<!s32i>, !s32i |
| // CIR: [[DVAL1:%[0-9]+]] = cir.load align(4) [[D]] : !cir.ptr<!s32i>, !s32i |
| // CIR: [[CMP2:%[0-9]+]] = cir.cmp(eq, [[CVAL1]], [[DVAL1]]) : !s32i, !cir.bool |
| // CIR: cir.yield [[CMP2]] : !cir.bool |
| // CIR: }, false { |
| // CIR: [[FALSE:%[0-9]+]] = cir.const #false |
| // CIR: cir.yield [[FALSE]] : !cir.bool |
| // CIR: }) : (!cir.bool) -> !cir.bool |
| // CIR: cir.store align(1) [[AND_RESULT]], [[X]] : !cir.bool, !cir.ptr<!cir.bool> |
| // CIR: [[AVAL2:%[0-9]+]] = cir.load align(4) [[A]] : !cir.ptr<!s32i>, !s32i |
| // CIR: [[BVAL2:%[0-9]+]] = cir.load align(4) [[B]] : !cir.ptr<!s32i>, !s32i |
| // CIR: [[CMP3:%[0-9]+]] = cir.cmp(eq, [[AVAL2]], [[BVAL2]]) : !s32i, !cir.bool |
| // CIR: [[OR_RESULT:%[0-9]+]] = cir.ternary([[CMP3]], true { |
| // CIR: [[TRUE:%[0-9]+]] = cir.const #true |
| // CIR: cir.yield [[TRUE]] : !cir.bool |
| // CIR: }, false { |
| // CIR: [[CVAL2:%[0-9]+]] = cir.load align(4) [[C]] : !cir.ptr<!s32i>, !s32i |
| // CIR: [[DVAL2:%[0-9]+]] = cir.load align(4) [[D]] : !cir.ptr<!s32i>, !s32i |
| // CIR: [[CMP4:%[0-9]+]] = cir.cmp(eq, [[CVAL2]], [[DVAL2]]) : !s32i, !cir.bool |
| // CIR: cir.yield [[CMP4]] : !cir.bool |
| // CIR: }) : (!cir.bool) -> !cir.bool |
| // CIR: cir.store align(1) [[OR_RESULT]], [[X]] : !cir.bool, !cir.ptr<!cir.bool> |
| // CIR: cir.return |
| |
| |
| // LLVM-LABEL: define{{.*}} void @_Z2b3iiii( |
| // LLVM-SAME: i32 %[[ARG0:.+]], i32 %[[ARG1:.+]], i32 %[[ARG2:.+]], i32 %[[ARG3:.+]]) |
| // LLVM: %[[A_ADDR:.*]] = alloca i32, i64 1 |
| // LLVM: %[[B_ADDR:.*]] = alloca i32, i64 1 |
| // LLVM: %[[C_ADDR:.*]] = alloca i32, i64 1 |
| // LLVM: %[[D_ADDR:.*]] = alloca i32, i64 1 |
| // LLVM: %[[X:.*]] = alloca i8, i64 1 |
| // LLVM: store i32 %[[ARG0]], ptr %[[A_ADDR]] |
| // LLVM: store i32 %[[ARG1]], ptr %[[B_ADDR]] |
| // LLVM: store i32 %[[ARG2]], ptr %[[C_ADDR]] |
| // LLVM: store i32 %[[ARG3]], ptr %[[D_ADDR]] |
| // LLVM: %[[A_VAL:.*]] = load i32, ptr %[[A_ADDR]] |
| // LLVM: %[[B_VAL:.*]] = load i32, ptr %[[B_ADDR]] |
| // LLVM: %[[CMP1:.*]] = icmp eq i32 %[[A_VAL]], %[[B_VAL]] |
| // LLVM: br i1 %[[CMP1]], label %[[AND_TRUE:.+]], label %[[AND_FALSE:.+]] |
| // LLVM: [[AND_TRUE]]: |
| // LLVM: %[[C_VAL:.*]] = load i32, ptr %[[C_ADDR]] |
| // LLVM: %[[D_VAL:.*]] = load i32, ptr %[[D_ADDR]] |
| // LLVM: %[[CMP2:.*]] = icmp eq i32 %[[C_VAL]], %[[D_VAL]] |
| // LLVM: br label %[[AND_MERGE:.+]] |
| // LLVM: [[AND_FALSE]]: |
| // LLVM: br label %[[AND_MERGE]] |
| // LLVM: [[AND_MERGE]]: |
| // LLVM: %[[AND_PHI:.*]] = phi i1 [ false, %[[AND_FALSE]] ], [ %[[CMP2]], %[[AND_TRUE]] ] |
| // LLVM: %[[ZEXT_AND:.*]] = zext i1 %[[AND_PHI]] to i8 |
| // LLVM: store i8 %[[ZEXT_AND]], ptr %[[X]] |
| // LLVM: %[[A_VAL2:.*]] = load i32, ptr %[[A_ADDR]] |
| // LLVM: %[[B_VAL2:.*]] = load i32, ptr %[[B_ADDR]] |
| // LLVM: %[[CMP3:.*]] = icmp eq i32 %[[A_VAL2]], %[[B_VAL2]] |
| // LLVM: br i1 %[[CMP3]], label %[[OR_TRUE:.+]], label %[[OR_FALSE:.+]] |
| // LLVM: [[OR_TRUE]]: |
| // LLVM: br label %[[OR_MERGE:.+]] |
| // LLVM: [[OR_FALSE]]: |
| // LLVM: %[[C_VAL2:.*]] = load i32, ptr %[[C_ADDR]] |
| // LLVM: %[[D_VAL2:.*]] = load i32, ptr %[[D_ADDR]] |
| // LLVM: %[[CMP4:.*]] = icmp eq i32 %[[C_VAL2]], %[[D_VAL2]] |
| // LLVM: br label %[[OR_MERGE]] |
| // LLVM: [[OR_MERGE]]: |
| // LLVM: %[[OR_PHI:.*]] = phi i1 [ %[[CMP4]], %[[OR_FALSE]] ], [ true, %[[OR_TRUE]] ] |
| // LLVM: %[[ZEXT_OR:.*]] = zext i1 %[[OR_PHI]] to i8 |
| // LLVM: store i8 %[[ZEXT_OR]], ptr %[[X]] |
| // LLVM: ret void |
| |
| // OGCG-LABEL: define{{.*}} void @_Z2b3iiii( |
| // OGCG-SAME: i32 {{.*}} %[[ARG0:.+]], i32 {{.*}} %[[ARG1:.+]], i32 {{.*}} %[[ARG2:.+]], i32 {{.*}} %[[ARG3:.+]]) |
| // OGCG: [[ENTRY:.*]]: |
| // OGCG: %[[A_ADDR:.*]] = alloca i32 |
| // OGCG: %[[B_ADDR:.*]] = alloca i32 |
| // OGCG: %[[C_ADDR:.*]] = alloca i32 |
| // OGCG: %[[D_ADDR:.*]] = alloca i32 |
| // OGCG: %[[X:.*]] = alloca i8 |
| // OGCG: store i32 %[[ARG0]], ptr %[[A_ADDR]] |
| // OGCG: store i32 %[[ARG1]], ptr %[[B_ADDR]] |
| // OGCG: store i32 %[[ARG2]], ptr %[[C_ADDR]] |
| // OGCG: store i32 %[[ARG3]], ptr %[[D_ADDR]] |
| // OGCG: %[[A_VAL:.*]] = load i32, ptr %[[A_ADDR]] |
| // OGCG: %[[B_VAL:.*]] = load i32, ptr %[[B_ADDR]] |
| // OGCG: %[[CMP1:.*]] = icmp eq i32 %[[A_VAL]], %[[B_VAL]] |
| // OGCG: br i1 %[[CMP1]], label %[[AND_TRUE:.+]], label %[[AND_MERGE:.+]] |
| // OGCG: [[AND_TRUE]]: |
| // OGCG: %[[C_VAL:.*]] = load i32, ptr %[[C_ADDR]] |
| // OGCG: %[[D_VAL:.*]] = load i32, ptr %[[D_ADDR]] |
| // OGCG: %[[CMP2:.*]] = icmp eq i32 %[[C_VAL]], %[[D_VAL]] |
| // OGCG: br label %[[AND_MERGE:.+]] |
| // OGCG: [[AND_MERGE]]: |
| // OGCG: %[[AND_PHI:.*]] = phi i1 [ false, %[[ENTRY]] ], [ %[[CMP2]], %[[AND_TRUE]] ] |
| // OGCG: %[[ZEXT_AND:.*]] = zext i1 %[[AND_PHI]] to i8 |
| // OGCG: store i8 %[[ZEXT_AND]], ptr %[[X]] |
| // OGCG: %[[A_VAL2:.*]] = load i32, ptr %[[A_ADDR]] |
| // OGCG: %[[B_VAL2:.*]] = load i32, ptr %[[B_ADDR]] |
| // OGCG: %[[CMP3:.*]] = icmp eq i32 %[[A_VAL2]], %[[B_VAL2]] |
| // OGCG: br i1 %[[CMP3]], label %[[OR_MERGE:.+]], label %[[OR_FALSE:.+]] |
| // OGCG: [[OR_FALSE]]: |
| // OGCG: %[[C_VAL2:.*]] = load i32, ptr %[[C_ADDR]] |
| // OGCG: %[[D_VAL2:.*]] = load i32, ptr %[[D_ADDR]] |
| // OGCG: %[[CMP4:.*]] = icmp eq i32 %[[C_VAL2]], %[[D_VAL2]] |
| // OGCG: br label %[[OR_MERGE]] |
| // OGCG: [[OR_MERGE]]: |
| // OGCG: %[[OR_PHI:.*]] = phi i1 [ true, %[[AND_MERGE]] ], [ %[[CMP4]], %[[OR_FALSE]] ] |
| // OGCG: %[[ZEXT_OR:.*]] = zext i1 %[[OR_PHI]] to i8 |
| // OGCG: store i8 %[[ZEXT_OR]], ptr %[[X]] |
| // OGCG: ret void |
