void cvmx_debug_memcpy_align(void *dest, const void *src, int size) {
  long long *dest1 = (long long *)dest;
  const long long *src1 = (const long long *)src;
  int i;
  if (size == 40) {
    long long a0, a1, a2, a3, a4;
    a0 = src1[0];
    a1 = src1[1];
    a2 = src1[2];
    a3 = src1[3];
    a4 = src1[4];
    dest1[0] = a0;
    dest1[1] = a1;
    dest1[2] = a2;
    dest1[3] = a3;
    dest1[4] = a4;
    return;
  }
  for (i = 0; i < size; i += 8) {
    *dest1 = *src1;
    dest1++;
    src1++;
  }
}


x86 assembly (clang, -O0):
<cvmx_debug_memcpy_align>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpl   $0x28,-0x14(%rbp)
jne    11a4 <cvmx_debug_memcpy_align+0xa4>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    0x20(%rax),%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,0x8(%rax)
mov    -0x48(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,0x10(%rax)
mov    -0x50(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,0x18(%rax)
mov    -0x58(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,0x20(%rax)
jmp    11eb <cvmx_debug_memcpy_align+0xeb>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11eb <cvmx_debug_memcpy_align+0xeb>
mov    -0x28(%rbp),%rax
mov    (%rax),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x2c(%rbp)
jmp    11ab <cvmx_debug_memcpy_align+0xab>
pop    %rbp
ret

x86 assembly (clang, -O2):
<cvmx_debug_memcpy_align>:
cmp    $0x28,%edx
jne    111c <cvmx_debug_memcpy_align+0x1c>
movups (%rsi),%xmm0
movups 0x10(%rsi),%xmm1
mov    0x20(%rsi),%rax
movups %xmm0,(%rdi)
movups %xmm1,0x10(%rdi)
mov    %rax,0x20(%rdi)
ret
test   %edx,%edx
jle    1264 <cvmx_debug_memcpy_align+0x164>
lea    -0x1(%rdx),%r9d
xor    %r8d,%r8d
cmp    $0x18,%r9d
jb     1242 <cvmx_debug_memcpy_align+0x142>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    (%rsi,%rcx,1),%rax
add    $0x8,%rax
cmp    %rdi,%rax
jbe    1159 <cvmx_debug_memcpy_align+0x59>
lea    (%rdi,%rcx,1),%rax
add    $0x8,%rax
cmp    %rsi,%rax
ja     1242 <cvmx_debug_memcpy_align+0x142>
shr    $0x3,%r9d
add    $0x1,%r9d
mov    %r9d,%r8d
and    $0xfffffffc,%r8d
lea    -0x4(%r8),%rax
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x3,%r10d
cmp    $0xc,%rax
jae    1188 <cvmx_debug_memcpy_align+0x88>
xor    %eax,%eax
jmp    11e8 <cvmx_debug_memcpy_align+0xe8>
and    $0xfffffffffffffffc,%rcx
xor    %eax,%eax
xchg   %ax,%ax
movups (%rsi,%rax,8),%xmm0
movups 0x10(%rsi,%rax,8),%xmm1
movups %xmm0,(%rdi,%rax,8)
movups %xmm1,0x10(%rdi,%rax,8)
movups 0x20(%rsi,%rax,8),%xmm0
movups 0x30(%rsi,%rax,8),%xmm1
movups %xmm0,0x20(%rdi,%rax,8)
movups %xmm1,0x30(%rdi,%rax,8)
movups 0x40(%rsi,%rax,8),%xmm0
movups 0x50(%rsi,%rax,8),%xmm1
movups %xmm0,0x40(%rdi,%rax,8)
movups %xmm1,0x50(%rdi,%rax,8)
movups 0x60(%rsi,%rax,8),%xmm0
movups 0x70(%rsi,%rax,8),%xmm1
movups %xmm0,0x60(%rdi,%rax,8)
movups %xmm1,0x70(%rdi,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1190 <cvmx_debug_memcpy_align+0x90>
test   %r10,%r10
je     122d <cvmx_debug_memcpy_align+0x12d>
lea    (%rsi,%rax,8),%r11
add    $0x10,%r11
lea    (%rdi,%rax,8),%rax
add    $0x10,%rax
shl    $0x5,%r10
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%r11,%rcx,1),%xmm0
movups (%r11,%rcx,1),%xmm1
movups %xmm0,-0x10(%rax,%rcx,1)
movups %xmm1,(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r10
jne    1210 <cvmx_debug_memcpy_align+0x110>
cmp    %r9,%r8
je     1264 <cvmx_debug_memcpy_align+0x164>
lea    (%rdi,%r8,8),%rdi
lea    (%rsi,%r8,8),%rsi
lea    0x0(,%r8,8),%r8d
mov    %r8d,%r8d
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%rcx,1),%rax
mov    %rax,(%rdi,%rcx,1)
add    $0x8,%rcx
lea    (%r8,%rcx,1),%eax
cmp    %edx,%eax
jl     1250 <cvmx_debug_memcpy_align+0x150>
ret

LLVM IR (-O0):
define void @cvmx_debug_memcpy_align(i8* %0, i8* %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i64*
%8 = alloca i64*
%9 = alloca i32
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%15 = load i8*, i8** %4
%16 = bitcast i8* %15 to i64*
store i64* %16, i64** %7
%17 = load i8*, i8** %5
%18 = bitcast i8* %17 to i64*
store i64* %18, i64** %8
%19 = load i32, i32* %6
%20 = icmp eq i32 %19, 40
br i1 %20, label %21, label %52
21: ; preds = %3
%22 = load i64*, i64** %8
%23 = getelementptr inbounds i64, i64* %22, i64 0
%24 = load i64, i64* %23
store i64 %24, i64* %10
%25 = load i64*, i64** %8
%26 = getelementptr inbounds i64, i64* %25, i64 1
%27 = load i64, i64* %26
store i64 %27, i64* %11
%28 = load i64*, i64** %8
%29 = getelementptr inbounds i64, i64* %28, i64 2
%30 = load i64, i64* %29
store i64 %30, i64* %12
%31 = load i64*, i64** %8
%32 = getelementptr inbounds i64, i64* %31, i64 3
%33 = load i64, i64* %32
store i64 %33, i64* %13
%34 = load i64*, i64** %8
%35 = getelementptr inbounds i64, i64* %34, i64 4
%36 = load i64, i64* %35
store i64 %36, i64* %14
%37 = load i64, i64* %10
%38 = load i64*, i64** %7
%39 = getelementptr inbounds i64, i64* %38, i64 0
store i64 %37, i64* %39
%40 = load i64, i64* %11
%41 = load i64*, i64** %7
%42 = getelementptr inbounds i64, i64* %41, i64 1
store i64 %40, i64* %42
%43 = load i64, i64* %12
%44 = load i64*, i64** %7
%45 = getelementptr inbounds i64, i64* %44, i64 2
store i64 %43, i64* %45
%46 = load i64, i64* %13
%47 = load i64*, i64** %7
%48 = getelementptr inbounds i64, i64* %47, i64 3
store i64 %46, i64* %48
%49 = load i64, i64* %14
%50 = load i64*, i64** %7
%51 = getelementptr inbounds i64, i64* %50, i64 4
store i64 %49, i64* %51
br label %68
52: ; preds = %3
store i32 0, i32* %9
br label %53
53: ; preds = %65, %52
%54 = load i32, i32* %9
%55 = load i32, i32* %6
%56 = icmp slt i32 %54, %55
br i1 %56, label %57, label %68
57: ; preds = %53
%58 = load i64*, i64** %8
%59 = load i64, i64* %58
%60 = load i64*, i64** %7
store i64 %59, i64* %60
%61 = load i64*, i64** %7
%62 = getelementptr inbounds i64, i64* %61, i32 1
store i64* %62, i64** %7
%63 = load i64*, i64** %8
%64 = getelementptr inbounds i64, i64* %63, i32 1
store i64* %64, i64** %8
br label %65
65: ; preds = %57
%66 = load i32, i32* %9
%67 = add nsw i32 %66, 8
store i32 %67, i32* %9
br label %53
68: ; preds = %21, %53
ret void
}

LLVM IR (-O2):
define void @cvmx_debug_memcpy_align(i8* nocapture writeonly %0, i8* nocapture %1, i32 %2) {
%4 = bitcast i8* %0 to i64*
%5 = bitcast i8* %1 to i64*
%6 = icmp eq i32 %2, 40
br i1 %6, label %112, label %7
7: ; preds = %3
%8 = icmp sgt i32 %2, 0
br i1 %8, label %9, label %135
9: ; preds = %7
%10 = add i32 %2, -1
%11 = lshr i32 %10, 3
%12 = add nuw nsw i32 %11, 1
%13 = zext i32 %12 to i64
%14 = icmp ult i32 %10, 24
br i1 %14, label %108, label %15
15: ; preds = %9
%16 = add i32 %2, -1
%17 = and i32 %16, -8
%18 = zext i32 %17 to i64
%19 = add nuw nsw i64 %18, 8
%20 = getelementptr i8, i8* %0, i64 %19
%21 = getelementptr i8, i8* %1, i64 %19
%22 = icmp ugt i8* %21, %0
%23 = icmp ugt i8* %20, %1
%24 = and i1 %22, %23
br i1 %24, label %108, label %25
25: ; preds = %15
%26 = and i64 %13, 1073741820
%27 = getelementptr i64, i64* %4, i64 %26
%28 = getelementptr i64, i64* %5, i64 %26
%29 = trunc i64 %26 to i32
%30 = shl i32 %29, 3
%31 = add nsw i64 %26, -4
%32 = lshr exact i64 %31, 2
%33 = add nuw nsw i64 %32, 1
%34 = and i64 %33, 3
%35 = icmp ult i64 %31, 12
br i1 %35, label %87, label %36
36: ; preds = %25
%37 = and i64 %33, 9223372036854775804
br label %38
38: ; preds = %38, %36
%39 = phi i64 [ 0, %36 ], [ %84, %38 ]
%40 = phi i64 [ 0, %36 ], [ %85, %38 ]
%41 = getelementptr i64, i64* %4, i64 %39
%42 = getelementptr i64, i64* %5, i64 %39
%43 = bitcast i64* %42 to <2 x i64>*
%44 = load <2 x i64>, <2 x i64>* %43
%45 = getelementptr i64, i64* %42, i64 2
%46 = bitcast i64* %45 to <2 x i64>*
%47 = load <2 x i64>, <2 x i64>* %46
%48 = bitcast i64* %41 to <2 x i64>*
store <2 x i64> %44, <2 x i64>* %48
%49 = getelementptr i64, i64* %41, i64 2
%50 = bitcast i64* %49 to <2 x i64>*
store <2 x i64> %47, <2 x i64>* %50
%51 = or i64 %39, 4
%52 = getelementptr i64, i64* %4, i64 %51
%53 = getelementptr i64, i64* %5, i64 %51
%54 = bitcast i64* %53 to <2 x i64>*
%55 = load <2 x i64>, <2 x i64>* %54
%56 = getelementptr i64, i64* %53, i64 2
%57 = bitcast i64* %56 to <2 x i64>*
%58 = load <2 x i64>, <2 x i64>* %57
%59 = bitcast i64* %52 to <2 x i64>*
store <2 x i64> %55, <2 x i64>* %59
%60 = getelementptr i64, i64* %52, i64 2
%61 = bitcast i64* %60 to <2 x i64>*
store <2 x i64> %58, <2 x i64>* %61
%62 = or i64 %39, 8
%63 = getelementptr i64, i64* %4, i64 %62
%64 = getelementptr i64, i64* %5, i64 %62
%65 = bitcast i64* %64 to <2 x i64>*
%66 = load <2 x i64>, <2 x i64>* %65
%67 = getelementptr i64, i64* %64, i64 2
%68 = bitcast i64* %67 to <2 x i64>*
%69 = load <2 x i64>, <2 x i64>* %68
%70 = bitcast i64* %63 to <2 x i64>*
store <2 x i64> %66, <2 x i64>* %70
%71 = getelementptr i64, i64* %63, i64 2
%72 = bitcast i64* %71 to <2 x i64>*
store <2 x i64> %69, <2 x i64>* %72
%73 = or i64 %39, 12
%74 = getelementptr i64, i64* %4, i64 %73
%75 = getelementptr i64, i64* %5, i64 %73
%76 = bitcast i64* %75 to <2 x i64>*
%77 = load <2 x i64>, <2 x i64>* %76
%78 = getelementptr i64, i64* %75, i64 2
%79 = bitcast i64* %78 to <2 x i64>*
%80 = load <2 x i64>, <2 x i64>* %79
%81 = bitcast i64* %74 to <2 x i64>*
store <2 x i64> %77, <2 x i64>* %81
%82 = getelementptr i64, i64* %74, i64 2
%83 = bitcast i64* %82 to <2 x i64>*
store <2 x i64> %80, <2 x i64>* %83
%84 = add nuw i64 %39, 16
%85 = add nuw i64 %40, 4
%86 = icmp eq i64 %85, %37
br i1 %86, label %87, label %38
87: ; preds = %38, %25
%88 = phi i64 [ 0, %25 ], [ %84, %38 ]
%89 = icmp eq i64 %34, 0
br i1 %89, label %106, label %90
90: ; preds = %87, %90
%91 = phi i64 [ %103, %90 ], [ %88, %87 ]
%92 = phi i64 [ %104, %90 ], [ 0, %87 ]
%93 = getelementptr i64, i64* %4, i64 %91
%94 = getelementptr i64, i64* %5, i64 %91
%95 = bitcast i64* %94 to <2 x i64>*
%96 = load <2 x i64>, <2 x i64>* %95
%97 = getelementptr i64, i64* %94, i64 2
%98 = bitcast i64* %97 to <2 x i64>*
%99 = load <2 x i64>, <2 x i64>* %98
%100 = bitcast i64* %93 to <2 x i64>*
store <2 x i64> %96, <2 x i64>* %100
%101 = getelementptr i64, i64* %93, i64 2
%102 = bitcast i64* %101 to <2 x i64>*
store <2 x i64> %99, <2 x i64>* %102
%103 = add nuw i64 %91, 4
%104 = add i64 %92, 1
%105 = icmp eq i64 %104, %34
br i1 %105, label %106, label %90
106: ; preds = %90, %87
%107 = icmp eq i64 %26, %13
br i1 %107, label %135, label %108
108: ; preds = %15, %9, %106
%109 = phi i64* [ %4, %15 ], [ %4, %9 ], [ %27, %106 ]
%110 = phi i64* [ %5, %15 ], [ %5, %9 ], [ %28, %106 ]
%111 = phi i32 [ 0, %15 ], [ 0, %9 ], [ %30, %106 ]
br label %126
112: ; preds = %3
%113 = bitcast i8* %1 to <2 x i64>*
%114 = load <2 x i64>, <2 x i64>* %113
%115 = getelementptr inbounds i8, i8* %1, i64 16
%116 = bitcast i8* %115 to <2 x i64>*
%117 = load <2 x i64>, <2 x i64>* %116
%118 = getelementptr inbounds i8, i8* %1, i64 32
%119 = bitcast i8* %118 to i64*
%120 = load i64, i64* %119
%121 = bitcast i8* %0 to <2 x i64>*
store <2 x i64> %114, <2 x i64>* %121
%122 = getelementptr inbounds i8, i8* %0, i64 16
%123 = bitcast i8* %122 to <2 x i64>*
store <2 x i64> %117, <2 x i64>* %123
%124 = getelementptr inbounds i8, i8* %0, i64 32
%125 = bitcast i8* %124 to i64*
store i64 %120, i64* %125
br label %135
126: ; preds = %108, %126
%127 = phi i64* [ %131, %126 ], [ %109, %108 ]
%128 = phi i64* [ %132, %126 ], [ %110, %108 ]
%129 = phi i32 [ %133, %126 ], [ %111, %108 ]
%130 = load i64, i64* %128
store i64 %130, i64* %127
%131 = getelementptr inbounds i64, i64* %127, i64 1
%132 = getelementptr inbounds i64, i64* %128, i64 1
%133 = add nuw nsw i32 %129, 8
%134 = icmp slt i32 %133, %2
br i1 %134, label %126, label %135
135: ; preds = %126, %106, %7, %112
ret void
}