sub-from-sub.ll | Explore in Territory

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -passes=instcombine %s -S -o - | FileCheck %s

; ((X - Y) - Z)  -->  X - (Y + Z)  because we prefer add's.

declare void @use8(i8)

; Basic test
define i8 @t0(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: @t0(
; CHECK-NEXT:    [[TMP1:%.*]] = add i8 [[Y:%.*]], [[Z:%.*]]
; CHECK-NEXT:    [[R:%.*]] = sub i8 [[X:%.*]], [[TMP1]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %i0 = sub i8 %x, %y
  %r = sub i8 %i0, %z
  ret i8 %r
}

; NSW/NUW flags are propagated
define i8 @t1_flags(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: @t1_flags(
; CHECK-NEXT:    [[TMP1:%.*]] = add nuw nsw i8 [[Y:%.*]], [[Z:%.*]]
; CHECK-NEXT:    [[R:%.*]] = sub nuw nsw i8 [[X:%.*]], [[TMP1]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %o0 = sub nuw nsw i8 %x, %y
  %r = sub nuw nsw i8 %o0, %z
  ret i8 %r
}

; NUW flags are propagated
define i8 @t1_flags_nuw_only(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: @t1_flags_nuw_only(
; CHECK-NEXT:    [[TMP1:%.*]] = add nuw i8 [[Y:%.*]], [[Z:%.*]]
; CHECK-NEXT:    [[R:%.*]] = sub nuw i8 [[X:%.*]], [[TMP1]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %o0 = sub nuw i8 %x, %y
  %r = sub nuw i8 %o0, %z
  ret i8 %r
}

; Negative tests
define i8 @t1_flags_sub_nsw_sub(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: @t1_flags_sub_nsw_sub(
; CHECK-NEXT:    [[TMP1:%.*]] = add i8 [[Y:%.*]], [[Z:%.*]]
; CHECK-NEXT:    [[R:%.*]] = sub i8 [[X:%.*]], [[TMP1]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %o0 = sub nsw i8 %x, %y
  %r = sub i8 %o0, %z
  ret i8 %r
}

define i8 @t1_flags_nuw_first(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: @t1_flags_nuw_first(
; CHECK-NEXT:    [[TMP1:%.*]] = add i8 [[Y:%.*]], [[Z:%.*]]
; CHECK-NEXT:    [[R:%.*]] = sub i8 [[X:%.*]], [[TMP1]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %o0 = sub nuw i8 %x, %y
  %r = sub i8 %o0, %z
  ret i8 %r
}

define i8 @t1_flags_nuw_second(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: @t1_flags_nuw_second(
; CHECK-NEXT:    [[TMP1:%.*]] = add i8 [[Y:%.*]], [[Z:%.*]]
; CHECK-NEXT:    [[R:%.*]] = sub i8 [[X:%.*]], [[TMP1]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %o0 = sub i8 %x, %y
  %r = sub nuw i8 %o0, %z
  ret i8 %r
}

define i8 @t1_flags_nuw_nsw_first(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: @t1_flags_nuw_nsw_first(
; CHECK-NEXT:    [[TMP1:%.*]] = add i8 [[Y:%.*]], [[Z:%.*]]
; CHECK-NEXT:    [[R:%.*]] = sub i8 [[X:%.*]], [[TMP1]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %o0 = sub nuw nsw i8 %x, %y
  %r = sub i8 %o0, %z
  ret i8 %r
}

define i8 @t1_flags_nuw_nsw_second(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: @t1_flags_nuw_nsw_second(
; CHECK-NEXT:    [[TMP1:%.*]] = add i8 [[Y:%.*]], [[Z:%.*]]
; CHECK-NEXT:    [[R:%.*]] = sub i8 [[X:%.*]], [[TMP1]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %o0 = sub i8 %x, %y
  %r = sub nuw nsw i8 %o0, %z
  ret i8 %r
}

; The inner sub must have single use.
define i8 @n2(i8 %x, i8 %y, i8 %z) {
; CHECK-LABEL: @n2(
; CHECK-NEXT:    [[I0:%.*]] = sub i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT:    call void @use8(i8 [[I0]])
; CHECK-NEXT:    [[R:%.*]] = sub i8 [[I0]], [[Z:%.*]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %i0 = sub i8 %x, %y ; extra use
  call void @use8(i8 %i0)
  %r = sub i8 %i0, %z
  ret i8 %r
}

; What if some operand is constant?

define i8 @t3_c0(i8 %y, i8 %z) {
; CHECK-LABEL: @t3_c0(
; CHECK-NEXT:    [[TMP1:%.*]] = add i8 [[Y:%.*]], [[Z:%.*]]
; CHECK-NEXT:    [[R:%.*]] = sub i8 42, [[TMP1]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %i0 = sub i8 42, %y
  %r = sub i8 %i0, %z
  ret i8 %r
}

define i8 @t4_c1(i8 %x, i8 %z) {
; CHECK-LABEL: @t4_c1(
; CHECK-NEXT:    [[I0:%.*]] = add i8 [[X:%.*]], -42
; CHECK-NEXT:    [[R:%.*]] = sub i8 [[I0]], [[Z:%.*]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %i0 = sub i8 %x, 42
  %r = sub i8 %i0, %z
  ret i8 %r
}

define i8 @t5_c2(i8 %x, i8 %y) {
; CHECK-LABEL: @t5_c2(
; CHECK-NEXT:    [[I0:%.*]] = sub i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT:    [[R:%.*]] = add i8 [[I0]], -42
; CHECK-NEXT:    ret i8 [[R]]
;
  %i0 = sub i8 %x, %y
  %r = sub i8 %i0, 42
  ret i8 %r
}

; What if some operand is constant and there was extra use?

define i8 @t6_c0_extrause(i8 %y, i8 %z) {
; CHECK-LABEL: @t6_c0_extrause(
; CHECK-NEXT:    [[I0:%.*]] = sub i8 42, [[Y:%.*]]
; CHECK-NEXT:    call void @use8(i8 [[I0]])
; CHECK-NEXT:    [[R:%.*]] = sub i8 [[I0]], [[Z:%.*]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %i0 = sub i8 42, %y
  call void @use8(i8 %i0)
  %r = sub i8 %i0, %z
  ret i8 %r
}

define i8 @t7_c1_extrause(i8 %x, i8 %z) {
; CHECK-LABEL: @t7_c1_extrause(
; CHECK-NEXT:    [[I0:%.*]] = add i8 [[X:%.*]], -42
; CHECK-NEXT:    call void @use8(i8 [[I0]])
; CHECK-NEXT:    [[R:%.*]] = sub i8 [[I0]], [[Z:%.*]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %i0 = sub i8 %x, 42
  call void @use8(i8 %i0)
  %r = sub i8 %i0, %z
  ret i8 %r
}

define i8 @t8_c2_extrause(i8 %x, i8 %y) {
; CHECK-LABEL: @t8_c2_extrause(
; CHECK-NEXT:    [[I0:%.*]] = sub i8 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT:    call void @use8(i8 [[I0]])
; CHECK-NEXT:    [[R:%.*]] = add i8 [[I0]], -42
; CHECK-NEXT:    ret i8 [[R]]
;
  %i0 = sub i8 %x, %y
  call void @use8(i8 %i0)
  %r = sub i8 %i0, 42
  ret i8 %r
}

; What if two operands are constants?

define i8 @t9_c0_c2(i8 %y, i8 %z) {
; CHECK-LABEL: @t9_c0_c2(
; CHECK-NEXT:    [[R:%.*]] = sub i8 18, [[Y:%.*]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %i0 = sub i8 42, %y
  %r = sub i8 %i0, 24
  ret i8 %r
}

define i8 @t10_c1_c2(i8 %x, i8 %z) {
; CHECK-LABEL: @t10_c1_c2(
; CHECK-NEXT:    [[R:%.*]] = add i8 [[X:%.*]], -66
; CHECK-NEXT:    ret i8 [[R]]
;
  %i0 = sub i8 %x, 42
  %r = sub i8 %i0, 24
  ret i8 %r
}

; What if two operands are constants and there was extra use?

define i8 @t11_c0_c2_extrause(i8 %y, i8 %z) {
; CHECK-LABEL: @t11_c0_c2_extrause(
; CHECK-NEXT:    [[I0:%.*]] = sub i8 42, [[Y:%.*]]
; CHECK-NEXT:    call void @use8(i8 [[I0]])
; CHECK-NEXT:    [[R:%.*]] = sub i8 18, [[Y]]
; CHECK-NEXT:    ret i8 [[R]]
;
  %i0 = sub i8 42, %y
  call void @use8(i8 %i0)
  %r = sub i8 %i0, 24
  ret i8 %r
}

define i8 @t12_c1_c2_exrause(i8 %x, i8 %z) {
; CHECK-LABEL: @t12_c1_c2_exrause(
; CHECK-NEXT:    [[I0:%.*]] = add i8 [[X:%.*]], -42
; CHECK-NEXT:    call void @use8(i8 [[I0]])
; CHECK-NEXT:    [[R:%.*]] = add i8 [[X]], -66
; CHECK-NEXT:    ret i8 [[R]]
;
  %i0 = sub i8 %x, 42
  call void @use8(i8 %i0)
  %r = sub i8 %i0, 24
  ret i8 %r
}

; PR49870
@g0 = external global i8, align 1
@g1 = external global i8, align 1
define i32 @constantexpr0(i32 %x, ptr %y) unnamed_addr {
; CHECK-LABEL: @constantexpr0(
; CHECK-NEXT:    [[I0:%.*]] = add i32 [[X:%.*]], ptrtoint (ptr @g0 to i32)
; CHECK-NEXT:    [[R:%.*]] = sub i32 0, [[I0]]
; CHECK-NEXT:    ret i32 [[R]]
;
  %i0 = add i32 %x, ptrtoint (ptr @g0 to i32)
  %r = sub i32 0, %i0
  ret i32 %r
}
define i32 @constantexpr1(i32 %x, ptr %y) unnamed_addr {
; CHECK-LABEL: @constantexpr1(
; CHECK-NEXT:    [[I0:%.*]] = add i32 [[X:%.*]], 42
; CHECK-NEXT:    [[R:%.*]] = sub i32 ptrtoint (ptr @g1 to i32), [[I0]]
; CHECK-NEXT:    ret i32 [[R]]
;
  %i0 = add i32 %x, 42
  %r = sub i32 ptrtoint (ptr @g1 to i32), %i0
  ret i32 %r
}
define i32 @constantexpr2(i32 %x, ptr %y) unnamed_addr {
; CHECK-LABEL: @constantexpr2(
; CHECK-NEXT:    [[I0:%.*]] = add i32 [[X:%.*]], ptrtoint (ptr @g0 to i32)
; CHECK-NEXT:    [[R:%.*]] = sub i32 ptrtoint (ptr @g1 to i32), [[I0]]
; CHECK-NEXT:    ret i32 [[R]]
;
  %i0 = add i32 %x, ptrtoint (ptr @g0 to i32)
  %r = sub i32 ptrtoint (ptr @g1 to i32), %i0
  ret i32 %r
}

define i64 @pr49870(i64 %x) {
; CHECK-LABEL: @pr49870(
; CHECK-NEXT:    [[I0:%.*]] = xor i64 [[X:%.*]], -1
; CHECK-NEXT:    [[R:%.*]] = add i64 [[I0]], ptrtoint (ptr @g0 to i64)
; CHECK-NEXT:    ret i64 [[R]]
;
  %i0 = xor i64 %x, -1
  %r = add i64 %i0, ptrtoint (ptr @g0 to i64)
  ret i64 %r
}
llvm/llvm/test/Transforms/InstCombine/sub-from-sub.ll
