#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ XPointer;

/* Variables and functions */
int /*<<< orphan*/ memcpy(char *, char *, int);
void _XlcCopyToArg(char *src, char **dst, int size) {
  if (size == sizeof(long))
    *((long *)*dst) = *((long *)src);
  else if (size == sizeof(short))
    *((short *)*dst) = *((short *)src);
  else if (size == sizeof(char))
    *((char *)*dst) = *((char *)src);
  else if (size == sizeof(XPointer))
    *((XPointer *)*dst) = *((XPointer *)src);
  else
    memcpy(*dst, src, size);
}


x86 assembly (clang, -O0):
<_XlcCopyToArg>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movslq -0x14(%rbp),%rax
cmp    $0x8,%rax
jne    1147 <_XlcCopyToArg+0x37>
mov    -0x8(%rbp),%rax
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rcx,(%rax)
jmp    11d1 <_XlcCopyToArg+0xc1>
movslq -0x14(%rbp),%rax
cmp    $0x2,%rax
jne    116b <_XlcCopyToArg+0x5b>
mov    -0x8(%rbp),%rax
mov    (%rax),%cx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %cx,(%rax)
jmp    11cc <_XlcCopyToArg+0xbc>
movslq -0x14(%rbp),%rax
cmp    $0x1,%rax
jne    118d <_XlcCopyToArg+0x7d>
mov    -0x8(%rbp),%rax
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %cl,(%rax)
jmp    11c7 <_XlcCopyToArg+0xb7>
movslq -0x14(%rbp),%rax
cmp    $0x4,%rax
jne    11af <_XlcCopyToArg+0x9f>
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %ecx,(%rax)
jmp    11c2 <_XlcCopyToArg+0xb2>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   1030 <memcpy@plt>
jmp    11c7 <_XlcCopyToArg+0xb7>
jmp    11cc <_XlcCopyToArg+0xbc>
jmp    11d1 <_XlcCopyToArg+0xc1>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_XlcCopyToArg>:
mov    %rdi,%rax
lea    -0x1(%rdx),%ecx
cmp    $0x7,%ecx
ja     113d <_XlcCopyToArg+0x2d>
lea    0xede(%rip),%rdi
movslq (%rdi,%rcx,4),%rcx
add    %rdi,%rcx
jmp    *%rcx
mov    (%rax),%al
mov    (%rsi),%rcx
mov    %al,(%rcx)
ret
movzwl (%rax),%eax
mov    (%rsi),%rcx
mov    %ax,(%rcx)
ret
mov    (%rsi),%rdi
mov    %rax,%rsi
jmp    1030 <memcpy@plt>
mov    (%rax),%eax
mov    (%rsi),%rcx
mov    %eax,(%rcx)
ret
mov    (%rax),%rax
mov    (%rsi),%rcx
mov    %rax,(%rcx)
ret

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

LLVM IR (-O2):
define void @_XlcCopyToArg(i8* %0, i8** nocapture %1, i32 %2) {
switch i32 %2, label %22 [
i32 8, label %4
i32 2, label %9
i32 1, label %14
i32 4, label %17
]
4: ; preds = %3
%5 = bitcast i8* %0 to i64*
%6 = load i64, i64* %5
%7 = bitcast i8** %1 to i64**
%8 = load i64*, i64** %7
store i64 %6, i64* %8
br label %25
9: ; preds = %3
%10 = bitcast i8* %0 to i16*
%11 = load i16, i16* %10
%12 = bitcast i8** %1 to i16**
%13 = load i16*, i16** %12
store i16 %11, i16* %13
br label %25
14: ; preds = %3
%15 = load i8, i8* %0
%16 = load i8*, i8** %1
store i8 %15, i8* %16
br label %25
17: ; preds = %3
%18 = bitcast i8* %0 to i32*
%19 = load i32, i32* %18
%20 = bitcast i8** %1 to i32**
%21 = load i32*, i32** %20
store i32 %19, i32* %21
br label %25
22: ; preds = %3
%23 = load i8*, i8** %1
%24 = tail call i32 @memcpy(i8* %23, i8* %0, i32 %2)
br label %25
25: ; preds = %9, %17, %22, %14, %4
ret void
}