derek.holloway
7502bf64a4
CodeQL / Analyze (actions) (push) Canceled after 0s
CodeQL / Analyze (python) (push) Canceled after 0s
pre-commit / pre-commit (push) Canceled after 0s
Multi-Arch CI / setup (push) Canceled after 0s
Publish build_manylinux_x86_64 images / publish_build_manylinux_x86_64 (push) Canceled after 0s
Setup (Multi-Arch) / setup (push) Canceled after 0s
Multi-Arch CI / Linux::${{ fromJSON(needs.setup.outputs.linux_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubi10 image / publish_no_rocm_image_ubi10 (push) Canceled after 0s
Multi-Arch CI / Windows::${{ fromJSON(needs.setup.outputs.windows_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Multi-Arch CI / Manifest Diff (push) Canceled after 0s
TheRock Manifest Diff Report / Generate Manifest Diff Report (push) Canceled after 0s
Multi-Arch CI / CI Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_ocl_rt images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_rocgdb images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Unit Tests / Unit Tests :: ubuntu-24.04 (push) Canceled after 0s
Unit Tests / Unit Tests :: windows-2022 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_media (push) Canceled after 0s
Unit Tests / Unit Tests Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_openmpi (push) Canceled after 0s
1538 lines
61 KiB
LLVM
1538 lines
61 KiB
LLVM
; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
|
|
; RUN: llc < %s -mtriple=x86_64-unknown -mattr=+ndd -verify-machineinstrs --show-mc-encoding | FileCheck %s --check-prefixes=CHECK,NDD
|
|
; RUN: llc < %s -mtriple=x86_64-unknown -mattr=+ndd,+prefer-ndd-imm -verify-machineinstrs --show-mc-encoding | FileCheck %s --check-prefixes=CHECK,IMM,IMMONLY
|
|
; RUN: llc < %s -mtriple=x86_64-unknown -mattr=+ndd,+prefer-ndd-mem -verify-machineinstrs --show-mc-encoding | FileCheck %s --check-prefixes=CHECK,MEM,MEMONLY
|
|
; RUN: llc < %s -mtriple=x86_64-unknown -mattr=+ndd,+prefer-ndd-imm,+prefer-ndd-mem -verify-machineinstrs --show-mc-encoding | FileCheck %s --check-prefixes=CHECK,IMM,MEM,BOTH
|
|
; RUN: llc < %s -mtriple=x86_64-unknown -mattr=+ndd,nf -verify-machineinstrs --show-mc-encoding | FileCheck --check-prefix=NF %s
|
|
; RUN: llc < %s -mtriple=x86_64-unknown -mattr=+ndd,nf -x86-enable-apx-for-relocation=true -verify-machineinstrs --show-mc-encoding | FileCheck --check-prefix=NF %s
|
|
|
|
define i8 @add8rr(i8 noundef %a, i8 noundef %b) {
|
|
; CHECK-LABEL: add8rr:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addb %sil, %dil, %al # encoding: [0x62,0xf4,0x7c,0x18,0x00,0xf7]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add8rr:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: {nf} addb %sil, %dil, %al # EVEX TO EVEX Compression encoding: [0x62,0xf4,0x7c,0x1c,0x00,0xf7]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = add i8 %a, %b
|
|
ret i8 %add
|
|
}
|
|
|
|
define i16 @add16rr(i16 noundef %a, i16 noundef %b) {
|
|
; CHECK-LABEL: add16rr:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addw %si, %di, %ax # encoding: [0x62,0xf4,0x7d,0x18,0x01,0xf7]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add16rr:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: {nf} addw %si, %di, %ax # EVEX TO EVEX Compression encoding: [0x62,0xf4,0x7d,0x1c,0x01,0xf7]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = add i16 %a, %b
|
|
ret i16 %add
|
|
}
|
|
|
|
define i32 @add32rr(i32 noundef %a, i32 noundef %b) {
|
|
; CHECK-LABEL: add32rr:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: leal (%rdi,%rsi), %eax # encoding: [0x8d,0x04,0x37]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add32rr:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: leal (%rdi,%rsi), %eax # encoding: [0x8d,0x04,0x37]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = add i32 %a, %b
|
|
ret i32 %add
|
|
}
|
|
|
|
define i64 @add64rr(i64 noundef %a, i64 noundef %b) {
|
|
; CHECK-LABEL: add64rr:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: leaq (%rdi,%rsi), %rax # encoding: [0x48,0x8d,0x04,0x37]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add64rr:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: leaq (%rdi,%rsi), %rax # encoding: [0x48,0x8d,0x04,0x37]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = add i64 %a, %b
|
|
ret i64 %add
|
|
}
|
|
|
|
define i8 @add8rm(i8 noundef %a, ptr %ptr) {
|
|
; NDD-LABEL: add8rm:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movl %edi, %eax # encoding: [0x89,0xf8]
|
|
; NDD-NEXT: addb (%rsi), %al # encoding: [0x02,0x06]
|
|
; NDD-NEXT: # kill: def $al killed $al killed $eax
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add8rm:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movl %edi, %eax # encoding: [0x89,0xf8]
|
|
; IMMONLY-NEXT: addb (%rsi), %al # encoding: [0x02,0x06]
|
|
; IMMONLY-NEXT: # kill: def $al killed $al killed $eax
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: add8rm:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addb (%rsi), %dil, %al # encoding: [0x62,0xf4,0x7c,0x18,0x02,0x3e]
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add8rm:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movl %edi, %eax # encoding: [0x89,0xf8]
|
|
; NF-NEXT: addb (%rsi), %al # encoding: [0x02,0x06]
|
|
; NF-NEXT: # kill: def $al killed $al killed $eax
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%b = load i8, ptr %ptr
|
|
%add = add i8 %a, %b
|
|
ret i8 %add
|
|
}
|
|
|
|
define i16 @add16rm(i16 noundef %a, ptr %ptr) {
|
|
; NDD-LABEL: add16rm:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movl %edi, %eax # encoding: [0x89,0xf8]
|
|
; NDD-NEXT: addw (%rsi), %ax # encoding: [0x66,0x03,0x06]
|
|
; NDD-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add16rm:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movl %edi, %eax # encoding: [0x89,0xf8]
|
|
; IMMONLY-NEXT: addw (%rsi), %ax # encoding: [0x66,0x03,0x06]
|
|
; IMMONLY-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: add16rm:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addw (%rsi), %di, %ax # encoding: [0x62,0xf4,0x7d,0x18,0x03,0x3e]
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add16rm:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movl %edi, %eax # encoding: [0x89,0xf8]
|
|
; NF-NEXT: addw (%rsi), %ax # encoding: [0x66,0x03,0x06]
|
|
; NF-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%b = load i16, ptr %ptr
|
|
%add = add i16 %a, %b
|
|
ret i16 %add
|
|
}
|
|
|
|
define i32 @add32rm(i32 noundef %a, ptr %ptr) {
|
|
; NDD-LABEL: add32rm:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movl %edi, %eax # encoding: [0x89,0xf8]
|
|
; NDD-NEXT: addl (%rsi), %eax # encoding: [0x03,0x06]
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add32rm:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movl %edi, %eax # encoding: [0x89,0xf8]
|
|
; IMMONLY-NEXT: addl (%rsi), %eax # encoding: [0x03,0x06]
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: add32rm:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addl (%rsi), %edi, %eax # encoding: [0x62,0xf4,0x7c,0x18,0x03,0x3e]
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add32rm:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movl %edi, %eax # encoding: [0x89,0xf8]
|
|
; NF-NEXT: addl (%rsi), %eax # encoding: [0x03,0x06]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%b = load i32, ptr %ptr
|
|
%add = add i32 %a, %b
|
|
ret i32 %add
|
|
}
|
|
|
|
define i64 @add64rm(i64 noundef %a, ptr %ptr) {
|
|
; NDD-LABEL: add64rm:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movq %rdi, %rax # encoding: [0x48,0x89,0xf8]
|
|
; NDD-NEXT: addq (%rsi), %rax # encoding: [0x48,0x03,0x06]
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add64rm:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movq %rdi, %rax # encoding: [0x48,0x89,0xf8]
|
|
; IMMONLY-NEXT: addq (%rsi), %rax # encoding: [0x48,0x03,0x06]
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: add64rm:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addq (%rsi), %rdi, %rax # encoding: [0x62,0xf4,0xfc,0x18,0x03,0x3e]
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add64rm:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movq %rdi, %rax # encoding: [0x48,0x89,0xf8]
|
|
; NF-NEXT: addq (%rsi), %rax # encoding: [0x48,0x03,0x06]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%b = load i64, ptr %ptr
|
|
%add = add i64 %a, %b
|
|
ret i64 %add
|
|
}
|
|
|
|
define i16 @add16ri8(i16 noundef %a) {
|
|
; CHECK-LABEL: add16ri8:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addw $123, %di, %ax # encoding: [0x62,0xf4,0x7d,0x18,0x83,0xc7,0x7b]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add16ri8:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: {nf} addw $123, %di, %ax # EVEX TO EVEX Compression encoding: [0x62,0xf4,0x7d,0x1c,0x83,0xc7,0x7b]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = add i16 %a, 123
|
|
ret i16 %add
|
|
}
|
|
|
|
define i32 @add32ri8(i32 noundef %a) {
|
|
; CHECK-LABEL: add32ri8:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: leal 123(%rdi), %eax # encoding: [0x8d,0x47,0x7b]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add32ri8:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: leal 123(%rdi), %eax # encoding: [0x8d,0x47,0x7b]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = add i32 %a, 123
|
|
ret i32 %add
|
|
}
|
|
|
|
define i64 @add64ri8(i64 noundef %a) {
|
|
; CHECK-LABEL: add64ri8:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: leaq 123(%rdi), %rax # encoding: [0x48,0x8d,0x47,0x7b]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add64ri8:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: leaq 123(%rdi), %rax # encoding: [0x48,0x8d,0x47,0x7b]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = add i64 %a, 123
|
|
ret i64 %add
|
|
}
|
|
|
|
define i8 @add8ri(i8 noundef %a) {
|
|
; CHECK-LABEL: add8ri:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addb $123, %dil, %al # encoding: [0x62,0xf4,0x7c,0x18,0x80,0xc7,0x7b]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add8ri:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: {nf} addb $123, %dil, %al # EVEX TO EVEX Compression encoding: [0x62,0xf4,0x7c,0x1c,0x80,0xc7,0x7b]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = add i8 %a, 123
|
|
ret i8 %add
|
|
}
|
|
|
|
define i16 @add16ri(i16 noundef %a) {
|
|
; CHECK-LABEL: add16ri:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addw $1234, %di, %ax # encoding: [0x62,0xf4,0x7d,0x18,0x81,0xc7,0xd2,0x04]
|
|
; CHECK-NEXT: # imm = 0x4D2
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add16ri:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: {nf} addw $1234, %di, %ax # EVEX TO EVEX Compression encoding: [0x62,0xf4,0x7d,0x1c,0x81,0xc7,0xd2,0x04]
|
|
; NF-NEXT: # imm = 0x4D2
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = add i16 %a, 1234
|
|
ret i16 %add
|
|
}
|
|
|
|
define i32 @add32ri(i32 noundef %a) {
|
|
; CHECK-LABEL: add32ri:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: leal 123456(%rdi), %eax # encoding: [0x8d,0x87,0x40,0xe2,0x01,0x00]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add32ri:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: leal 123456(%rdi), %eax # encoding: [0x8d,0x87,0x40,0xe2,0x01,0x00]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = add i32 %a, 123456
|
|
ret i32 %add
|
|
}
|
|
|
|
define i64 @add64ri(i64 noundef %a) {
|
|
; CHECK-LABEL: add64ri:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: leaq 123456(%rdi), %rax # encoding: [0x48,0x8d,0x87,0x40,0xe2,0x01,0x00]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add64ri:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: leaq 123456(%rdi), %rax # encoding: [0x48,0x8d,0x87,0x40,0xe2,0x01,0x00]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = add i64 %a, 123456
|
|
ret i64 %add
|
|
}
|
|
|
|
define i8 @add8mr(ptr %a, i8 noundef %b) {
|
|
; NDD-LABEL: add8mr:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movl %esi, %eax # encoding: [0x89,0xf0]
|
|
; NDD-NEXT: addb (%rdi), %al # encoding: [0x02,0x07]
|
|
; NDD-NEXT: # kill: def $al killed $al killed $eax
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add8mr:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movl %esi, %eax # encoding: [0x89,0xf0]
|
|
; IMMONLY-NEXT: addb (%rdi), %al # encoding: [0x02,0x07]
|
|
; IMMONLY-NEXT: # kill: def $al killed $al killed $eax
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: add8mr:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addb (%rdi), %sil, %al # encoding: [0x62,0xf4,0x7c,0x18,0x02,0x37]
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add8mr:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movl %esi, %eax # encoding: [0x89,0xf0]
|
|
; NF-NEXT: addb (%rdi), %al # encoding: [0x02,0x07]
|
|
; NF-NEXT: # kill: def $al killed $al killed $eax
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i8, ptr %a
|
|
%add = add nsw i8 %t, %b
|
|
ret i8 %add
|
|
}
|
|
|
|
define i16 @add16mr(ptr %a, i16 noundef %b) {
|
|
; NDD-LABEL: add16mr:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movl %esi, %eax # encoding: [0x89,0xf0]
|
|
; NDD-NEXT: addw (%rdi), %ax # encoding: [0x66,0x03,0x07]
|
|
; NDD-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add16mr:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movl %esi, %eax # encoding: [0x89,0xf0]
|
|
; IMMONLY-NEXT: addw (%rdi), %ax # encoding: [0x66,0x03,0x07]
|
|
; IMMONLY-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: add16mr:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addw (%rdi), %si, %ax # encoding: [0x62,0xf4,0x7d,0x18,0x03,0x37]
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add16mr:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movl %esi, %eax # encoding: [0x89,0xf0]
|
|
; NF-NEXT: addw (%rdi), %ax # encoding: [0x66,0x03,0x07]
|
|
; NF-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i16, ptr %a
|
|
%add = add nsw i16 %t, %b
|
|
ret i16 %add
|
|
}
|
|
|
|
define i32 @add32mr(ptr %a, i32 noundef %b) {
|
|
; NDD-LABEL: add32mr:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movl %esi, %eax # encoding: [0x89,0xf0]
|
|
; NDD-NEXT: addl (%rdi), %eax # encoding: [0x03,0x07]
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add32mr:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movl %esi, %eax # encoding: [0x89,0xf0]
|
|
; IMMONLY-NEXT: addl (%rdi), %eax # encoding: [0x03,0x07]
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: add32mr:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addl (%rdi), %esi, %eax # encoding: [0x62,0xf4,0x7c,0x18,0x03,0x37]
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add32mr:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movl %esi, %eax # encoding: [0x89,0xf0]
|
|
; NF-NEXT: addl (%rdi), %eax # encoding: [0x03,0x07]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i32, ptr %a
|
|
%add = add nsw i32 %t, %b
|
|
ret i32 %add
|
|
}
|
|
|
|
define i64 @add64mr(ptr %a, i64 noundef %b) {
|
|
; NDD-LABEL: add64mr:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movq %rsi, %rax # encoding: [0x48,0x89,0xf0]
|
|
; NDD-NEXT: addq (%rdi), %rax # encoding: [0x48,0x03,0x07]
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add64mr:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movq %rsi, %rax # encoding: [0x48,0x89,0xf0]
|
|
; IMMONLY-NEXT: addq (%rdi), %rax # encoding: [0x48,0x03,0x07]
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: add64mr:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addq (%rdi), %rsi, %rax # encoding: [0x62,0xf4,0xfc,0x18,0x03,0x37]
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add64mr:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movq %rsi, %rax # encoding: [0x48,0x89,0xf0]
|
|
; NF-NEXT: addq (%rdi), %rax # encoding: [0x48,0x03,0x07]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i64, ptr %a
|
|
%add = add nsw i64 %t, %b
|
|
ret i64 %add
|
|
}
|
|
|
|
define i16 @add16mi8(ptr %a) {
|
|
; NDD-LABEL: add16mi8:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movzwl (%rdi), %eax # encoding: [0x0f,0xb7,0x07]
|
|
; NDD-NEXT: addw $123, %ax # EVEX TO LEGACY Compression encoding: [0x66,0x83,0xc0,0x7b]
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add16mi8:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movzwl (%rdi), %eax # encoding: [0x0f,0xb7,0x07]
|
|
; IMMONLY-NEXT: addw $123, %ax # EVEX TO LEGACY Compression encoding: [0x66,0x83,0xc0,0x7b]
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: add16mi8:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addw $123, (%rdi), %ax # encoding: [0x62,0xf4,0x7d,0x18,0x83,0x07,0x7b]
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add16mi8:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movzwl (%rdi), %eax # encoding: [0x0f,0xb7,0x07]
|
|
; NF-NEXT: addw $123, %ax # EVEX TO LEGACY Compression encoding: [0x66,0x83,0xc0,0x7b]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i16, ptr %a
|
|
%add = add nsw i16 %t, 123
|
|
ret i16 %add
|
|
}
|
|
|
|
define i32 @add32mi8(ptr %a) {
|
|
; NDD-LABEL: add32mi8:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movl (%rdi), %eax # encoding: [0x8b,0x07]
|
|
; NDD-NEXT: addl $123, %eax # EVEX TO LEGACY Compression encoding: [0x83,0xc0,0x7b]
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add32mi8:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movl (%rdi), %eax # encoding: [0x8b,0x07]
|
|
; IMMONLY-NEXT: addl $123, %eax # EVEX TO LEGACY Compression encoding: [0x83,0xc0,0x7b]
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: add32mi8:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addl $123, (%rdi), %eax # encoding: [0x62,0xf4,0x7c,0x18,0x83,0x07,0x7b]
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add32mi8:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movl (%rdi), %eax # encoding: [0x8b,0x07]
|
|
; NF-NEXT: addl $123, %eax # EVEX TO LEGACY Compression encoding: [0x83,0xc0,0x7b]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i32, ptr %a
|
|
%add = add nsw i32 %t, 123
|
|
ret i32 %add
|
|
}
|
|
|
|
define i64 @add64mi8(ptr %a) {
|
|
; NDD-LABEL: add64mi8:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movq (%rdi), %rax # encoding: [0x48,0x8b,0x07]
|
|
; NDD-NEXT: addq $123, %rax # encoding: [0x48,0x83,0xc0,0x7b]
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add64mi8:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movq (%rdi), %rax # encoding: [0x48,0x8b,0x07]
|
|
; IMMONLY-NEXT: addq $123, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x83,0xc0,0x7b]
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEMONLY-LABEL: add64mi8:
|
|
; MEMONLY: # %bb.0: # %entry
|
|
; MEMONLY-NEXT: movq (%rdi), %rax # encoding: [0x48,0x8b,0x07]
|
|
; MEMONLY-NEXT: addq $123, %rax # encoding: [0x48,0x83,0xc0,0x7b]
|
|
; MEMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; BOTH-LABEL: add64mi8:
|
|
; BOTH: # %bb.0: # %entry
|
|
; BOTH-NEXT: addq $123, (%rdi), %rax # encoding: [0x62,0xf4,0xfc,0x18,0x83,0x07,0x7b]
|
|
; BOTH-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add64mi8:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movq (%rdi), %rax # encoding: [0x48,0x8b,0x07]
|
|
; NF-NEXT: addq $123, %rax # encoding: [0x48,0x83,0xc0,0x7b]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i64, ptr %a
|
|
%add = add nsw i64 %t, 123
|
|
ret i64 %add
|
|
}
|
|
|
|
define i8 @add8mi(ptr %a) {
|
|
; NDD-LABEL: add8mi:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movzbl (%rdi), %eax # encoding: [0x0f,0xb6,0x07]
|
|
; NDD-NEXT: addb $123, %al # EVEX TO LEGACY Compression encoding: [0x04,0x7b]
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add8mi:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movzbl (%rdi), %eax # encoding: [0x0f,0xb6,0x07]
|
|
; IMMONLY-NEXT: addb $123, %al # EVEX TO LEGACY Compression encoding: [0x04,0x7b]
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: add8mi:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addb $123, (%rdi), %al # encoding: [0x62,0xf4,0x7c,0x18,0x80,0x07,0x7b]
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add8mi:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movzbl (%rdi), %eax # encoding: [0x0f,0xb6,0x07]
|
|
; NF-NEXT: addb $123, %al # EVEX TO LEGACY Compression encoding: [0x04,0x7b]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i8, ptr %a
|
|
%add = add nsw i8 %t, 123
|
|
ret i8 %add
|
|
}
|
|
|
|
define i16 @add16mi(ptr %a) {
|
|
; NDD-LABEL: add16mi:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movzwl (%rdi), %eax # encoding: [0x0f,0xb7,0x07]
|
|
; NDD-NEXT: addw $1234, %ax # EVEX TO LEGACY Compression encoding: [0x66,0x05,0xd2,0x04]
|
|
; NDD-NEXT: # imm = 0x4D2
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add16mi:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movzwl (%rdi), %eax # encoding: [0x0f,0xb7,0x07]
|
|
; IMMONLY-NEXT: addw $1234, %ax # EVEX TO LEGACY Compression encoding: [0x66,0x05,0xd2,0x04]
|
|
; IMMONLY-NEXT: # imm = 0x4D2
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: add16mi:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addw $1234, (%rdi), %ax # encoding: [0x62,0xf4,0x7d,0x18,0x81,0x07,0xd2,0x04]
|
|
; MEM-NEXT: # imm = 0x4D2
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add16mi:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movzwl (%rdi), %eax # encoding: [0x0f,0xb7,0x07]
|
|
; NF-NEXT: addw $1234, %ax # EVEX TO LEGACY Compression encoding: [0x66,0x05,0xd2,0x04]
|
|
; NF-NEXT: # imm = 0x4D2
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i16, ptr %a
|
|
%add = add nsw i16 %t, 1234
|
|
ret i16 %add
|
|
}
|
|
|
|
define i32 @add32mi(ptr %a) {
|
|
; NDD-LABEL: add32mi:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movl (%rdi), %eax # encoding: [0x8b,0x07]
|
|
; NDD-NEXT: addl $123456, %eax # EVEX TO LEGACY Compression encoding: [0x05,0x40,0xe2,0x01,0x00]
|
|
; NDD-NEXT: # imm = 0x1E240
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add32mi:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movl (%rdi), %eax # encoding: [0x8b,0x07]
|
|
; IMMONLY-NEXT: addl $123456, %eax # EVEX TO LEGACY Compression encoding: [0x05,0x40,0xe2,0x01,0x00]
|
|
; IMMONLY-NEXT: # imm = 0x1E240
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: add32mi:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addl $123456, (%rdi), %eax # encoding: [0x62,0xf4,0x7c,0x18,0x81,0x07,0x40,0xe2,0x01,0x00]
|
|
; MEM-NEXT: # imm = 0x1E240
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add32mi:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movl (%rdi), %eax # encoding: [0x8b,0x07]
|
|
; NF-NEXT: addl $123456, %eax # EVEX TO LEGACY Compression encoding: [0x05,0x40,0xe2,0x01,0x00]
|
|
; NF-NEXT: # imm = 0x1E240
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i32, ptr %a
|
|
%add = add nsw i32 %t, 123456
|
|
ret i32 %add
|
|
}
|
|
|
|
define i64 @add64mi(ptr %a) {
|
|
; NDD-LABEL: add64mi:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: movq (%rdi), %rax # encoding: [0x48,0x8b,0x07]
|
|
; NDD-NEXT: addq $123456, %rax # encoding: [0x48,0x05,0x40,0xe2,0x01,0x00]
|
|
; NDD-NEXT: # imm = 0x1E240
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: add64mi:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: movq (%rdi), %rax # encoding: [0x48,0x8b,0x07]
|
|
; IMMONLY-NEXT: addq $123456, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x05,0x40,0xe2,0x01,0x00]
|
|
; IMMONLY-NEXT: # imm = 0x1E240
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: add64mi:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addq $123456, (%rdi), %rax # encoding: [0x62,0xf4,0xfc,0x18,0x81,0x07,0x40,0xe2,0x01,0x00]
|
|
; MEM-NEXT: # imm = 0x1E240
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add64mi:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: movq (%rdi), %rax # encoding: [0x48,0x8b,0x07]
|
|
; NF-NEXT: addq $123456, %rax # encoding: [0x48,0x05,0x40,0xe2,0x01,0x00]
|
|
; NF-NEXT: # imm = 0x1E240
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i64, ptr %a
|
|
%add = add nsw i64 %t, 123456
|
|
ret i64 %add
|
|
}
|
|
|
|
declare i8 @llvm.uadd.sat.i8(i8, i8)
|
|
declare i16 @llvm.uadd.sat.i16(i16, i16)
|
|
declare i32 @llvm.uadd.sat.i32(i32, i32)
|
|
declare i64 @llvm.uadd.sat.i64(i64, i64)
|
|
|
|
define i8 @addflag8rr(i8 noundef %a, i8 noundef %b) {
|
|
; CHECK-LABEL: addflag8rr:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addb %sil, %dil, %al # encoding: [0x62,0xf4,0x7c,0x18,0x00,0xf7]
|
|
; CHECK-NEXT: movzbl %al, %eax # encoding: [0x0f,0xb6,0xc0]
|
|
; CHECK-NEXT: movl $255, %ecx # encoding: [0xb9,0xff,0x00,0x00,0x00]
|
|
; CHECK-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; CHECK-NEXT: # kill: def $al killed $al killed $eax
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag8rr:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addb %sil, %dil, %al # encoding: [0x62,0xf4,0x7c,0x18,0x00,0xf7]
|
|
; NF-NEXT: movzbl %al, %eax # encoding: [0x0f,0xb6,0xc0]
|
|
; NF-NEXT: movl $255, %ecx # encoding: [0xb9,0xff,0x00,0x00,0x00]
|
|
; NF-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; NF-NEXT: # kill: def $al killed $al killed $eax
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = call i8 @llvm.uadd.sat.i8(i8 %a, i8 %b)
|
|
ret i8 %add
|
|
}
|
|
|
|
define i16 @addflag16rr(i16 noundef %a, i16 noundef %b) {
|
|
; CHECK-LABEL: addflag16rr:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addw %si, %di, %ax # encoding: [0x62,0xf4,0x7d,0x18,0x01,0xf7]
|
|
; CHECK-NEXT: movl $65535, %ecx # encoding: [0xb9,0xff,0xff,0x00,0x00]
|
|
; CHECK-NEXT: # imm = 0xFFFF
|
|
; CHECK-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; CHECK-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag16rr:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addw %si, %di, %ax # encoding: [0x62,0xf4,0x7d,0x18,0x01,0xf7]
|
|
; NF-NEXT: movl $65535, %ecx # encoding: [0xb9,0xff,0xff,0x00,0x00]
|
|
; NF-NEXT: # imm = 0xFFFF
|
|
; NF-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; NF-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = call i16 @llvm.uadd.sat.i16(i16 %a, i16 %b)
|
|
ret i16 %add
|
|
}
|
|
|
|
define i32 @addflag32rr(i32 noundef %a, i32 noundef %b) {
|
|
; CHECK-LABEL: addflag32rr:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addl %esi, %edi, %eax # encoding: [0x62,0xf4,0x7c,0x18,0x01,0xf7]
|
|
; CHECK-NEXT: movl $-1, %ecx # encoding: [0xb9,0xff,0xff,0xff,0xff]
|
|
; CHECK-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag32rr:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addl %esi, %edi, %eax # encoding: [0x62,0xf4,0x7c,0x18,0x01,0xf7]
|
|
; NF-NEXT: movl $-1, %ecx # encoding: [0xb9,0xff,0xff,0xff,0xff]
|
|
; NF-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = call i32 @llvm.uadd.sat.i32(i32 %a, i32 %b)
|
|
ret i32 %add
|
|
}
|
|
|
|
define i64 @addflag64rr(i64 noundef %a, i64 noundef %b) {
|
|
; CHECK-LABEL: addflag64rr:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addq %rsi, %rdi, %rax # encoding: [0x62,0xf4,0xfc,0x18,0x01,0xf7]
|
|
; CHECK-NEXT: movq $-1, %rcx # encoding: [0x48,0xc7,0xc1,0xff,0xff,0xff,0xff]
|
|
; CHECK-NEXT: cmovbq %rcx, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x0f,0x42,0xc1]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag64rr:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addq %rsi, %rdi, %rax # encoding: [0x62,0xf4,0xfc,0x18,0x01,0xf7]
|
|
; NF-NEXT: movq $-1, %rcx # encoding: [0x48,0xc7,0xc1,0xff,0xff,0xff,0xff]
|
|
; NF-NEXT: cmovbq %rcx, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x0f,0x42,0xc1]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = call i64 @llvm.uadd.sat.i64(i64 %a, i64 %b)
|
|
ret i64 %add
|
|
}
|
|
|
|
define i8 @addflag8rm(i8 noundef %a, ptr %b) {
|
|
; NDD-LABEL: addflag8rm:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: addb (%rsi), %dil # encoding: [0x40,0x02,0x3e]
|
|
; NDD-NEXT: movzbl %dil, %eax # encoding: [0x40,0x0f,0xb6,0xc7]
|
|
; NDD-NEXT: movl $255, %ecx # encoding: [0xb9,0xff,0x00,0x00,0x00]
|
|
; NDD-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; NDD-NEXT: # kill: def $al killed $al killed $eax
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: addflag8rm:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: addb (%rsi), %dil # encoding: [0x40,0x02,0x3e]
|
|
; IMMONLY-NEXT: movzbl %dil, %eax # encoding: [0x40,0x0f,0xb6,0xc7]
|
|
; IMMONLY-NEXT: movl $255, %ecx # encoding: [0xb9,0xff,0x00,0x00,0x00]
|
|
; IMMONLY-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; IMMONLY-NEXT: # kill: def $al killed $al killed $eax
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: addflag8rm:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addb (%rsi), %dil, %al # encoding: [0x62,0xf4,0x7c,0x18,0x02,0x3e]
|
|
; MEM-NEXT: movzbl %al, %eax # encoding: [0x0f,0xb6,0xc0]
|
|
; MEM-NEXT: movl $255, %ecx # encoding: [0xb9,0xff,0x00,0x00,0x00]
|
|
; MEM-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; MEM-NEXT: # kill: def $al killed $al killed $eax
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag8rm:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addb (%rsi), %dil # encoding: [0x40,0x02,0x3e]
|
|
; NF-NEXT: movzbl %dil, %eax # encoding: [0x40,0x0f,0xb6,0xc7]
|
|
; NF-NEXT: movl $255, %ecx # encoding: [0xb9,0xff,0x00,0x00,0x00]
|
|
; NF-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; NF-NEXT: # kill: def $al killed $al killed $eax
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t = load i8, ptr %b
|
|
%add = call i8 @llvm.uadd.sat.i8(i8 %a, i8 %t)
|
|
ret i8 %add
|
|
}
|
|
|
|
define i16 @addflag16rm(i16 noundef %a, ptr %b) {
|
|
; NDD-LABEL: addflag16rm:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: addw (%rsi), %di # encoding: [0x66,0x03,0x3e]
|
|
; NDD-NEXT: movl $65535, %eax # encoding: [0xb8,0xff,0xff,0x00,0x00]
|
|
; NDD-NEXT: # imm = 0xFFFF
|
|
; NDD-NEXT: cmovael %edi, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x43,0xc7]
|
|
; NDD-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: addflag16rm:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: addw (%rsi), %di # encoding: [0x66,0x03,0x3e]
|
|
; IMMONLY-NEXT: movl $65535, %eax # encoding: [0xb8,0xff,0xff,0x00,0x00]
|
|
; IMMONLY-NEXT: # imm = 0xFFFF
|
|
; IMMONLY-NEXT: cmovael %edi, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x43,0xc7]
|
|
; IMMONLY-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: addflag16rm:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addw (%rsi), %di, %ax # encoding: [0x62,0xf4,0x7d,0x18,0x03,0x3e]
|
|
; MEM-NEXT: movl $65535, %ecx # encoding: [0xb9,0xff,0xff,0x00,0x00]
|
|
; MEM-NEXT: # imm = 0xFFFF
|
|
; MEM-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; MEM-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag16rm:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addw (%rsi), %di # encoding: [0x66,0x03,0x3e]
|
|
; NF-NEXT: movl $65535, %eax # encoding: [0xb8,0xff,0xff,0x00,0x00]
|
|
; NF-NEXT: # imm = 0xFFFF
|
|
; NF-NEXT: cmovael %edi, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x43,0xc7]
|
|
; NF-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t = load i16, ptr %b
|
|
%add = call i16 @llvm.uadd.sat.i16(i16 %a, i16 %t)
|
|
ret i16 %add
|
|
}
|
|
|
|
define i32 @addflag32rm(i32 noundef %a, ptr %b) {
|
|
; NDD-LABEL: addflag32rm:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: addl (%rsi), %edi # encoding: [0x03,0x3e]
|
|
; NDD-NEXT: movl $-1, %eax # encoding: [0xb8,0xff,0xff,0xff,0xff]
|
|
; NDD-NEXT: cmovael %edi, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x43,0xc7]
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: addflag32rm:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: addl (%rsi), %edi # encoding: [0x03,0x3e]
|
|
; IMMONLY-NEXT: movl $-1, %eax # encoding: [0xb8,0xff,0xff,0xff,0xff]
|
|
; IMMONLY-NEXT: cmovael %edi, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x43,0xc7]
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: addflag32rm:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addl (%rsi), %edi, %eax # encoding: [0x62,0xf4,0x7c,0x18,0x03,0x3e]
|
|
; MEM-NEXT: movl $-1, %ecx # encoding: [0xb9,0xff,0xff,0xff,0xff]
|
|
; MEM-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag32rm:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addl (%rsi), %edi # encoding: [0x03,0x3e]
|
|
; NF-NEXT: movl $-1, %eax # encoding: [0xb8,0xff,0xff,0xff,0xff]
|
|
; NF-NEXT: cmovael %edi, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x43,0xc7]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t = load i32, ptr %b
|
|
%add = call i32 @llvm.uadd.sat.i32(i32 %a, i32 %t)
|
|
ret i32 %add
|
|
}
|
|
|
|
define i64 @addflag64rm(i64 noundef %a, ptr %b) {
|
|
; NDD-LABEL: addflag64rm:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: addq (%rsi), %rdi # encoding: [0x48,0x03,0x3e]
|
|
; NDD-NEXT: movq $-1, %rax # encoding: [0x48,0xc7,0xc0,0xff,0xff,0xff,0xff]
|
|
; NDD-NEXT: cmovaeq %rdi, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x0f,0x43,0xc7]
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: addflag64rm:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: addq (%rsi), %rdi # encoding: [0x48,0x03,0x3e]
|
|
; IMMONLY-NEXT: movq $-1, %rax # encoding: [0x48,0xc7,0xc0,0xff,0xff,0xff,0xff]
|
|
; IMMONLY-NEXT: cmovaeq %rdi, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x0f,0x43,0xc7]
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: addflag64rm:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: addq (%rsi), %rdi, %rax # encoding: [0x62,0xf4,0xfc,0x18,0x03,0x3e]
|
|
; MEM-NEXT: movq $-1, %rcx # encoding: [0x48,0xc7,0xc1,0xff,0xff,0xff,0xff]
|
|
; MEM-NEXT: cmovbq %rcx, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x0f,0x42,0xc1]
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag64rm:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addq (%rsi), %rdi # encoding: [0x48,0x03,0x3e]
|
|
; NF-NEXT: movq $-1, %rax # encoding: [0x48,0xc7,0xc0,0xff,0xff,0xff,0xff]
|
|
; NF-NEXT: cmovaeq %rdi, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x0f,0x43,0xc7]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t = load i64, ptr %b
|
|
%add = call i64 @llvm.uadd.sat.i64(i64 %a, i64 %t)
|
|
ret i64 %add
|
|
}
|
|
|
|
define i16 @addflag16ri8(i16 noundef %a) {
|
|
; CHECK-LABEL: addflag16ri8:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addw $123, %di, %ax # encoding: [0x62,0xf4,0x7d,0x18,0x83,0xc7,0x7b]
|
|
; CHECK-NEXT: movl $65535, %ecx # encoding: [0xb9,0xff,0xff,0x00,0x00]
|
|
; CHECK-NEXT: # imm = 0xFFFF
|
|
; CHECK-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; CHECK-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag16ri8:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addw $123, %di, %ax # encoding: [0x62,0xf4,0x7d,0x18,0x83,0xc7,0x7b]
|
|
; NF-NEXT: movl $65535, %ecx # encoding: [0xb9,0xff,0xff,0x00,0x00]
|
|
; NF-NEXT: # imm = 0xFFFF
|
|
; NF-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; NF-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = call i16 @llvm.uadd.sat.i16(i16 %a, i16 123)
|
|
ret i16 %add
|
|
}
|
|
|
|
define i32 @addflag32ri8(i32 noundef %a) {
|
|
; CHECK-LABEL: addflag32ri8:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addl $123, %edi, %eax # encoding: [0x62,0xf4,0x7c,0x18,0x83,0xc7,0x7b]
|
|
; CHECK-NEXT: movl $-1, %ecx # encoding: [0xb9,0xff,0xff,0xff,0xff]
|
|
; CHECK-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag32ri8:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addl $123, %edi, %eax # encoding: [0x62,0xf4,0x7c,0x18,0x83,0xc7,0x7b]
|
|
; NF-NEXT: movl $-1, %ecx # encoding: [0xb9,0xff,0xff,0xff,0xff]
|
|
; NF-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = call i32 @llvm.uadd.sat.i32(i32 %a, i32 123)
|
|
ret i32 %add
|
|
}
|
|
|
|
define i64 @addflag64ri8(i64 noundef %a) {
|
|
; NDD-LABEL: addflag64ri8:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: addq $123, %rdi # encoding: [0x48,0x83,0xc7,0x7b]
|
|
; NDD-NEXT: movq $-1, %rax # encoding: [0x48,0xc7,0xc0,0xff,0xff,0xff,0xff]
|
|
; NDD-NEXT: cmovaeq %rdi, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x0f,0x43,0xc7]
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMM-LABEL: addflag64ri8:
|
|
; IMM: # %bb.0: # %entry
|
|
; IMM-NEXT: addq $123, %rdi, %rax # encoding: [0x62,0xf4,0xfc,0x18,0x83,0xc7,0x7b]
|
|
; IMM-NEXT: movq $-1, %rcx # encoding: [0x48,0xc7,0xc1,0xff,0xff,0xff,0xff]
|
|
; IMM-NEXT: cmovbq %rcx, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x0f,0x42,0xc1]
|
|
; IMM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEMONLY-LABEL: addflag64ri8:
|
|
; MEMONLY: # %bb.0: # %entry
|
|
; MEMONLY-NEXT: addq $123, %rdi # encoding: [0x48,0x83,0xc7,0x7b]
|
|
; MEMONLY-NEXT: movq $-1, %rax # encoding: [0x48,0xc7,0xc0,0xff,0xff,0xff,0xff]
|
|
; MEMONLY-NEXT: cmovaeq %rdi, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x0f,0x43,0xc7]
|
|
; MEMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag64ri8:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addq $123, %rdi # encoding: [0x48,0x83,0xc7,0x7b]
|
|
; NF-NEXT: movq $-1, %rax # encoding: [0x48,0xc7,0xc0,0xff,0xff,0xff,0xff]
|
|
; NF-NEXT: cmovaeq %rdi, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x0f,0x43,0xc7]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = call i64 @llvm.uadd.sat.i64(i64 %a, i64 123)
|
|
ret i64 %add
|
|
}
|
|
|
|
define i8 @addflag8ri(i8 noundef %a) {
|
|
; CHECK-LABEL: addflag8ri:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addb $123, %dil, %al # encoding: [0x62,0xf4,0x7c,0x18,0x80,0xc7,0x7b]
|
|
; CHECK-NEXT: movzbl %al, %eax # encoding: [0x0f,0xb6,0xc0]
|
|
; CHECK-NEXT: movl $255, %ecx # encoding: [0xb9,0xff,0x00,0x00,0x00]
|
|
; CHECK-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; CHECK-NEXT: # kill: def $al killed $al killed $eax
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag8ri:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addb $123, %dil, %al # encoding: [0x62,0xf4,0x7c,0x18,0x80,0xc7,0x7b]
|
|
; NF-NEXT: movzbl %al, %eax # encoding: [0x0f,0xb6,0xc0]
|
|
; NF-NEXT: movl $255, %ecx # encoding: [0xb9,0xff,0x00,0x00,0x00]
|
|
; NF-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; NF-NEXT: # kill: def $al killed $al killed $eax
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = call i8 @llvm.uadd.sat.i8(i8 %a, i8 123)
|
|
ret i8 %add
|
|
}
|
|
|
|
define i16 @addflag16ri(i16 noundef %a) {
|
|
; CHECK-LABEL: addflag16ri:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addw $1234, %di, %ax # encoding: [0x62,0xf4,0x7d,0x18,0x81,0xc7,0xd2,0x04]
|
|
; CHECK-NEXT: # imm = 0x4D2
|
|
; CHECK-NEXT: movl $65535, %ecx # encoding: [0xb9,0xff,0xff,0x00,0x00]
|
|
; CHECK-NEXT: # imm = 0xFFFF
|
|
; CHECK-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; CHECK-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag16ri:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addw $1234, %di, %ax # encoding: [0x62,0xf4,0x7d,0x18,0x81,0xc7,0xd2,0x04]
|
|
; NF-NEXT: # imm = 0x4D2
|
|
; NF-NEXT: movl $65535, %ecx # encoding: [0xb9,0xff,0xff,0x00,0x00]
|
|
; NF-NEXT: # imm = 0xFFFF
|
|
; NF-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; NF-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = call i16 @llvm.uadd.sat.i16(i16 %a, i16 1234)
|
|
ret i16 %add
|
|
}
|
|
|
|
define i32 @addflag32ri(i32 noundef %a) {
|
|
; CHECK-LABEL: addflag32ri:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addl $123456, %edi, %eax # encoding: [0x62,0xf4,0x7c,0x18,0x81,0xc7,0x40,0xe2,0x01,0x00]
|
|
; CHECK-NEXT: # imm = 0x1E240
|
|
; CHECK-NEXT: movl $-1, %ecx # encoding: [0xb9,0xff,0xff,0xff,0xff]
|
|
; CHECK-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag32ri:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addl $123456, %edi, %eax # encoding: [0x62,0xf4,0x7c,0x18,0x81,0xc7,0x40,0xe2,0x01,0x00]
|
|
; NF-NEXT: # imm = 0x1E240
|
|
; NF-NEXT: movl $-1, %ecx # encoding: [0xb9,0xff,0xff,0xff,0xff]
|
|
; NF-NEXT: cmovbl %ecx, %eax # EVEX TO LEGACY Compression encoding: [0x0f,0x42,0xc1]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = call i32 @llvm.uadd.sat.i32(i32 %a, i32 123456)
|
|
ret i32 %add
|
|
}
|
|
|
|
define i64 @addflag64ri(i64 noundef %a) {
|
|
; NDD-LABEL: addflag64ri:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: addq $123456, %rdi # encoding: [0x48,0x81,0xc7,0x40,0xe2,0x01,0x00]
|
|
; NDD-NEXT: # imm = 0x1E240
|
|
; NDD-NEXT: movq $-1, %rax # encoding: [0x48,0xc7,0xc0,0xff,0xff,0xff,0xff]
|
|
; NDD-NEXT: cmovaeq %rdi, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x0f,0x43,0xc7]
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMM-LABEL: addflag64ri:
|
|
; IMM: # %bb.0: # %entry
|
|
; IMM-NEXT: addq $123456, %rdi, %rax # encoding: [0x62,0xf4,0xfc,0x18,0x81,0xc7,0x40,0xe2,0x01,0x00]
|
|
; IMM-NEXT: # imm = 0x1E240
|
|
; IMM-NEXT: movq $-1, %rcx # encoding: [0x48,0xc7,0xc1,0xff,0xff,0xff,0xff]
|
|
; IMM-NEXT: cmovbq %rcx, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x0f,0x42,0xc1]
|
|
; IMM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEMONLY-LABEL: addflag64ri:
|
|
; MEMONLY: # %bb.0: # %entry
|
|
; MEMONLY-NEXT: addq $123456, %rdi # encoding: [0x48,0x81,0xc7,0x40,0xe2,0x01,0x00]
|
|
; MEMONLY-NEXT: # imm = 0x1E240
|
|
; MEMONLY-NEXT: movq $-1, %rax # encoding: [0x48,0xc7,0xc0,0xff,0xff,0xff,0xff]
|
|
; MEMONLY-NEXT: cmovaeq %rdi, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x0f,0x43,0xc7]
|
|
; MEMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: addflag64ri:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addq $123456, %rdi # encoding: [0x48,0x81,0xc7,0x40,0xe2,0x01,0x00]
|
|
; NF-NEXT: # imm = 0x1E240
|
|
; NF-NEXT: movq $-1, %rax # encoding: [0x48,0xc7,0xc0,0xff,0xff,0xff,0xff]
|
|
; NF-NEXT: cmovaeq %rdi, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x0f,0x43,0xc7]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%add = call i64 @llvm.uadd.sat.i64(i64 %a, i64 123456)
|
|
ret i64 %add
|
|
}
|
|
|
|
@val = external dso_local global i16, align 4
|
|
|
|
define i1 @add64ri_reloc(i16 %k) {
|
|
; NDD-LABEL: add64ri_reloc:
|
|
; NDD: # %bb.0:
|
|
; NDD-NEXT: # kill: def $edi killed $edi def $rdi
|
|
; NDD-NEXT: movswq %di, %rax # encoding: [0x48,0x0f,0xbf,0xc7]
|
|
; NDD-NEXT: addq %rax, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x01,0xc0]
|
|
; NDD-NEXT: addq $val, %rax # encoding: [0x48,0x05,A,A,A,A]
|
|
; NDD-NEXT: # fixup A - offset: 2, value: val, kind: reloc_signed_4byte
|
|
; NDD-NEXT: setne %al # encoding: [0x0f,0x95,0xc0]
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMM-LABEL: add64ri_reloc:
|
|
; IMM: # %bb.0:
|
|
; IMM-NEXT: # kill: def $edi killed $edi def $rdi
|
|
; IMM-NEXT: movswq %di, %rax # encoding: [0x48,0x0f,0xbf,0xc7]
|
|
; IMM-NEXT: addq %rax, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x01,0xc0]
|
|
; IMM-NEXT: addq $val, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x05,A,A,A,A]
|
|
; IMM-NEXT: # fixup A - offset: 2, value: val, kind: reloc_signed_4byte
|
|
; IMM-NEXT: setne %al # encoding: [0x0f,0x95,0xc0]
|
|
; IMM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEMONLY-LABEL: add64ri_reloc:
|
|
; MEMONLY: # %bb.0:
|
|
; MEMONLY-NEXT: # kill: def $edi killed $edi def $rdi
|
|
; MEMONLY-NEXT: movswq %di, %rax # encoding: [0x48,0x0f,0xbf,0xc7]
|
|
; MEMONLY-NEXT: addq %rax, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x01,0xc0]
|
|
; MEMONLY-NEXT: addq $val, %rax # encoding: [0x48,0x05,A,A,A,A]
|
|
; MEMONLY-NEXT: # fixup A - offset: 2, value: val, kind: reloc_signed_4byte
|
|
; MEMONLY-NEXT: setne %al # encoding: [0x0f,0x95,0xc0]
|
|
; MEMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add64ri_reloc:
|
|
; NF: # %bb.0:
|
|
; NF-NEXT: # kill: def $edi killed $edi def $rdi
|
|
; NF-NEXT: movswq %di, %rax # encoding: [0x48,0x0f,0xbf,0xc7]
|
|
; NF-NEXT: addq %rax, %rax # EVEX TO LEGACY Compression encoding: [0x48,0x01,0xc0]
|
|
; NF-NEXT: addq $val, %rax # encoding: [0x48,0x05,A,A,A,A]
|
|
; NF-NEXT: # fixup A - offset: 2, value: val, kind: reloc_signed_4byte
|
|
; NF-NEXT: setne %al # encoding: [0x0f,0x95,0xc0]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
%g = getelementptr inbounds i16, ptr @val, i16 %k
|
|
%cmp = icmp ne ptr %g, null
|
|
ret i1 %cmp
|
|
}
|
|
|
|
define void @add8mr_legacy(ptr %a, i8 noundef %b) {
|
|
; CHECK-LABEL: add8mr_legacy:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addb %sil, (%rdi) # encoding: [0x40,0x00,0x37]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add8mr_legacy:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addb %sil, (%rdi) # encoding: [0x40,0x00,0x37]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i8, ptr %a
|
|
%add = add i8 %t, %b
|
|
store i8 %add, ptr %a
|
|
ret void
|
|
}
|
|
|
|
define void @add16mr_legacy(ptr %a, i16 noundef %b) {
|
|
; CHECK-LABEL: add16mr_legacy:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addw %si, (%rdi) # encoding: [0x66,0x01,0x37]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add16mr_legacy:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addw %si, (%rdi) # encoding: [0x66,0x01,0x37]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i16, ptr %a
|
|
%add = add i16 %t, %b
|
|
store i16 %add, ptr %a
|
|
ret void
|
|
}
|
|
|
|
define void @add32mr_legacy(ptr %a, i32 noundef %b) {
|
|
; CHECK-LABEL: add32mr_legacy:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addl %esi, (%rdi) # encoding: [0x01,0x37]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add32mr_legacy:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addl %esi, (%rdi) # encoding: [0x01,0x37]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i32, ptr %a
|
|
%add = add i32 %t, %b
|
|
store i32 %add, ptr %a
|
|
ret void
|
|
}
|
|
|
|
define void @add64mr_legacy(ptr %a, i64 noundef %b) {
|
|
; CHECK-LABEL: add64mr_legacy:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addq %rsi, (%rdi) # encoding: [0x48,0x01,0x37]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add64mr_legacy:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addq %rsi, (%rdi) # encoding: [0x48,0x01,0x37]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i64, ptr %a
|
|
%add = add i64 %t, %b
|
|
store i64 %add, ptr %a
|
|
ret void
|
|
}
|
|
|
|
define void @add8mi_legacy(ptr %a) {
|
|
; CHECK-LABEL: add8mi_legacy:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addb $123, (%rdi) # encoding: [0x80,0x07,0x7b]
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add8mi_legacy:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addb $123, (%rdi) # encoding: [0x80,0x07,0x7b]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i8, ptr %a
|
|
%add = add nsw i8 %t, 123
|
|
store i8 %add, ptr %a
|
|
ret void
|
|
}
|
|
|
|
define void @add16mi_legacy(ptr %a) {
|
|
; CHECK-LABEL: add16mi_legacy:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addw $1234, (%rdi) # encoding: [0x66,0x81,0x07,0xd2,0x04]
|
|
; CHECK-NEXT: # imm = 0x4D2
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add16mi_legacy:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addw $1234, (%rdi) # encoding: [0x66,0x81,0x07,0xd2,0x04]
|
|
; NF-NEXT: # imm = 0x4D2
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i16, ptr %a
|
|
%add = add nsw i16 %t, 1234
|
|
store i16 %add, ptr %a
|
|
ret void
|
|
}
|
|
|
|
define void @add32mi_legacy(ptr %a) {
|
|
; CHECK-LABEL: add32mi_legacy:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addl $123456, (%rdi) # encoding: [0x81,0x07,0x40,0xe2,0x01,0x00]
|
|
; CHECK-NEXT: # imm = 0x1E240
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add32mi_legacy:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addl $123456, (%rdi) # encoding: [0x81,0x07,0x40,0xe2,0x01,0x00]
|
|
; NF-NEXT: # imm = 0x1E240
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i32, ptr %a
|
|
%add = add nsw i32 %t, 123456
|
|
store i32 %add, ptr %a
|
|
ret void
|
|
}
|
|
|
|
define void @add64mi_legacy(ptr %a) {
|
|
; CHECK-LABEL: add64mi_legacy:
|
|
; CHECK: # %bb.0: # %entry
|
|
; CHECK-NEXT: addq $123456, (%rdi) # encoding: [0x48,0x81,0x07,0x40,0xe2,0x01,0x00]
|
|
; CHECK-NEXT: # imm = 0x1E240
|
|
; CHECK-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: add64mi_legacy:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: addq $123456, (%rdi) # encoding: [0x48,0x81,0x07,0x40,0xe2,0x01,0x00]
|
|
; NF-NEXT: # imm = 0x1E240
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%t= load i64, ptr %a
|
|
%add = add nsw i64 %t, 123456
|
|
store i64 %add, ptr %a
|
|
ret void
|
|
}
|
|
|
|
define i32 @two_address_no_subreg(i32 %arg0, ptr %arg1, i1 %arg2) nounwind {
|
|
; NDD-LABEL: two_address_no_subreg:
|
|
; NDD: # %bb.0: # %entry
|
|
; NDD-NEXT: pushq %rbp # encoding: [0x55]
|
|
; NDD-NEXT: pushq %r15 # encoding: [0x41,0x57]
|
|
; NDD-NEXT: pushq %r14 # encoding: [0x41,0x56]
|
|
; NDD-NEXT: pushq %r13 # encoding: [0x41,0x55]
|
|
; NDD-NEXT: pushq %r12 # encoding: [0x41,0x54]
|
|
; NDD-NEXT: pushq %rbx # encoding: [0x53]
|
|
; NDD-NEXT: pushq %rax # encoding: [0x50]
|
|
; NDD-NEXT: movl %edx, %ebp # encoding: [0x89,0xd5]
|
|
; NDD-NEXT: movq %rsi, %r14 # encoding: [0x49,0x89,0xf6]
|
|
; NDD-NEXT: movl %edi, %ebx # encoding: [0x89,0xfb]
|
|
; NDD-NEXT: movslq %edi, %rax # encoding: [0x48,0x63,0xc7]
|
|
; NDD-NEXT: imulq $715827883, %rax, %r13 # encoding: [0x4c,0x69,0xe8,0xab,0xaa,0xaa,0x2a]
|
|
; NDD-NEXT: # imm = 0x2AAAAAAB
|
|
; NDD-NEXT: shrq $63, %r13, %rax # encoding: [0x62,0xd4,0xfc,0x18,0xc1,0xed,0x3f]
|
|
; NDD-NEXT: movq %rax, (%rsp) # 8-byte Spill
|
|
; NDD-NEXT: # encoding: [0x48,0x89,0x04,0x24]
|
|
; NDD-NEXT: shrq $32, %r13 # EVEX TO LEGACY Compression encoding: [0x49,0xc1,0xed,0x20]
|
|
; NDD-NEXT: xorl %r15d, %r15d # encoding: [0x45,0x31,0xff]
|
|
; NDD-NEXT: movq %rsi, %rdi # encoding: [0x48,0x89,0xf7]
|
|
; NDD-NEXT: callq *%r15 # encoding: [0x41,0xff,0xd7]
|
|
; NDD-NEXT: movq %r14, %rdi # encoding: [0x4c,0x89,0xf7]
|
|
; NDD-NEXT: callq *%r15 # encoding: [0x41,0xff,0xd7]
|
|
; NDD-NEXT: movl $1, %r12d # encoding: [0x41,0xbc,0x01,0x00,0x00,0x00]
|
|
; NDD-NEXT: testb $1, %bpl # encoding: [0x40,0xf6,0xc5,0x01]
|
|
; NDD-NEXT: jne .LBB50_2 # encoding: [0x75,A]
|
|
; NDD-NEXT: # fixup A - offset: 1, value: .LBB50_2, kind: FK_PCRel_1
|
|
; NDD-NEXT: # %bb.1: # %bb2
|
|
; NDD-NEXT: xorl %r12d, %r12d # encoding: [0x45,0x31,0xe4]
|
|
; NDD-NEXT: .LBB50_2: # %bb1
|
|
; NDD-NEXT: movl %r13d, %esi # encoding: [0x44,0x89,0xee]
|
|
; NDD-NEXT: addl (%rsp), %esi # 4-byte Folded Reload
|
|
; NDD-NEXT: # encoding: [0x03,0x34,0x24]
|
|
; NDD-NEXT: imull %ebx, %ebx, %r13d # encoding: [0x62,0xf4,0x14,0x18,0xaf,0xdb]
|
|
; NDD-NEXT: testb $1, %bpl # encoding: [0x40,0xf6,0xc5,0x01]
|
|
; NDD-NEXT: jne .LBB50_4 # encoding: [0x75,A]
|
|
; NDD-NEXT: # fixup A - offset: 1, value: .LBB50_4, kind: FK_PCRel_1
|
|
; NDD-NEXT: # %bb.3: # %bb4
|
|
; NDD-NEXT: xorl %ebp, %ebp # encoding: [0x31,0xed]
|
|
; NDD-NEXT: movq %r14, %rdi # encoding: [0x4c,0x89,0xf7]
|
|
; NDD-NEXT: movl %esi, %r14d # encoding: [0x41,0x89,0xf6]
|
|
; NDD-NEXT: callq *%rbp # encoding: [0xff,0xd5]
|
|
; NDD-NEXT: incl %r12d, %r15d # encoding: [0x62,0xd4,0x04,0x18,0xff,0xc4]
|
|
; NDD-NEXT: xorl %edi, %edi # encoding: [0x31,0xff]
|
|
; NDD-NEXT: callq *%rbp # encoding: [0xff,0xd5]
|
|
; NDD-NEXT: movl %r14d, %esi # encoding: [0x44,0x89,0xf6]
|
|
; NDD-NEXT: .LBB50_4: # %bb3
|
|
; NDD-NEXT: orl %r13d, %esi # EVEX TO LEGACY Compression encoding: [0x44,0x09,0xee]
|
|
; NDD-NEXT: orl %r15d, %esi # EVEX TO LEGACY Compression encoding: [0x44,0x09,0xfe]
|
|
; NDD-NEXT: xorl %eax, %eax # encoding: [0x31,0xc0]
|
|
; NDD-NEXT: movl %ebx, %edi # encoding: [0x89,0xdf]
|
|
; NDD-NEXT: xorl %edx, %edx # encoding: [0x31,0xd2]
|
|
; NDD-NEXT: xorl %ecx, %ecx # encoding: [0x31,0xc9]
|
|
; NDD-NEXT: callq *%rax # encoding: [0xff,0xd0]
|
|
; NDD-NEXT: xorl %eax, %eax # encoding: [0x31,0xc0]
|
|
; NDD-NEXT: addq $8, %rsp # encoding: [0x48,0x83,0xc4,0x08]
|
|
; NDD-NEXT: popq %rbx # encoding: [0x5b]
|
|
; NDD-NEXT: popq %r12 # encoding: [0x41,0x5c]
|
|
; NDD-NEXT: popq %r13 # encoding: [0x41,0x5d]
|
|
; NDD-NEXT: popq %r14 # encoding: [0x41,0x5e]
|
|
; NDD-NEXT: popq %r15 # encoding: [0x41,0x5f]
|
|
; NDD-NEXT: popq %rbp # encoding: [0x5d]
|
|
; NDD-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; IMMONLY-LABEL: two_address_no_subreg:
|
|
; IMMONLY: # %bb.0: # %entry
|
|
; IMMONLY-NEXT: pushq %rbp # encoding: [0x55]
|
|
; IMMONLY-NEXT: pushq %r15 # encoding: [0x41,0x57]
|
|
; IMMONLY-NEXT: pushq %r14 # encoding: [0x41,0x56]
|
|
; IMMONLY-NEXT: pushq %r13 # encoding: [0x41,0x55]
|
|
; IMMONLY-NEXT: pushq %r12 # encoding: [0x41,0x54]
|
|
; IMMONLY-NEXT: pushq %rbx # encoding: [0x53]
|
|
; IMMONLY-NEXT: pushq %rax # encoding: [0x50]
|
|
; IMMONLY-NEXT: movl %edx, %ebp # encoding: [0x89,0xd5]
|
|
; IMMONLY-NEXT: movq %rsi, %r14 # encoding: [0x49,0x89,0xf6]
|
|
; IMMONLY-NEXT: movl %edi, %ebx # encoding: [0x89,0xfb]
|
|
; IMMONLY-NEXT: movslq %edi, %rax # encoding: [0x48,0x63,0xc7]
|
|
; IMMONLY-NEXT: imulq $715827883, %rax, %r13 # encoding: [0x4c,0x69,0xe8,0xab,0xaa,0xaa,0x2a]
|
|
; IMMONLY-NEXT: # imm = 0x2AAAAAAB
|
|
; IMMONLY-NEXT: shrq $63, %r13, %rax # encoding: [0x62,0xd4,0xfc,0x18,0xc1,0xed,0x3f]
|
|
; IMMONLY-NEXT: movq %rax, (%rsp) # 8-byte Spill
|
|
; IMMONLY-NEXT: # encoding: [0x48,0x89,0x04,0x24]
|
|
; IMMONLY-NEXT: shrq $32, %r13 # EVEX TO LEGACY Compression encoding: [0x49,0xc1,0xed,0x20]
|
|
; IMMONLY-NEXT: xorl %r15d, %r15d # encoding: [0x45,0x31,0xff]
|
|
; IMMONLY-NEXT: movq %rsi, %rdi # encoding: [0x48,0x89,0xf7]
|
|
; IMMONLY-NEXT: callq *%r15 # encoding: [0x41,0xff,0xd7]
|
|
; IMMONLY-NEXT: movq %r14, %rdi # encoding: [0x4c,0x89,0xf7]
|
|
; IMMONLY-NEXT: callq *%r15 # encoding: [0x41,0xff,0xd7]
|
|
; IMMONLY-NEXT: movl $1, %r12d # encoding: [0x41,0xbc,0x01,0x00,0x00,0x00]
|
|
; IMMONLY-NEXT: testb $1, %bpl # encoding: [0x40,0xf6,0xc5,0x01]
|
|
; IMMONLY-NEXT: jne .LBB50_2 # encoding: [0x75,A]
|
|
; IMMONLY-NEXT: # fixup A - offset: 1, value: .LBB50_2, kind: FK_PCRel_1
|
|
; IMMONLY-NEXT: # %bb.1: # %bb2
|
|
; IMMONLY-NEXT: xorl %r12d, %r12d # encoding: [0x45,0x31,0xe4]
|
|
; IMMONLY-NEXT: .LBB50_2: # %bb1
|
|
; IMMONLY-NEXT: movl %r13d, %esi # encoding: [0x44,0x89,0xee]
|
|
; IMMONLY-NEXT: addl (%rsp), %esi # 4-byte Folded Reload
|
|
; IMMONLY-NEXT: # encoding: [0x03,0x34,0x24]
|
|
; IMMONLY-NEXT: imull %ebx, %ebx, %r13d # encoding: [0x62,0xf4,0x14,0x18,0xaf,0xdb]
|
|
; IMMONLY-NEXT: testb $1, %bpl # encoding: [0x40,0xf6,0xc5,0x01]
|
|
; IMMONLY-NEXT: jne .LBB50_4 # encoding: [0x75,A]
|
|
; IMMONLY-NEXT: # fixup A - offset: 1, value: .LBB50_4, kind: FK_PCRel_1
|
|
; IMMONLY-NEXT: # %bb.3: # %bb4
|
|
; IMMONLY-NEXT: xorl %ebp, %ebp # encoding: [0x31,0xed]
|
|
; IMMONLY-NEXT: movq %r14, %rdi # encoding: [0x4c,0x89,0xf7]
|
|
; IMMONLY-NEXT: movl %esi, %r14d # encoding: [0x41,0x89,0xf6]
|
|
; IMMONLY-NEXT: callq *%rbp # encoding: [0xff,0xd5]
|
|
; IMMONLY-NEXT: incl %r12d, %r15d # encoding: [0x62,0xd4,0x04,0x18,0xff,0xc4]
|
|
; IMMONLY-NEXT: xorl %edi, %edi # encoding: [0x31,0xff]
|
|
; IMMONLY-NEXT: callq *%rbp # encoding: [0xff,0xd5]
|
|
; IMMONLY-NEXT: movl %r14d, %esi # encoding: [0x44,0x89,0xf6]
|
|
; IMMONLY-NEXT: .LBB50_4: # %bb3
|
|
; IMMONLY-NEXT: orl %r13d, %esi # EVEX TO LEGACY Compression encoding: [0x44,0x09,0xee]
|
|
; IMMONLY-NEXT: orl %r15d, %esi # EVEX TO LEGACY Compression encoding: [0x44,0x09,0xfe]
|
|
; IMMONLY-NEXT: xorl %eax, %eax # encoding: [0x31,0xc0]
|
|
; IMMONLY-NEXT: movl %ebx, %edi # encoding: [0x89,0xdf]
|
|
; IMMONLY-NEXT: xorl %edx, %edx # encoding: [0x31,0xd2]
|
|
; IMMONLY-NEXT: xorl %ecx, %ecx # encoding: [0x31,0xc9]
|
|
; IMMONLY-NEXT: callq *%rax # encoding: [0xff,0xd0]
|
|
; IMMONLY-NEXT: xorl %eax, %eax # encoding: [0x31,0xc0]
|
|
; IMMONLY-NEXT: addq $8, %rsp # encoding: [0x48,0x83,0xc4,0x08]
|
|
; IMMONLY-NEXT: popq %rbx # encoding: [0x5b]
|
|
; IMMONLY-NEXT: popq %r12 # encoding: [0x41,0x5c]
|
|
; IMMONLY-NEXT: popq %r13 # encoding: [0x41,0x5d]
|
|
; IMMONLY-NEXT: popq %r14 # encoding: [0x41,0x5e]
|
|
; IMMONLY-NEXT: popq %r15 # encoding: [0x41,0x5f]
|
|
; IMMONLY-NEXT: popq %rbp # encoding: [0x5d]
|
|
; IMMONLY-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; MEM-LABEL: two_address_no_subreg:
|
|
; MEM: # %bb.0: # %entry
|
|
; MEM-NEXT: pushq %rbp # encoding: [0x55]
|
|
; MEM-NEXT: pushq %r15 # encoding: [0x41,0x57]
|
|
; MEM-NEXT: pushq %r14 # encoding: [0x41,0x56]
|
|
; MEM-NEXT: pushq %r13 # encoding: [0x41,0x55]
|
|
; MEM-NEXT: pushq %r12 # encoding: [0x41,0x54]
|
|
; MEM-NEXT: pushq %rbx # encoding: [0x53]
|
|
; MEM-NEXT: pushq %rax # encoding: [0x50]
|
|
; MEM-NEXT: movl %edx, %ebp # encoding: [0x89,0xd5]
|
|
; MEM-NEXT: movq %rsi, %r14 # encoding: [0x49,0x89,0xf6]
|
|
; MEM-NEXT: movl %edi, %ebx # encoding: [0x89,0xfb]
|
|
; MEM-NEXT: movslq %edi, %rax # encoding: [0x48,0x63,0xc7]
|
|
; MEM-NEXT: imulq $715827883, %rax, %r13 # encoding: [0x4c,0x69,0xe8,0xab,0xaa,0xaa,0x2a]
|
|
; MEM-NEXT: # imm = 0x2AAAAAAB
|
|
; MEM-NEXT: shrq $63, %r13, %rax # encoding: [0x62,0xd4,0xfc,0x18,0xc1,0xed,0x3f]
|
|
; MEM-NEXT: movq %rax, (%rsp) # 8-byte Spill
|
|
; MEM-NEXT: # encoding: [0x48,0x89,0x04,0x24]
|
|
; MEM-NEXT: shrq $32, %r13 # EVEX TO LEGACY Compression encoding: [0x49,0xc1,0xed,0x20]
|
|
; MEM-NEXT: xorl %r15d, %r15d # encoding: [0x45,0x31,0xff]
|
|
; MEM-NEXT: movq %rsi, %rdi # encoding: [0x48,0x89,0xf7]
|
|
; MEM-NEXT: callq *%r15 # encoding: [0x41,0xff,0xd7]
|
|
; MEM-NEXT: movq %r14, %rdi # encoding: [0x4c,0x89,0xf7]
|
|
; MEM-NEXT: callq *%r15 # encoding: [0x41,0xff,0xd7]
|
|
; MEM-NEXT: movl $1, %r12d # encoding: [0x41,0xbc,0x01,0x00,0x00,0x00]
|
|
; MEM-NEXT: testb $1, %bpl # encoding: [0x40,0xf6,0xc5,0x01]
|
|
; MEM-NEXT: jne .LBB50_2 # encoding: [0x75,A]
|
|
; MEM-NEXT: # fixup A - offset: 1, value: .LBB50_2, kind: FK_PCRel_1
|
|
; MEM-NEXT: # %bb.1: # %bb2
|
|
; MEM-NEXT: xorl %r12d, %r12d # encoding: [0x45,0x31,0xe4]
|
|
; MEM-NEXT: .LBB50_2: # %bb1
|
|
; MEM-NEXT: addl (%rsp), %r13d, %esi # 4-byte Folded Reload
|
|
; MEM-NEXT: # encoding: [0x62,0x74,0x4c,0x18,0x03,0x2c,0x24]
|
|
; MEM-NEXT: imull %ebx, %ebx, %r13d # encoding: [0x62,0xf4,0x14,0x18,0xaf,0xdb]
|
|
; MEM-NEXT: testb $1, %bpl # encoding: [0x40,0xf6,0xc5,0x01]
|
|
; MEM-NEXT: jne .LBB50_4 # encoding: [0x75,A]
|
|
; MEM-NEXT: # fixup A - offset: 1, value: .LBB50_4, kind: FK_PCRel_1
|
|
; MEM-NEXT: # %bb.3: # %bb4
|
|
; MEM-NEXT: xorl %ebp, %ebp # encoding: [0x31,0xed]
|
|
; MEM-NEXT: movq %r14, %rdi # encoding: [0x4c,0x89,0xf7]
|
|
; MEM-NEXT: movl %esi, %r14d # encoding: [0x41,0x89,0xf6]
|
|
; MEM-NEXT: callq *%rbp # encoding: [0xff,0xd5]
|
|
; MEM-NEXT: incl %r12d, %r15d # encoding: [0x62,0xd4,0x04,0x18,0xff,0xc4]
|
|
; MEM-NEXT: xorl %edi, %edi # encoding: [0x31,0xff]
|
|
; MEM-NEXT: callq *%rbp # encoding: [0xff,0xd5]
|
|
; MEM-NEXT: movl %r14d, %esi # encoding: [0x44,0x89,0xf6]
|
|
; MEM-NEXT: .LBB50_4: # %bb3
|
|
; MEM-NEXT: orl %r13d, %esi # EVEX TO LEGACY Compression encoding: [0x44,0x09,0xee]
|
|
; MEM-NEXT: orl %r15d, %esi # EVEX TO LEGACY Compression encoding: [0x44,0x09,0xfe]
|
|
; MEM-NEXT: xorl %eax, %eax # encoding: [0x31,0xc0]
|
|
; MEM-NEXT: movl %ebx, %edi # encoding: [0x89,0xdf]
|
|
; MEM-NEXT: xorl %edx, %edx # encoding: [0x31,0xd2]
|
|
; MEM-NEXT: xorl %ecx, %ecx # encoding: [0x31,0xc9]
|
|
; MEM-NEXT: callq *%rax # encoding: [0xff,0xd0]
|
|
; MEM-NEXT: xorl %eax, %eax # encoding: [0x31,0xc0]
|
|
; MEM-NEXT: addq $8, %rsp # encoding: [0x48,0x83,0xc4,0x08]
|
|
; MEM-NEXT: popq %rbx # encoding: [0x5b]
|
|
; MEM-NEXT: popq %r12 # encoding: [0x41,0x5c]
|
|
; MEM-NEXT: popq %r13 # encoding: [0x41,0x5d]
|
|
; MEM-NEXT: popq %r14 # encoding: [0x41,0x5e]
|
|
; MEM-NEXT: popq %r15 # encoding: [0x41,0x5f]
|
|
; MEM-NEXT: popq %rbp # encoding: [0x5d]
|
|
; MEM-NEXT: retq # encoding: [0xc3]
|
|
;
|
|
; NF-LABEL: two_address_no_subreg:
|
|
; NF: # %bb.0: # %entry
|
|
; NF-NEXT: pushq %rbp # encoding: [0x55]
|
|
; NF-NEXT: pushq %r15 # encoding: [0x41,0x57]
|
|
; NF-NEXT: pushq %r14 # encoding: [0x41,0x56]
|
|
; NF-NEXT: pushq %r13 # encoding: [0x41,0x55]
|
|
; NF-NEXT: pushq %r12 # encoding: [0x41,0x54]
|
|
; NF-NEXT: pushq %rbx # encoding: [0x53]
|
|
; NF-NEXT: pushq %rax # encoding: [0x50]
|
|
; NF-NEXT: movl %edx, %ebp # encoding: [0x89,0xd5]
|
|
; NF-NEXT: movq %rsi, %r14 # encoding: [0x49,0x89,0xf6]
|
|
; NF-NEXT: movl %edi, %ebx # encoding: [0x89,0xfb]
|
|
; NF-NEXT: movslq %edi, %rax # encoding: [0x48,0x63,0xc7]
|
|
; NF-NEXT: imulq $715827883, %rax, %r13 # encoding: [0x4c,0x69,0xe8,0xab,0xaa,0xaa,0x2a]
|
|
; NF-NEXT: # imm = 0x2AAAAAAB
|
|
; NF-NEXT: {nf} shrq $63, %r13, %rax # EVEX TO EVEX Compression encoding: [0x62,0xd4,0xfc,0x1c,0xc1,0xed,0x3f]
|
|
; NF-NEXT: movq %rax, (%rsp) # 8-byte Spill
|
|
; NF-NEXT: # encoding: [0x48,0x89,0x04,0x24]
|
|
; NF-NEXT: shrq $32, %r13 # EVEX TO LEGACY Compression encoding: [0x49,0xc1,0xed,0x20]
|
|
; NF-NEXT: xorl %r15d, %r15d # encoding: [0x45,0x31,0xff]
|
|
; NF-NEXT: movq %rsi, %rdi # encoding: [0x48,0x89,0xf7]
|
|
; NF-NEXT: callq *%r15 # encoding: [0x41,0xff,0xd7]
|
|
; NF-NEXT: movq %r14, %rdi # encoding: [0x4c,0x89,0xf7]
|
|
; NF-NEXT: callq *%r15 # encoding: [0x41,0xff,0xd7]
|
|
; NF-NEXT: movl $1, %r12d # encoding: [0x41,0xbc,0x01,0x00,0x00,0x00]
|
|
; NF-NEXT: testb $1, %bpl # encoding: [0x40,0xf6,0xc5,0x01]
|
|
; NF-NEXT: jne .LBB50_2 # encoding: [0x75,A]
|
|
; NF-NEXT: # fixup A - offset: 1, value: .LBB50_2, kind: FK_PCRel_1
|
|
; NF-NEXT: # %bb.1: # %bb2
|
|
; NF-NEXT: xorl %r12d, %r12d # encoding: [0x45,0x31,0xe4]
|
|
; NF-NEXT: .LBB50_2: # %bb1
|
|
; NF-NEXT: movl %r13d, %esi # encoding: [0x44,0x89,0xee]
|
|
; NF-NEXT: addl (%rsp), %esi # 4-byte Folded Reload
|
|
; NF-NEXT: # encoding: [0x03,0x34,0x24]
|
|
; NF-NEXT: {nf} imull %ebx, %ebx, %r13d # EVEX TO EVEX Compression encoding: [0x62,0xf4,0x14,0x1c,0xaf,0xdb]
|
|
; NF-NEXT: testb $1, %bpl # encoding: [0x40,0xf6,0xc5,0x01]
|
|
; NF-NEXT: jne .LBB50_4 # encoding: [0x75,A]
|
|
; NF-NEXT: # fixup A - offset: 1, value: .LBB50_4, kind: FK_PCRel_1
|
|
; NF-NEXT: # %bb.3: # %bb4
|
|
; NF-NEXT: xorl %ebp, %ebp # encoding: [0x31,0xed]
|
|
; NF-NEXT: movq %r14, %rdi # encoding: [0x4c,0x89,0xf7]
|
|
; NF-NEXT: movl %esi, %r14d # encoding: [0x41,0x89,0xf6]
|
|
; NF-NEXT: callq *%rbp # encoding: [0xff,0xd5]
|
|
; NF-NEXT: {nf} incl %r12d, %r15d # EVEX TO EVEX Compression encoding: [0x62,0xd4,0x04,0x1c,0xff,0xc4]
|
|
; NF-NEXT: xorl %edi, %edi # encoding: [0x31,0xff]
|
|
; NF-NEXT: callq *%rbp # encoding: [0xff,0xd5]
|
|
; NF-NEXT: movl %r14d, %esi # encoding: [0x44,0x89,0xf6]
|
|
; NF-NEXT: .LBB50_4: # %bb3
|
|
; NF-NEXT: orl %r13d, %esi # EVEX TO LEGACY Compression encoding: [0x44,0x09,0xee]
|
|
; NF-NEXT: orl %r15d, %esi # EVEX TO LEGACY Compression encoding: [0x44,0x09,0xfe]
|
|
; NF-NEXT: xorl %eax, %eax # encoding: [0x31,0xc0]
|
|
; NF-NEXT: movl %ebx, %edi # encoding: [0x89,0xdf]
|
|
; NF-NEXT: xorl %edx, %edx # encoding: [0x31,0xd2]
|
|
; NF-NEXT: xorl %ecx, %ecx # encoding: [0x31,0xc9]
|
|
; NF-NEXT: callq *%rax # encoding: [0xff,0xd0]
|
|
; NF-NEXT: xorl %eax, %eax # encoding: [0x31,0xc0]
|
|
; NF-NEXT: addq $8, %rsp # encoding: [0x48,0x83,0xc4,0x08]
|
|
; NF-NEXT: popq %rbx # encoding: [0x5b]
|
|
; NF-NEXT: popq %r12 # encoding: [0x41,0x5c]
|
|
; NF-NEXT: popq %r13 # encoding: [0x41,0x5d]
|
|
; NF-NEXT: popq %r14 # encoding: [0x41,0x5e]
|
|
; NF-NEXT: popq %r15 # encoding: [0x41,0x5f]
|
|
; NF-NEXT: popq %rbp # encoding: [0x5d]
|
|
; NF-NEXT: retq # encoding: [0xc3]
|
|
entry:
|
|
%v0 = sdiv i32 %arg0, 6
|
|
%v1 = tail call i32 null(ptr %arg1)
|
|
%v2 = tail call i32 null(ptr %arg1)
|
|
br i1 %arg2, label %bb1, label %bb2
|
|
|
|
bb2: ; preds = %entry
|
|
br label %bb1
|
|
|
|
bb1: ; preds = %bb2, %entry
|
|
%v3 = phi i32 [ 0, %bb2 ], [ 1, %entry ]
|
|
%v4 = mul i32 %arg0, %arg0
|
|
br i1 %arg2, label %bb3, label %bb4
|
|
|
|
bb4: ; preds = %bb1
|
|
%v5 = tail call i32 null(ptr %arg1)
|
|
%v6 = add i32 %v3, 1
|
|
%v7 = tail call i32 null(ptr null)
|
|
br label %bb3
|
|
|
|
bb3: ; preds = %bb4, %bb1
|
|
%v8 = phi i32 [ %v6, %bb4 ], [ 0, %bb1 ]
|
|
%v9 = or i32 %v0, %v4
|
|
%v10 = or i32 %v9, %v8
|
|
tail call void null(i32 %arg0, i32 %v10, i32 0, i32 0)
|
|
ret i32 0
|
|
}
|