forked from OSchip/llvm-project
245 lines
8.1 KiB
LLVM
245 lines
8.1 KiB
LLVM
; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
|
|
; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -mcpu=core2 | FileCheck %s -check-prefix=LINUX
|
|
; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=core2 | FileCheck %s -check-prefix=DARWIN
|
|
|
|
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
|
|
declare void @llvm.memcpy.p256i8.p256i8.i64(i8 addrspace(256)* nocapture, i8 addrspace(256)* nocapture, i64, i1) nounwind
|
|
|
|
|
|
; Variable memcpy's should lower to calls.
|
|
define i8* @test1(i8* %a, i8* %b, i64 %n) nounwind {
|
|
; LINUX-LABEL: test1:
|
|
; LINUX: # %bb.0: # %entry
|
|
; LINUX-NEXT: jmp memcpy # TAILCALL
|
|
;
|
|
; DARWIN-LABEL: test1:
|
|
; DARWIN: ## %bb.0: ## %entry
|
|
; DARWIN-NEXT: jmp _memcpy ## TAILCALL
|
|
entry:
|
|
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 %n, i1 0 )
|
|
ret i8* %a
|
|
}
|
|
|
|
; Variable memcpy's should lower to calls.
|
|
define i8* @test2(i64* %a, i64* %b, i64 %n) nounwind {
|
|
; LINUX-LABEL: test2:
|
|
; LINUX: # %bb.0: # %entry
|
|
; LINUX-NEXT: jmp memcpy # TAILCALL
|
|
;
|
|
; DARWIN-LABEL: test2:
|
|
; DARWIN: ## %bb.0: ## %entry
|
|
; DARWIN-NEXT: jmp _memcpy ## TAILCALL
|
|
entry:
|
|
%tmp14 = bitcast i64* %a to i8*
|
|
%tmp25 = bitcast i64* %b to i8*
|
|
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %tmp14, i8* align 8 %tmp25, i64 %n, i1 0 )
|
|
ret i8* %tmp14
|
|
}
|
|
|
|
; Large constant memcpy's should lower to a call when optimizing for size.
|
|
; PR6623
|
|
|
|
; On the other hand, Darwin's definition of -Os is optimizing for size without
|
|
; hurting performance so it should just ignore optsize when expanding memcpy.
|
|
; rdar://8821501
|
|
define void @test3(i8* nocapture %A, i8* nocapture %B) nounwind optsize noredzone {
|
|
; LINUX-LABEL: test3:
|
|
; LINUX: # %bb.0: # %entry
|
|
; LINUX-NEXT: movl $64, %edx
|
|
; LINUX-NEXT: jmp memcpy # TAILCALL
|
|
;
|
|
; DARWIN-LABEL: test3:
|
|
; DARWIN: ## %bb.0: ## %entry
|
|
; DARWIN-NEXT: movq 56(%rsi), %rax
|
|
; DARWIN-NEXT: movq %rax, 56(%rdi)
|
|
; DARWIN-NEXT: movq 48(%rsi), %rax
|
|
; DARWIN-NEXT: movq %rax, 48(%rdi)
|
|
; DARWIN-NEXT: movq 40(%rsi), %rax
|
|
; DARWIN-NEXT: movq %rax, 40(%rdi)
|
|
; DARWIN-NEXT: movq 32(%rsi), %rax
|
|
; DARWIN-NEXT: movq %rax, 32(%rdi)
|
|
; DARWIN-NEXT: movq 24(%rsi), %rax
|
|
; DARWIN-NEXT: movq %rax, 24(%rdi)
|
|
; DARWIN-NEXT: movq 16(%rsi), %rax
|
|
; DARWIN-NEXT: movq %rax, 16(%rdi)
|
|
; DARWIN-NEXT: movq (%rsi), %rax
|
|
; DARWIN-NEXT: movq 8(%rsi), %rcx
|
|
; DARWIN-NEXT: movq %rcx, 8(%rdi)
|
|
; DARWIN-NEXT: movq %rax, (%rdi)
|
|
; DARWIN-NEXT: retq
|
|
entry:
|
|
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 64, i1 false)
|
|
ret void
|
|
}
|
|
|
|
define void @test3_minsize(i8* nocapture %A, i8* nocapture %B) nounwind minsize noredzone {
|
|
; LINUX-LABEL: test3_minsize:
|
|
; LINUX: # %bb.0:
|
|
; LINUX-NEXT: pushq $64
|
|
; LINUX-NEXT: popq %rdx
|
|
; LINUX-NEXT: jmp memcpy # TAILCALL
|
|
;
|
|
; DARWIN-LABEL: test3_minsize:
|
|
; DARWIN: ## %bb.0:
|
|
; DARWIN-NEXT: pushq $64
|
|
; DARWIN-NEXT: popq %rdx
|
|
; DARWIN-NEXT: jmp _memcpy ## TAILCALL
|
|
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 64, i1 false)
|
|
ret void
|
|
}
|
|
|
|
define void @test3_minsize_optsize(i8* nocapture %A, i8* nocapture %B) nounwind optsize minsize noredzone {
|
|
; LINUX-LABEL: test3_minsize_optsize:
|
|
; LINUX: # %bb.0:
|
|
; LINUX-NEXT: pushq $64
|
|
; LINUX-NEXT: popq %rdx
|
|
; LINUX-NEXT: jmp memcpy # TAILCALL
|
|
;
|
|
; DARWIN-LABEL: test3_minsize_optsize:
|
|
; DARWIN: ## %bb.0:
|
|
; DARWIN-NEXT: pushq $64
|
|
; DARWIN-NEXT: popq %rdx
|
|
; DARWIN-NEXT: jmp _memcpy ## TAILCALL
|
|
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 64, i1 false)
|
|
ret void
|
|
}
|
|
|
|
; Large constant memcpy's should be inlined when not optimizing for size.
|
|
define void @test4(i8* nocapture %A, i8* nocapture %B) nounwind noredzone {
|
|
; LINUX-LABEL: test4:
|
|
; LINUX: # %bb.0: # %entry
|
|
; LINUX-NEXT: movq 56(%rsi), %rax
|
|
; LINUX-NEXT: movq %rax, 56(%rdi)
|
|
; LINUX-NEXT: movq 48(%rsi), %rax
|
|
; LINUX-NEXT: movq %rax, 48(%rdi)
|
|
; LINUX-NEXT: movq 40(%rsi), %rax
|
|
; LINUX-NEXT: movq %rax, 40(%rdi)
|
|
; LINUX-NEXT: movq 32(%rsi), %rax
|
|
; LINUX-NEXT: movq %rax, 32(%rdi)
|
|
; LINUX-NEXT: movq 24(%rsi), %rax
|
|
; LINUX-NEXT: movq %rax, 24(%rdi)
|
|
; LINUX-NEXT: movq 16(%rsi), %rax
|
|
; LINUX-NEXT: movq %rax, 16(%rdi)
|
|
; LINUX-NEXT: movq (%rsi), %rax
|
|
; LINUX-NEXT: movq 8(%rsi), %rcx
|
|
; LINUX-NEXT: movq %rcx, 8(%rdi)
|
|
; LINUX-NEXT: movq %rax, (%rdi)
|
|
; LINUX-NEXT: retq
|
|
;
|
|
; DARWIN-LABEL: test4:
|
|
; DARWIN: ## %bb.0: ## %entry
|
|
; DARWIN-NEXT: movq 56(%rsi), %rax
|
|
; DARWIN-NEXT: movq %rax, 56(%rdi)
|
|
; DARWIN-NEXT: movq 48(%rsi), %rax
|
|
; DARWIN-NEXT: movq %rax, 48(%rdi)
|
|
; DARWIN-NEXT: movq 40(%rsi), %rax
|
|
; DARWIN-NEXT: movq %rax, 40(%rdi)
|
|
; DARWIN-NEXT: movq 32(%rsi), %rax
|
|
; DARWIN-NEXT: movq %rax, 32(%rdi)
|
|
; DARWIN-NEXT: movq 24(%rsi), %rax
|
|
; DARWIN-NEXT: movq %rax, 24(%rdi)
|
|
; DARWIN-NEXT: movq 16(%rsi), %rax
|
|
; DARWIN-NEXT: movq %rax, 16(%rdi)
|
|
; DARWIN-NEXT: movq (%rsi), %rax
|
|
; DARWIN-NEXT: movq 8(%rsi), %rcx
|
|
; DARWIN-NEXT: movq %rcx, 8(%rdi)
|
|
; DARWIN-NEXT: movq %rax, (%rdi)
|
|
; DARWIN-NEXT: retq
|
|
entry:
|
|
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 64, i1 false)
|
|
ret void
|
|
}
|
|
|
|
|
|
@.str = private unnamed_addr constant [30 x i8] c"\00aaaaaaaaaaaaaaaaaaaaaaaaaaaa\00", align 1
|
|
|
|
define void @test5(i8* nocapture %C) nounwind uwtable ssp {
|
|
; LINUX-LABEL: test5:
|
|
; LINUX: # %bb.0: # %entry
|
|
; LINUX-NEXT: movabsq $7016996765293437281, %rax # imm = 0x6161616161616161
|
|
; LINUX-NEXT: movq %rax, 8(%rdi)
|
|
; LINUX-NEXT: movabsq $7016996765293437184, %rax # imm = 0x6161616161616100
|
|
; LINUX-NEXT: movq %rax, (%rdi)
|
|
; LINUX-NEXT: retq
|
|
;
|
|
; DARWIN-LABEL: test5:
|
|
; DARWIN: ## %bb.0: ## %entry
|
|
; DARWIN-NEXT: movabsq $7016996765293437281, %rax ## imm = 0x6161616161616161
|
|
; DARWIN-NEXT: movq %rax, 8(%rdi)
|
|
; DARWIN-NEXT: movabsq $7016996765293437184, %rax ## imm = 0x6161616161616100
|
|
; DARWIN-NEXT: movq %rax, (%rdi)
|
|
; DARWIN-NEXT: retq
|
|
entry:
|
|
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %C, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0), i64 16, i1 false)
|
|
ret void
|
|
}
|
|
|
|
|
|
; PR14896
|
|
@.str2 = private unnamed_addr constant [2 x i8] c"x\00", align 1
|
|
|
|
define void @test6() nounwind uwtable {
|
|
; LINUX-LABEL: test6:
|
|
; LINUX: # %bb.0: # %entry
|
|
; LINUX-NEXT: movw $0, 8
|
|
; LINUX-NEXT: movq $120, 0
|
|
; LINUX-NEXT: retq
|
|
;
|
|
; DARWIN-LABEL: test6:
|
|
; DARWIN: ## %bb.0: ## %entry
|
|
; DARWIN-NEXT: movw $0, 8
|
|
; DARWIN-NEXT: movq $120, 0
|
|
; DARWIN-NEXT: retq
|
|
entry:
|
|
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str2, i64 0, i64 0), i64 10, i1 false)
|
|
ret void
|
|
}
|
|
|
|
define void @PR15348(i8* %a, i8* %b) {
|
|
; Ensure that alignment of '0' in an @llvm.memcpy intrinsic results in
|
|
; unaligned loads and stores.
|
|
; LINUX-LABEL: PR15348:
|
|
; LINUX: # %bb.0:
|
|
; LINUX-NEXT: movb 16(%rsi), %al
|
|
; LINUX-NEXT: movb %al, 16(%rdi)
|
|
; LINUX-NEXT: movq (%rsi), %rax
|
|
; LINUX-NEXT: movq 8(%rsi), %rcx
|
|
; LINUX-NEXT: movq %rcx, 8(%rdi)
|
|
; LINUX-NEXT: movq %rax, (%rdi)
|
|
; LINUX-NEXT: retq
|
|
;
|
|
; DARWIN-LABEL: PR15348:
|
|
; DARWIN: ## %bb.0:
|
|
; DARWIN-NEXT: movb 16(%rsi), %al
|
|
; DARWIN-NEXT: movb %al, 16(%rdi)
|
|
; DARWIN-NEXT: movq (%rsi), %rax
|
|
; DARWIN-NEXT: movq 8(%rsi), %rcx
|
|
; DARWIN-NEXT: movq %rcx, 8(%rdi)
|
|
; DARWIN-NEXT: movq %rax, (%rdi)
|
|
; DARWIN-NEXT: retq
|
|
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 17, i1 false)
|
|
ret void
|
|
}
|
|
|
|
; Memcpys from / to address space 256 should be lowered to appropriate loads /
|
|
; stores if small enough.
|
|
define void @addrspace256(i8 addrspace(256)* %a, i8 addrspace(256)* %b) nounwind {
|
|
; LINUX-LABEL: addrspace256:
|
|
; LINUX: # %bb.0:
|
|
; LINUX-NEXT: movq %gs:(%rsi), %rax
|
|
; LINUX-NEXT: movq %gs:8(%rsi), %rcx
|
|
; LINUX-NEXT: movq %rcx, %gs:8(%rdi)
|
|
; LINUX-NEXT: movq %rax, %gs:(%rdi)
|
|
; LINUX-NEXT: retq
|
|
;
|
|
; DARWIN-LABEL: addrspace256:
|
|
; DARWIN: ## %bb.0:
|
|
; DARWIN-NEXT: movq %gs:(%rsi), %rax
|
|
; DARWIN-NEXT: movq %gs:8(%rsi), %rcx
|
|
; DARWIN-NEXT: movq %rcx, %gs:8(%rdi)
|
|
; DARWIN-NEXT: movq %rax, %gs:(%rdi)
|
|
; DARWIN-NEXT: retq
|
|
tail call void @llvm.memcpy.p256i8.p256i8.i64(i8 addrspace(256)* align 8 %a, i8 addrspace(256)* align 8 %b, i64 16, i1 false)
|
|
ret void
|
|
}
|