xunge/DecIR huggingface dataset:
/* Variables and functions */
int /*<<< orphan*/ uart_puts(char *);
void halt() {
  uart_puts("Halting!\n\r");
  while (1)
    ;
}


x86 assembly (clang, -O0):
<halt>:
push   %rbp
mov    %rsp,%rbp
lea    0xee5(%rip),%rdi
call   1030 <uart_puts@plt>
jmp    1120 <halt+0x10>

x86 assembly (clang, -O2):
<halt>:
push   %rax
lea    0xee8(%rip),%rdi
call   1030 <uart_puts@plt>
nopl   (%rax)
jmp    1120 <halt+0x10>

LLVM IR (-O0):
@.str = [11 x i8] c"Halting!\0A\0D\00"
define void @halt() {
%1 = call i32 @uart_puts(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0))
br label %2
2: ; preds = %0, %2
br label %2
}

LLVM IR (-O2):
@.str = [11 x i8] c"Halting!\0A\0D\00"
define void @halt() {
%1 = tail call i32 @uart_puts(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0))
br label %2
2: ; preds = %0, %2
br label %2
}
char *copyin(register char *src, char **space) {
  register char *cp;
  char *top;
  top = cp = *space;
  while ((*cp++ = *src++) != '\0')
    ;
  *space = cp;
  return (top);
}


x86 assembly (clang, -O0):
<copyin>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x18(%rbp)
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%al
mov    -0x18(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %al,(%rcx)
movsbl %al,%eax
cmp    $0x0,%eax
je     114e <copyin+0x4e>
jmp    111b <copyin+0x1b>
mov    -0x18(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<copyin>:
mov    (%rsi),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rdi,%rcx,1),%edx
mov    %dl,(%rax,%rcx,1)
add    $0x1,%rcx
test   %dl,%dl
jne    1110 <copyin+0x10>
add    %rax,%rcx
mov    %rcx,(%rsi)
ret

LLVM IR (-O0):
define i8* @copyin(i8* %0, i8** %1) {
%3 = alloca i8*
%4 = alloca i8**
%5 = alloca i8*
%6 = alloca i8*
store i8* %0, i8** %3
store i8** %1, i8*** %4
%7 = load i8**, i8*** %4
%8 = load i8*, i8** %7
store i8* %8, i8** %5
store i8* %8, i8** %6
br label %9
9: ; preds = %17, %2
%10 = load i8*, i8** %3
%11 = getelementptr inbounds i8, i8* %10, i32 1
store i8* %11, i8** %3
%12 = load i8, i8* %10
%13 = load i8*, i8** %5
%14 = getelementptr inbounds i8, i8* %13, i32 1
store i8* %14, i8** %5
store i8 %12, i8* %13
%15 = sext i8 %12 to i32
%16 = icmp ne i32 %15, 0
br i1 %16, label %17, label %18
17: ; preds = %9
br label %9
18: ; preds = %9
%19 = load i8*, i8** %5
%20 = load i8**, i8*** %4
store i8* %19, i8** %20
%21 = load i8*, i8** %6
ret i8* %21
}

LLVM IR (-O2):
define i8* @copyin(i8* nocapture %0, i8** nocapture %1) {
%3 = load i8*, i8** %1
br label %4
4: ; preds = %4, %2
%5 = phi i8* [ %3, %2 ], [ %9, %4 ]
%6 = phi i8* [ %0, %2 ], [ %7, %4 ]
%7 = getelementptr inbounds i8, i8* %6, i64 1
%8 = load i8, i8* %6
%9 = getelementptr inbounds i8, i8* %5, i64 1
store i8 %8, i8* %5
%10 = icmp eq i8 %8, 0
br i1 %10, label %11, label %4
11: ; preds = %4
store i8* %9, i8** %1
ret i8* %3
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *, double);
int /*<<< orphan*/ scanf(char *, int *);
int main() {
  int R;
  double VOLUME;
  scanf("%d", &R);
  VOLUME = ((4.0 / 3) * 3.14159 * R * R * R);
  printf("VOLUME = %.3lf\n", VOLUME);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xed2(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1040 <scanf@plt>
cvtsi2sdl -0x8(%rbp),%xmm1
movsd  0xeb4(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x8(%rbp),%xmm1
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x8(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  -0x10(%rbp),%xmm0
lea    0xe98(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
lea    0xee0(%rip),%rdi
lea    0x4(%rsp),%rsi
call   1040 <scanf@plt>
cvtsi2sdl 0x4(%rsp),%xmm1
movsd  0xec0(%rip),%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm1,%xmm0
lea    0xeb8(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%d\00"
@.str.1 = [16 x i8] c"VOLUME = %.3lf\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca double
store i32 0, i32* %1
%4 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %2)
%5 = load i32, i32* %2
%6 = sitofp i32 %5 to double
%7 = fmul double 0x4010C1514ABD0449, %6
%8 = load i32, i32* %2
%9 = sitofp i32 %8 to double
%10 = fmul double %7, %9
%11 = load i32, i32* %2
%12 = sitofp i32 %11 to double
%13 = fmul double %10, %12
store double %13, double* %3
%14 = load double, double* %3
%15 = call i32 @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0), double %14)
ret i32 0
}

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@.str.1 = [16 x i8] c"VOLUME = %.3lf\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = bitcast i32* %1 to i8*
%3 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%4 = load i32, i32* %1
%5 = sitofp i32 %4 to double
%6 = fmul double %5, 0x4010C1514ABD0449
%7 = fmul double %6, %5
%8 = fmul double %7, %5
%9 = call i32 @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0), double %8)
ret i32 0
}
int slen(char *s) {
  int rval;
  for (rval = 0; *s != 0; s++, rval++)
    ;
  return rval;
}


x86 assembly (clang, -O0):
<slen>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     113e <slen+0x3e>
jmp    1124 <slen+0x24>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    110f <slen+0xf>
mov    -0xc(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<slen>:
cmpb   $0x0,(%rdi)
je     111c <slen+0x1c>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
cmpb   $0x0,0x1(%rdi,%rax,1)
lea    0x1(%rax),%rax
jne    1110 <slen+0x10>
ret
xor    %eax,%eax
ret

LLVM IR (-O0):
define i32 @slen(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
store i8* %0, i8** %2
store i32 0, i32* %3
br label %4
4: ; preds = %10, %1
%5 = load i8*, i8** %2
%6 = load i8, i8* %5
%7 = sext i8 %6 to i32
%8 = icmp ne i32 %7, 0
br i1 %8, label %9, label %15
9: ; preds = %4
br label %10
10: ; preds = %9
%11 = load i8*, i8** %2
%12 = getelementptr inbounds i8, i8* %11, i32 1
store i8* %12, i8** %2
%13 = load i32, i32* %3
%14 = add nsw i32 %13, 1
store i32 %14, i32* %3
br label %4
15: ; preds = %4
%16 = load i32, i32* %3
ret i32 %16
}

LLVM IR (-O2):
define i32 @slen(i8* nocapture %0) {
%2 = load i8, i8* %0
%3 = icmp eq i8 %2, 0
br i1 %3, label %11, label %4
4: ; preds = %1, %4
%5 = phi i32 [ %8, %4 ], [ 0, %1 ]
%6 = phi i8* [ %7, %4 ], [ %0, %1 ]
%7 = getelementptr inbounds i8, i8* %6, i64 1
%8 = add nuw nsw i32 %5, 1
%9 = load i8, i8* %7
%10 = icmp eq i8 %9, 0
br i1 %10, label %11, label %4
11: ; preds = %4, %1
%12 = phi i32 [ 0, %1 ], [ %8, %4 ]
ret i32 %12
}
/* Variables and functions */
double exp(double);
int /*<<< orphan*/ printf(char *, double, double);
int main() {
  double param, result;
  param = 5.0;
  result = exp(param);
  printf("The exponential value of %f is %f.\n", param, result);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movl   $0x0,-0x4(%rbp)
movsd  0xec9(%rip),%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  -0x10(%rbp),%xmm0
call   1040 <exp@plt>
movsd  %xmm0,-0x18(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm1
lea    0xeac(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
lea    0xef8(%rip),%rdi
movsd  0xee0(%rip),%xmm0
movsd  0xee0(%rip),%xmm1
call   1030 <printf@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [36 x i8] c"The exponential value of %f is %f.\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca double
%3 = alloca double
store i32 0, i32* %1
store double 5.000000e+00, double* %2
%4 = load double, double* %2
%5 = call double @exp(double %4)
store double %5, double* %3
%6 = load double, double* %2
%7 = load double, double* %3
%8 = call i32 @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0), double %6, double %7)
ret i32 0
}

LLVM IR (-O2):
@.str = [36 x i8] c"The exponential value of %f is %f.\0A\00"
define i32 @main() {
%1 = tail call i32 @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0), double 5.000000e+00, double 0x40628D389970338F)
ret i32 0
}
float f1(float f) { return -f; }


x86 assembly (clang, -O0):
<f1>:
push   %rbp
mov    %rsp,%rbp
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<f1>:
xorps  0xef9(%rip),%xmm0
ret

LLVM IR (-O0):
define float @f1(float %0) {
%2 = alloca float
store float %0, float* %2
%3 = load float, float* %2
%4 = fneg float %3
ret float %4
}

LLVM IR (-O2):
define float @f1(float %0) {
%2 = fneg float %0
ret float %2
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *, long long, long, int, int);
void main(int argc, char *argv[]) {
  long long a = 222222222222222112;
  long b = 222222222222222112;
  printf("%lld\n%ld\n,  %d:%d", a, b, sizeof a, sizeof b);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movabs $0x3157def08c0e320,%rax
7d 15 03
mov    %rax,-0x18(%rbp)
movabs $0x3157def08c0e320,%rax
7d 15 03
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
lea    0xeb6(%rip),%rdi
mov    $0x8,%r8d
mov    %r8d,%ecx
call   1030 <printf@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
lea    0xee9(%rip),%rdi
movabs $0x3157def08c0e320,%rdx
7d 15 03
mov    %rdx,%rsi
mov    $0x8,%ecx
mov    $0x8,%r8d
jmp    1030 <printf@plt>

LLVM IR (-O0):
@.str = [18 x i8] c"%lld\0A%ld\0A, %d:%d\00"
define void @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i8**
%5 = alloca i64
%6 = alloca i64
store i32 %0, i32* %3
store i8** %1, i8*** %4
store i64 222222222222222112, i64* %5
store i64 222222222222222112, i64* %6
%7 = load i64, i64* %5
%8 = load i64, i64* %6
%9 = call i32 @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i64 %7, i64 %8, i32 8, i32 8)
ret void
}

LLVM IR (-O2):
@.str = [18 x i8] c"%lld\0A%ld\0A, %d:%d\00"
define void @main(i32 %0, i8** nocapture readnone %1) {
%3 = tail call i32 @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i64 222222222222222112, i64 222222222222222112, i32 8, i32 8)
ret void
}
/* Type definitions */
typedef int uintmax_t;

/* Variables and functions */
uintmax_t char_to_multiplier(const char c) {
  uintmax_t ret = 0;
  switch (c) {
  case 'k':
  case 'K':
    ret = 1 << 10;
    break;
  case 'm':
  case 'M':
    ret = 1 << 20;
    break;
  case 'g':
  case 'G':
    ret = 1 << 30;
    break;
  case 't':
  case 'T':
    ret = (uintmax_t)1 << 40;
    break;
  case 'p':
  case 'P':
    ret = (uintmax_t)1 << 50;
    break;
  }
  return (ret);
}


x86 assembly (clang, -O0):
<char_to_multiplier>:
push   %rbp
mov    %rsp,%rbp
mov    %dil,%al
mov    %al,-0x1(%rbp)
movl   $0x0,-0x8(%rbp)
movsbl -0x1(%rbp),%eax
add    $0xffffffb9,%eax
mov    %eax,%ecx
mov    %rcx,-0x10(%rbp)
sub    $0x2d,%eax
ja     116a <char_to_multiplier+0x6a>
mov    -0x10(%rbp),%rax
lea    0xece(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x400,-0x8(%rbp)
jmp    116a <char_to_multiplier+0x6a>
movl   $0x100000,-0x8(%rbp)
jmp    116a <char_to_multiplier+0x6a>
movl   $0x40000000,-0x8(%rbp)
jmp    116a <char_to_multiplier+0x6a>
mov    %eax,-0x8(%rbp)
jmp    116a <char_to_multiplier+0x6a>
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<char_to_multiplier>:
xor    %eax,%eax
add    $0xffffffb9,%edi
cmp    $0x26,%edi
ja     1145 <char_to_multiplier+0x45>
movabs $0x100000001,%rcx
bt     %rdi,%rcx
jb     1140 <char_to_multiplier+0x40>
movabs $0x1000000010,%rcx
bt     %rdi,%rcx
jb     1146 <char_to_multiplier+0x46>
movabs $0x4000000040,%rcx
bt     %rdi,%rcx
jae    1145 <char_to_multiplier+0x45>
mov    $0x100000,%eax
ret
mov    $0x40000000,%eax
ret
mov    $0x400,%eax
ret

LLVM IR (-O0):
define i32 @char_to_multiplier(i8 signext %0) {
%2 = alloca i8
%3 = alloca i32
store i8 %0, i8* %2
store i32 0, i32* %3
%4 = load i8, i8* %2
%5 = sext i8 %4 to i32
switch i32 %5, label %11 [
i32 107, label %6
i32 75, label %6
i32 109, label %7
i32 77, label %7
i32 103, label %8
i32 71, label %8
i32 116, label %9
i32 84, label %9
i32 112, label %10
i32 80, label %10
]
6: ; preds = %1, %1
store i32 1024, i32* %3
br label %11
7: ; preds = %1, %1
store i32 1048576, i32* %3
br label %11
8: ; preds = %1, %1
store i32 1073741824, i32* %3
br label %11
9: ; preds = %1, %1
store i32 poison, i32* %3
br label %11
10: ; preds = %1, %1
store i32 poison, i32* %3
br label %11
11: ; preds = %1, %10, %9, %8, %7, %6
%12 = load i32, i32* %3
ret i32 %12
}

LLVM IR (-O2):
define i32 @char_to_multiplier(i8 signext %0) {
%2 = sext i8 %0 to i32
switch i32 %2, label %6 [
i32 107, label %3
i32 75, label %3
i32 109, label %4
i32 77, label %4
i32 103, label %5
i32 71, label %5
]
3: ; preds = %1, %1
br label %6
4: ; preds = %1, %1
br label %6
5: ; preds = %1, %1
br label %6
6: ; preds = %1, %5, %4, %3
%7 = phi i32 [ 1073741824, %5 ], [ 1048576, %4 ], [ 1024, %3 ], [ 0, %1 ]
ret i32 %7
}
/* Type definitions */
typedef scalar_t__ ulBase;

/* Variables and functions */
int /*<<< orphan*/ DEBUG_ASSERT(int);
int PWMGenValid(unsigned long);
void PWMGenEnable(unsigned long ulBase, unsigned long ulGen) {
  DEBUG_ASSERT((ulBase == 0x40028000) || (ulBase == 0x40029000));
  DEBUG_ASSERT(PWMGenValid(ulGen));
  (*((volatile unsigned long *)(((ulBase) + (ulGen)) + 0x00000000))) |=
      0x00000001;
}


x86 assembly (clang, -O0):
<PWMGenEnable>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    $0x1,%al
cmpq   $0x40028000,-0x8(%rbp)
40
mov    %al,-0x11(%rbp)
je     1151 <PWMGenEnable+0x31>
cmpq   $0x40029000,-0x8(%rbp)
40
sete   %al
mov    %al,-0x11(%rbp)
mov    -0x11(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <DEBUG_ASSERT@plt>
mov    -0x10(%rbp),%rdi
call   1040 <PWMGenValid@plt>
mov    %eax,%edi
call   1030 <DEBUG_ASSERT@plt>
mov    -0x8(%rbp),%rax
add    -0x10(%rbp),%rax
mov    (%rax),%rcx
or     $0x1,%rcx
mov    %rcx,(%rax)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<PWMGenEnable>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
mov    %rdi,%rax
and    $0xffffffffffffefff,%rax
xor    %edi,%edi
cmp    $0x40028000,%rax
sete   %dil
call   1030 <DEBUG_ASSERT@plt>
mov    %r14,%rdi
call   1040 <PWMGenValid@plt>
mov    %eax,%edi
call   1030 <DEBUG_ASSERT@plt>
orq    $0x1,(%r14,%rbx,1)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @PWMGenEnable(i64 %0, i64 %1) {
%3 = alloca i64
%4 = alloca i64
store i64 %0, i64* %3
store i64 %1, i64* %4
%5 = load i64, i64* %3
%6 = icmp eq i64 %5, 1073905664
br i1 %6, label %10, label %7
7: ; preds = %2
%8 = load i64, i64* %3
%9 = icmp eq i64 %8, 1073909760
br label %10
10: ; preds = %7, %2
%11 = phi i1 [ true, %2 ], [ %9, %7 ]
%12 = zext i1 %11 to i32
%13 = call i32 @DEBUG_ASSERT(i32 %12)
%14 = load i64, i64* %4
%15 = call i32 @PWMGenValid(i64 %14)
%16 = call i32 @DEBUG_ASSERT(i32 %15)
%17 = load i64, i64* %3
%18 = load i64, i64* %4
%19 = add i64 %17, %18
%20 = add i64 %19, 0
%21 = inttoptr i64 %20 to i64*
%22 = load volatile i64, i64* %21
%23 = or i64 %22, 1
store volatile i64 %23, i64* %21
ret void
}

LLVM IR (-O2):
define void @PWMGenEnable(i64 %0, i64 %1) {
%3 = and i64 %0, -4097
%4 = icmp eq i64 %3, 1073905664
%5 = zext i1 %4 to i32
%6 = tail call i32 @DEBUG_ASSERT(i32 %5)
%7 = tail call i32 @PWMGenValid(i64 %1)
%8 = tail call i32 @DEBUG_ASSERT(i32 %7)
%9 = add i64 %1, %0
%10 = inttoptr i64 %9 to i64*
%11 = load volatile i64, i64* %10
%12 = or i64 %11, 1
store volatile i64 %12, i64* %10
ret void
}
/* Variables and functions */
int /*<<< orphan*/ FreeNumP(double const *);
void free_num_p(const double *pointer) { FreeNumP(pointer); }


x86 assembly (clang, -O0):
<free_num_p>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <FreeNumP@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<free_num_p>:
jmp    1030 <FreeNumP@plt>

LLVM IR (-O0):
define void @free_num_p(double* %0) {
%2 = alloca double*
store double* %0, double** %2
%3 = load double*, double** %2
%4 = call i32 @FreeNumP(double* %3)
ret void
}

LLVM IR (-O2):
define void @free_num_p(double* %0) {
%2 = tail call i32 @FreeNumP(double* %0)
ret void
}
/* Type definitions */
struct cec_msg {
  int /*<<< orphan*/ *msg;
};
typedef int /*<<< orphan*/ __u8;

/* Variables and functions */
void cec_ops_record_status(const struct cec_msg *msg, __u8 *rec_status) {
  *rec_status = msg->msg[2];
}


x86 assembly (clang, -O0):
<cec_ops_record_status>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    0x8(%rax),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<cec_ops_record_status>:
mov    (%rdi),%rax
mov    0x8(%rax),%eax
mov    %eax,(%rsi)
ret

LLVM IR (-O0):
%struct.cec_msg = type { i32* }
define void @cec_ops_record_status(%struct.cec_msg* %0, i32* %1) {
%3 = alloca %struct.cec_msg*
%4 = alloca i32*
store %struct.cec_msg* %0, %struct.cec_msg** %3
store i32* %1, i32** %4
%5 = load %struct.cec_msg*, %struct.cec_msg** %3
%6 = getelementptr inbounds %struct.cec_msg, %struct.cec_msg* %5, i32 0, i32 0
%7 = load i32*, i32** %6
%8 = getelementptr inbounds i32, i32* %7, i64 2
%9 = load i32, i32* %8
%10 = load i32*, i32** %4
store i32 %9, i32* %10
ret void
}

LLVM IR (-O2):
%struct.cec_msg = type { i32* }
define void @cec_ops_record_status(%struct.cec_msg* nocapture %0, i32* nocapture writeonly %1) {
%3 = getelementptr inbounds %struct.cec_msg, %struct.cec_msg* %0, i64 0, i32 0
%4 = load i32*, i32** %3
%5 = getelementptr inbounds i32, i32* %4, i64 2
%6 = load i32, i32* %5
store i32 %6, i32* %1
ret void
}
/* Type definitions */
struct tm {
  int dummy;
};

/* Variables and functions */
char *fmt_iso8601(struct tm *);
int /*<<< orphan*/ printf(char *, char *);
void print_iso8601(struct tm *tmp) { printf("%s", fmt_iso8601(tmp)); }


x86 assembly (clang, -O0):
<print_iso8601>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <fmt_iso8601@plt>
mov    %rax,%rsi
lea    0xec1(%rip),%rdi
call   1030 <printf@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<print_iso8601>:
push   %rax
call   1040 <fmt_iso8601@plt>
lea    0xed3(%rip),%rdi
mov    %rax,%rsi
pop    %rax
jmp    1030 <printf@plt>

LLVM IR (-O0):
%struct.tm = type { i32 }
@.str = [3 x i8] c"%s\00"
define void @print_iso8601(%struct.tm* %0) {
%2 = alloca %struct.tm*
store %struct.tm* %0, %struct.tm** %2
%3 = load %struct.tm*, %struct.tm** %2
%4 = call i8* @fmt_iso8601(%struct.tm* %3)
%5 = call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %4)
ret void
}

LLVM IR (-O2):
%struct.tm = type { i32 }
@.str = [3 x i8] c"%s\00"
define void @print_iso8601(%struct.tm* %0) {
%2 = tail call i8* @fmt_iso8601(%struct.tm* %0)
%3 = tail call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %2)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ print_error(char *);
void readSerializedHeaderExtensions(char *tlvData, unsigned long long *pos,
                                    ...) {
  print_error("Sorry, readSerializedHeaderExtensions() not implemented yet.\n");
  return;
}


x86 assembly (clang, -O0):
<readSerializedHeaderExtensions>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    0xed9(%rip),%rdi
call   1030 <print_error@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<readSerializedHeaderExtensions>:
lea    0xee9(%rip),%rdi
jmp    1030 <print_error@plt>

LLVM IR (-O0):
@.str = [62 x i8] c"Sorry, readSerializedHeaderExtensions() not implemented yet.\0A\00"
define void @readSerializedHeaderExtensions(i8* %0, i64* %1, ...) {
%3 = alloca i8*
%4 = alloca i64*
store i8* %0, i8** %3
store i64* %1, i64** %4
%5 = call i32 @print_error(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [62 x i8] c"Sorry, readSerializedHeaderExtensions() not implemented yet.\0A\00"
define void @readSerializedHeaderExtensions(i8* nocapture readnone %0, i64* nocapture readnone %1, ...) {
%3 = tail call i32 @print_error(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str, i64 0, i64 0))
ret void
}
int istype(int tok) {
  switch (tok) {
  case 62:
  case 78:
  case 90:
  case 89:
  case 61:
  case 80:
  case 75:
  case 76:
  case 70:
  case 66:
  case 81:
  case 88:
  case 84:
  case 87:
  case 68:
  case 57:
    return 1;
  default:
    return 0;
  }
}


x86 assembly (clang, -O0):
<istype>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0xc(%rbp)
sub    $0x39,%eax
je     11c0 <istype+0xc0>
jmp    111b <istype+0x1b>
mov    -0xc(%rbp),%eax
add    $0xffffffc3,%eax
sub    $0x2,%eax
jb     11c0 <istype+0xc0>
jmp    112f <istype+0x2f>
mov    -0xc(%rbp),%eax
sub    $0x42,%eax
je     11c0 <istype+0xc0>
jmp    1140 <istype+0x40>
mov    -0xc(%rbp),%eax
sub    $0x44,%eax
je     11c0 <istype+0xc0>
jmp    1151 <istype+0x51>
mov    -0xc(%rbp),%eax
sub    $0x46,%eax
je     11c0 <istype+0xc0>
jmp    1162 <istype+0x62>
mov    -0xc(%rbp),%eax
add    $0xffffffb5,%eax
sub    $0x2,%eax
jb     11c0 <istype+0xc0>
jmp    1176 <istype+0x76>
mov    -0xc(%rbp),%eax
sub    $0x4e,%eax
je     11c0 <istype+0xc0>
jmp    1187 <istype+0x87>
mov    -0xc(%rbp),%eax
add    $0xffffffb0,%eax
sub    $0x2,%eax
jb     11c0 <istype+0xc0>
jmp    119b <istype+0x9b>
mov    -0xc(%rbp),%eax
sub    $0x54,%eax
je     11c0 <istype+0xc0>
jmp    11ac <istype+0xac>
mov    -0xc(%rbp),%eax
add    $0xffffffa9,%eax
sub    $0x3,%eax
ja     11cc <istype+0xcc>
jmp    11c0 <istype+0xc0>
movl   $0x1,-0x4(%rbp)
jmp    11d3 <istype+0xd3>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<istype>:
add    $0xffffffc7,%edi
xor    %eax,%eax
cmp    $0x21,%edi
ja     1117 <istype+0x17>
movslq %edi,%rax
lea    0xeec(%rip),%rcx
mov    (%rcx,%rax,4),%eax
ret

LLVM IR (-O0):
define i32 @istype(i32 %0) {
%2 = alloca i32
%3 = alloca i32
store i32 %0, i32* %3
%4 = load i32, i32* %3
switch i32 %4, label %6 [
i32 62, label %5
i32 78, label %5
i32 90, label %5
i32 89, label %5
i32 61, label %5
i32 80, label %5
i32 75, label %5
i32 76, label %5
i32 70, label %5
i32 66, label %5
i32 81, label %5
i32 88, label %5
i32 84, label %5
i32 87, label %5
i32 68, label %5
i32 57, label %5
]
5: ; preds = %1, %1, %1, %1, %1, %1, %1, %1, %1, %1, %1, %1, %1, %1, %1, %1
store i32 1, i32* %2
br label %7
6: ; preds = %1
store i32 0, i32* %2
br label %7
7: ; preds = %6, %5
%8 = load i32, i32* %2
ret i32 %8
}

LLVM IR (-O2):
@switch.table.istype = [34 x i32] [i32 1, i32 0, i32 0, i32 0, i32 1, i32 1, i32 0, i32 0, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 0, i32 0, i32 0, i32 1, i32 1, i32 0, i32 1, i32 0, i32 1, i32 1, i32 0, i32 0, i32 1, i32 0, i32 0, i32 1, i32 1, i32 1, i32 1]
define i32 @istype(i32 %0) {
%2 = add i32 %0, -57
%3 = icmp ult i32 %2, 34
br i1 %3, label %4, label %8
4: ; preds = %1
%5 = sext i32 %2 to i64
%6 = getelementptr inbounds [34 x i32], [34 x i32]* @switch.table.istype, i64 0, i64 %5
%7 = load i32, i32* %6
br label %8
8: ; preds = %1, %4
%9 = phi i32 [ %7, %4 ], [ 0, %1 ]
ret i32 %9
}
/* Type definitions */
typedef scalar_t__ volatile uint32_t;

/* Variables and functions */
void ADCIntDisableEx(uint32_t ui32Base, uint32_t ui32IntFlags) {
  ;
  (*((volatile uint32_t *)(ui32Base + 0x00000008))) &= ~ui32IntFlags;
}


x86 assembly (clang, -O0):
<ADCIntDisableEx>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rcx
and    %rdx,%rcx
mov    %rcx,0x8(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<ADCIntDisableEx>:
mov    %rdi,-0x8(%rsp)
mov    %rsi,-0x10(%rsp)
mov    -0x10(%rsp),%rax
not    %rax
mov    -0x8(%rsp),%rcx
and    %rax,0x8(%rcx)
ret

LLVM IR (-O0):
define void @ADCIntDisableEx(i64 %0, i64 %1) {
%3 = alloca i64
%4 = alloca i64
store volatile i64 %0, i64* %3
store volatile i64 %1, i64* %4
%5 = load volatile i64, i64* %4
%6 = xor i64 %5, -1
%7 = load volatile i64, i64* %3
%8 = add nsw i64 %7, 8
%9 = inttoptr i64 %8 to i64*
%10 = load volatile i64, i64* %9
%11 = and i64 %10, %6
store volatile i64 %11, i64* %9
ret void
}

LLVM IR (-O2):
define void @ADCIntDisableEx(i64 %0, i64 %1) {
%3 = alloca i64
%4 = alloca i64
store volatile i64 %0, i64* %3
store volatile i64 %1, i64* %4
%5 = load volatile i64, i64* %4
%6 = xor i64 %5, -1
%7 = load volatile i64, i64* %3
%8 = add nsw i64 %7, 8
%9 = inttoptr i64 %8 to i64*
%10 = load volatile i64, i64* %9
%11 = and i64 %10, %6
store volatile i64 %11, i64* %9
ret void
}
int dup2(oldfd, newfd) {
  close(newfd);
  return fcntl(oldfd, 0, newfd);
}


x86 assembly (clang, -O0):
<dup2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    -0x8(%rbp),%edi
mov    $0x0,%al
call   1040 <close@plt>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%edx
xor    %esi,%esi
mov    $0x0,%al
call   1030 <fcntl@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dup2>:
push   %rbp
push   %rbx
push   %rax
mov    %esi,%ebx
mov    %edi,%ebp
mov    %esi,%edi
xor    %eax,%eax
call   1040 <close@plt>
mov    %ebp,%edi
xor    %esi,%esi
mov    %ebx,%edx
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %rbp
jmp    1030 <fcntl@plt>

LLVM IR (-O0):
define i32 @dup2(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
store i32 %0, i32* %3
store i32 %1, i32* %4
%5 = load i32, i32* %4
%6 = call i32 (i32, ...) bitcast (i32 (...)* @close to i32 (i32, ...)*)(i32 %5)
%7 = load i32, i32* %3
%8 = load i32, i32* %4
%9 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @fcntl to i32 (i32, i32, i32, ...)*)(i32 %7, i32 0, i32 %8)
ret i32 %9
}

LLVM IR (-O2):
define i32 @dup2(i32 %0, i32 %1) {
%3 = tail call i32 (i32, ...) bitcast (i32 (...)* @close to i32 (i32, ...)*)(i32 %1)
%4 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @fcntl to i32 (i32, i32, i32, ...)*)(i32 %0, i32 0, i32 %1)
ret i32 %4
}
/* Type definitions */
struct timespec {
  double tv_nsec;
  scalar_t__ tv_sec;
};

/* Variables and functions */
int TimeSpecToUSeconds(struct timespec *ts) {
  return (int)(ts->tv_sec + ts->tv_nsec / 1000.0);
}


x86 assembly (clang, -O0):
<TimeSpecToUSeconds>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
cvtsi2sdq 0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0xede(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<TimeSpecToUSeconds>:
cvtsi2sdq 0x8(%rdi),%xmm0
movsd  (%rdi),%xmm1
divsd  0xeee(%rip),%xmm1
addsd  %xmm0,%xmm1
cvttsd2si %xmm1,%eax
ret

LLVM IR (-O0):
%struct.timespec = type { double, i64 }
define i32 @TimeSpecToUSeconds(%struct.timespec* %0) {
%2 = alloca %struct.timespec*
store %struct.timespec* %0, %struct.timespec** %2
%3 = load %struct.timespec*, %struct.timespec** %2
%4 = getelementptr inbounds %struct.timespec, %struct.timespec* %3, i32 0, i32 1
%5 = load i64, i64* %4
%6 = sitofp i64 %5 to double
%7 = load %struct.timespec*, %struct.timespec** %2
%8 = getelementptr inbounds %struct.timespec, %struct.timespec* %7, i32 0, i32 0
%9 = load double, double* %8
%10 = fdiv double %9, 1.000000e+03
%11 = fadd double %6, %10
%12 = fptosi double %11 to i32
ret i32 %12
}

LLVM IR (-O2):
%struct.timespec = type { double, i64 }
define i32 @TimeSpecToUSeconds(%struct.timespec* nocapture %0) {
%2 = getelementptr inbounds %struct.timespec, %struct.timespec* %0, i64 0, i32 1
%3 = load i64, i64* %2
%4 = sitofp i64 %3 to double
%5 = getelementptr inbounds %struct.timespec, %struct.timespec* %0, i64 0, i32 0
%6 = load double, double* %5
%7 = fdiv double %6, 1.000000e+03
%8 = fadd double %7, %4
%9 = fptosi double %8 to i32
ret i32 %9
}
/* Variables and functions */
int /*<<< orphan*/ errno;
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char const *);
int /*<<< orphan*/ stderr;
char *strerror(int /*<<< orphan*/);
void perror(const char *s) {
  if (s != NULL) {
    fprintf(stderr, "%s", s);
  }
  fprintf(stderr, ": %s\n", strerror(errno));
}


x86 assembly (clang, -O0):
<perror>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
cmpq   $0x0,-0x8(%rbp)
je     1150 <perror+0x30>
mov    0x2ea2(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%rdx
lea    0xeb5(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2e89(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0xc(%rbp)
mov    0x2e75(%rip),%rax
mov    (%rax),%edi
call   1040 <strerror@plt>
mov    -0xc(%rbp),%edi
mov    %rax,%rdx
lea    0xe8c(%rip),%rsi
call   1030 <fprintf@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<perror>:
push   %rbx
test   %rdi,%rdi
je     113e <perror+0x1e>
mov    %rdi,%rdx
mov    0x2eb0(%rip),%rax
mov    (%rax),%edi
lea    0xec7(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2e9b(%rip),%rax
mov    (%rax),%ebx
mov    0x2e8a(%rip),%rax
mov    (%rax),%edi
call   1040 <strerror@plt>
lea    0xea7(%rip),%rsi
mov    %ebx,%edi
mov    %rax,%rdx
pop    %rbx
jmp    1030 <fprintf@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [3 x i8] c"%s\00"
@.str.1 = [6 x i8] c": %s\0A\00"
@errno = global i32 0
define void @perror(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = icmp ne i8* %3, null
br i1 %4, label %5, label %9
5: ; preds = %1
%6 = load i32, i32* @stderr
%7 = load i8*, i8** %2
%8 = call i32 @fprintf(i32 %6, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %7)
br label %9
9: ; preds = %5, %1
%10 = load i32, i32* @stderr
%11 = load i32, i32* @errno
%12 = call i8* @strerror(i32 %11)
%13 = call i32 @fprintf(i32 %10, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i8* %12)
ret void
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [3 x i8] c"%s\00"
@.str.1 = [6 x i8] c": %s\0A\00"
@errno = global i32 0
define void @perror(i8* %0) {
%2 = icmp eq i8* %0, null
br i1 %2, label %6, label %3
3: ; preds = %1
%4 = load i32, i32* @stderr
%5 = tail call i32 @fprintf(i32 %4, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %0)
br label %6
6: ; preds = %3, %1
%7 = load i32, i32* @stderr
%8 = load i32, i32* @errno
%9 = tail call i8* @strerror(i32 %8)
%10 = tail call i32 @fprintf(i32 %7, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i8* %9)
ret void
}
/* Variables and functions */
int atoi(char *);
int /*<<< orphan*/ func1(int);
int main(int argc, char *argv[]) {
  int n;
  n = atoi(argv[1]);
  func1(n);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1040 <atoi@plt>
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%edi
call   1030 <func1@plt>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
mov    0x8(%rsi),%rdi
call   1040 <atoi@plt>
mov    %eax,%edi
call   1030 <func1@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i8**
%5 = alloca i32
store i32 %0, i32* %3
store i8** %1, i8*** %4
%6 = load i8**, i8*** %4
%7 = getelementptr inbounds i8*, i8** %6, i64 1
%8 = load i8*, i8** %7
%9 = call i32 @atoi(i8* %8)
store i32 %9, i32* %5
%10 = load i32, i32* %5
%11 = call i32 @func1(i32 %10)
ret i32 0
}

LLVM IR (-O2):
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = getelementptr inbounds i8*, i8** %1, i64 1
%4 = load i8*, i8** %3
%5 = tail call i32 @atoi(i8* %4)
%6 = tail call i32 @func1(i32 %5)
ret i32 0
}
/* Variables and functions */
int /*<<< orphan*/ BNCIO(int /*<<< orphan*/);
long int BNC_0() {
  long int stat = 99;
  BNCIO(0);
  return (stat);
}


x86 assembly (clang, -O0):
<BNC_0>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movq   $0x63,-0x8(%rbp)
xor    %edi,%edi
call   1030 <BNCIO@plt>
mov    -0x8(%rbp),%rax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<BNC_0>:
push   %rax
xor    %edi,%edi
call   1030 <BNCIO@plt>
mov    $0x63,%eax
pop    %rcx
ret

LLVM IR (-O0):
define i64 @BNC_0() {
%1 = alloca i64
store i64 99, i64* %1
%2 = call i32 @BNCIO(i32 0)
%3 = load i64, i64* %1
ret i64 %3
}

LLVM IR (-O2):
define i64 @BNC_0() {
%1 = tail call i32 @BNCIO(i32 0)
ret i64 99
}
PHP_FUNCTION(usleep) {}


x86 assembly (clang, -O0):
<PHP_FUNCTION>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x8(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<PHP_FUNCTION>:
ret

LLVM IR (-O0):
define i32 @PHP_FUNCTION(i32 %0) {
%2 = alloca i32
%3 = alloca i32
store i32 %0, i32* %3
%4 = load i32, i32* %2
ret i32 %4
}

LLVM IR (-O2):
define i32 @PHP_FUNCTION(i32 %0) {
ret i32 undef
}
void gtk_tooltips_force_window() {}


x86 assembly (clang, -O0):
<gtk_tooltips_force_window>:
push   %rbp
mov    %rsp,%rbp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gtk_tooltips_force_window>:
ret

LLVM IR (-O0):
define void @gtk_tooltips_force_window() {
ret void
}

LLVM IR (-O2):
define void @gtk_tooltips_force_window() {
ret void
}
/* Type definitions */
struct Heap {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ clearHeap(struct Heap *);
int /*<<< orphan*/ free(void *);
void freeHeap(struct Heap **heap) {
  clearHeap(*heap);
  free((void *)*heap);
  heap = NULL;
}


x86 assembly (clang, -O0):
<freeHeap>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rdi
call   1040 <clearHeap@plt>
mov    -0x8(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
movq   $0x0,-0x8(%rbp)
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<freeHeap>:
push   %rbx
mov    %rdi,%rbx
mov    (%rdi),%rdi
call   1040 <clearHeap@plt>
mov    (%rbx),%rdi
pop    %rbx
jmp    1030 <free@plt>

LLVM IR (-O0):
%struct.Heap = type { i32 }
define void @freeHeap(%struct.Heap** %0) {
%2 = alloca %struct.Heap**
store %struct.Heap** %0, %struct.Heap*** %2
%3 = load %struct.Heap**, %struct.Heap*** %2
%4 = load %struct.Heap*, %struct.Heap** %3
%5 = call i32 @clearHeap(%struct.Heap* %4)
%6 = load %struct.Heap**, %struct.Heap*** %2
%7 = load %struct.Heap*, %struct.Heap** %6
%8 = bitcast %struct.Heap* %7 to i8*
%9 = call i32 @free(i8* %8)
store %struct.Heap** null, %struct.Heap*** %2
ret void
}

LLVM IR (-O2):
%struct.Heap = type { i32 }
define void @freeHeap(%struct.Heap** nocapture %0) {
%2 = load %struct.Heap*, %struct.Heap** %0
%3 = tail call i32 @clearHeap(%struct.Heap* %2)
%4 = bitcast %struct.Heap** %0 to i8**
%5 = load i8*, i8** %4
%6 = tail call i32 @free(i8* %5)
ret void
}
/* Type definitions */
struct UPnPService {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ printf(char *, int);
void RNDResponseSink_RenderingControl_SelectPreset(struct UPnPService *Service,
                                                   int ErrorCode, void *User) {
  printf(
      "RND Invoke Response: RenderingControl/SelectPreset[ErrorCode:%d]()\r\n",
      ErrorCode);
}


x86 assembly (clang, -O0):
<RNDResponseSink_RenderingControl_SelectPreset>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0xc(%rbp),%esi
lea    0xed3(%rip),%rdi
call   1030 <printf@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<RNDResponseSink_RenderingControl_SelectPreset>:
lea    0xee9(%rip),%rdi
jmp    1030 <printf@plt>

LLVM IR (-O0):
%struct.UPnPService = type { i32 }
@.str = [69 x i8] c"RND Invoke Response: RenderingControl/SelectPreset[ErrorCode:%d]()\0D\0A\00"
define void @RNDResponseSink_RenderingControl_SelectPreset(%struct.UPnPService* %0, i32 %1, i8* %2) {
%4 = alloca %struct.UPnPService*
%5 = alloca i32
%6 = alloca i8*
store %struct.UPnPService* %0, %struct.UPnPService** %4
store i32 %1, i32* %5
store i8* %2, i8** %6
%7 = load i32, i32* %5
%8 = call i32 @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str, i64 0, i64 0), i32 %7)
ret void
}

LLVM IR (-O2):
%struct.UPnPService = type { i32 }
@.str = [69 x i8] c"RND Invoke Response: RenderingControl/SelectPreset[ErrorCode:%d]()\0D\0A\00"
define void @RNDResponseSink_RenderingControl_SelectPreset(%struct.UPnPService* nocapture readnone %0, i32 %1, i8* nocapture readnone %2) {
%4 = tail call i32 @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str, i64 0, i64 0), i32 %1)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ GL_MODELVIEW;
int /*<<< orphan*/ GL_PROJECTION;
int /*<<< orphan*/ glMatrixMode(int /*<<< orphan*/);
int /*<<< orphan*/ glPopMatrix();
void resetPerspectiveProjection() {
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);
}


x86 assembly (clang, -O0):
<resetPerspectiveProjection>:
push   %rbp
mov    %rsp,%rbp
mov    0x2ead(%rip),%rax
mov    (%rax),%edi
call   1030 <glMatrixMode@plt>
mov    $0x0,%al
call   1040 <glPopMatrix@plt>
mov    0x2ea8(%rip),%rax
mov    (%rax),%edi
call   1030 <glMatrixMode@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<resetPerspectiveProjection>:
push   %rax
mov    0x2eb0(%rip),%rax
mov    (%rax),%edi
call   1030 <glMatrixMode@plt>
xor    %eax,%eax
call   1040 <glPopMatrix@plt>
mov    0x2eab(%rip),%rax
mov    (%rax),%edi
pop    %rax
jmp    1030 <glMatrixMode@plt>

LLVM IR (-O0):
@GL_PROJECTION = global i32 0
@GL_MODELVIEW = global i32 0
define void @resetPerspectiveProjection() {
%1 = load i32, i32* @GL_PROJECTION
%2 = call i32 @glMatrixMode(i32 %1)
%3 = call i32 (...) @glPopMatrix()
%4 = load i32, i32* @GL_MODELVIEW
%5 = call i32 @glMatrixMode(i32 %4)
ret void
}

LLVM IR (-O2):
@GL_PROJECTION = global i32 0
@GL_MODELVIEW = global i32 0
define void @resetPerspectiveProjection() {
%1 = load i32, i32* @GL_PROJECTION
%2 = tail call i32 @glMatrixMode(i32 %1)
%3 = tail call i32 (...) @glPopMatrix()
%4 = load i32, i32* @GL_MODELVIEW
%5 = tail call i32 @glMatrixMode(i32 %4)
ret void
}
/* Variables and functions */
scalar_t__ isalpha(unsigned char volatile);
int t_isalpha(char ch) {
  volatile char xc = ch;
  volatile unsigned char xuc = ch;
  return isalpha(xc) && isalpha(xuc);
}


x86 assembly (clang, -O0):
<t_isalpha>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %dil,%al
mov    %al,-0x1(%rbp)
mov    -0x1(%rbp),%al
mov    %al,-0x2(%rbp)
mov    -0x1(%rbp),%al
mov    %al,-0x3(%rbp)
mov    -0x2(%rbp),%al
movzbl %al,%edi
call   1030 <isalpha@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x4(%rbp)
je     115c <t_isalpha+0x4c>
mov    -0x3(%rbp),%al
movzbl %al,%edi
call   1030 <isalpha@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x4(%rbp)
mov    -0x4(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<t_isalpha>:
push   %rax
mov    %dil,0x7(%rsp)
mov    %dil,0x6(%rsp)
movzbl 0x7(%rsp),%edi
call   1030 <isalpha@plt>
test   %rax,%rax
je     1141 <t_isalpha+0x31>
movzbl 0x6(%rsp),%edi
call   1030 <isalpha@plt>
mov    %rax,%rcx
xor    %eax,%eax
test   %rcx,%rcx
setne  %al
pop    %rcx
ret
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
define i32 @t_isalpha(i8 signext %0) {
%2 = alloca i8
%3 = alloca i8
%4 = alloca i8
store i8 %0, i8* %2
%5 = load i8, i8* %2
store volatile i8 %5, i8* %3
%6 = load i8, i8* %2
store volatile i8 %6, i8* %4
%7 = load volatile i8, i8* %3
%8 = call i64 @isalpha(i8 zeroext %7)
%9 = icmp ne i64 %8, 0
br i1 %9, label %10, label %14
10: ; preds = %1
%11 = load volatile i8, i8* %4
%12 = call i64 @isalpha(i8 zeroext %11)
%13 = icmp ne i64 %12, 0
br label %14
14: ; preds = %10, %1
%15 = phi i1 [ false, %1 ], [ %13, %10 ]
%16 = zext i1 %15 to i32
ret i32 %16
}

LLVM IR (-O2):
define i32 @t_isalpha(i8 signext %0) {
%2 = alloca i8
%3 = alloca i8
store volatile i8 %0, i8* %2
store volatile i8 %0, i8* %3
%4 = load volatile i8, i8* %2
%5 = tail call i64 @isalpha(i8 zeroext %4)
%6 = icmp eq i64 %5, 0
br i1 %6, label %12, label %7
7: ; preds = %1
%8 = load volatile i8, i8* %3
%9 = tail call i64 @isalpha(i8 zeroext %8)
%10 = icmp ne i64 %9, 0
%11 = zext i1 %10 to i32
br label %12
12: ; preds = %7, %1
%13 = phi i32 [ 0, %1 ], [ %11, %7 ]
ret i32 %13
}
/* Variables and functions */
int /*<<< orphan*/ mvaddstr(int, int, char *);
void fromwho(void) {
  mvaddstr(21, 13, "From Larry Bartz, Mark Hessling and William McBrine");
}


x86 assembly (clang, -O0):
<fromwho>:
push   %rbp
mov    %rsp,%rbp
mov    $0x15,%edi
mov    $0xd,%esi
lea    0xedb(%rip),%rdx
call   1030 <mvaddstr@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<fromwho>:
lea    0xee9(%rip),%rdx
mov    $0x15,%edi
mov    $0xd,%esi
jmp    1030 <mvaddstr@plt>

LLVM IR (-O0):
@.str = [52 x i8] c"From Larry Bartz, Mark Hessling and William McBrine\00"
define void @fromwho() {
%1 = call i32 @mvaddstr(i32 21, i32 13, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [52 x i8] c"From Larry Bartz, Mark Hessling and William McBrine\00"
define void @fromwho() {
%1 = tail call i32 @mvaddstr(i32 21, i32 13, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str, i64 0, i64 0))
ret void
}
int utf8_length(unsigned char x) {
  if (~x & 0x80)
    return 1;
  if ((x & 0xe0) == 0xc0)
    return 2;
  if ((x & 0xf0) == 0xe0)
    return 3;
  if ((x & 0xf8) == 0xf0)
    return 4;
  return (1);
}


x86 assembly (clang, -O0):
<utf8_length>:
push   %rbp
mov    %rsp,%rbp
mov    %dil,%al
mov    %al,-0x5(%rbp)
movzbl -0x5(%rbp),%eax
xor    $0xffffffff,%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     112b <utf8_length+0x2b>
movl   $0x1,-0x4(%rbp)
jmp    1192 <utf8_length+0x92>
movzbl -0x5(%rbp),%eax
and    $0xe0,%eax
cmp    $0xc0,%eax
jne    114b <utf8_length+0x4b>
movl   $0x2,-0x4(%rbp)
jmp    1192 <utf8_length+0x92>
movzbl -0x5(%rbp),%eax
and    $0xf0,%eax
cmp    $0xe0,%eax
jne    116b <utf8_length+0x6b>
movl   $0x3,-0x4(%rbp)
jmp    1192 <utf8_length+0x92>
movzbl -0x5(%rbp),%eax
and    $0xf8,%eax
cmp    $0xf0,%eax
jne    118b <utf8_length+0x8b>
movl   $0x4,-0x4(%rbp)
jmp    1192 <utf8_length+0x92>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<utf8_length>:
mov    $0x1,%eax
test   $0x80,%dil
je     1143 <utf8_length+0x43>
mov    %edi,%ecx
and    $0xffffffe0,%ecx
mov    $0x2,%eax
cmp    $0xc0,%ecx
je     1143 <utf8_length+0x43>
mov    %edi,%ecx
and    $0xfffffff0,%ecx
mov    $0x3,%eax
cmp    $0xe0,%ecx
je     1143 <utf8_length+0x43>
and    $0xfffffff8,%edi
xor    %eax,%eax
cmp    $0xf0,%edi
sete   %al
lea    (%rax,%rax,2),%eax
add    $0x1,%eax
ret

LLVM IR (-O0):
define i32 @utf8_length(i8 zeroext %0) {
%2 = alloca i32
%3 = alloca i8
store i8 %0, i8* %3
%4 = load i8, i8* %3
%5 = zext i8 %4 to i32
%6 = xor i32 %5, -1
%7 = and i32 %6, 128
%8 = icmp ne i32 %7, 0
br i1 %8, label %9, label %10
9: ; preds = %1
store i32 1, i32* %2
br label %29
10: ; preds = %1
%11 = load i8, i8* %3
%12 = zext i8 %11 to i32
%13 = and i32 %12, 224
%14 = icmp eq i32 %13, 192
br i1 %14, label %15, label %16
15: ; preds = %10
store i32 2, i32* %2
br label %29
16: ; preds = %10
%17 = load i8, i8* %3
%18 = zext i8 %17 to i32
%19 = and i32 %18, 240
%20 = icmp eq i32 %19, 224
br i1 %20, label %21, label %22
21: ; preds = %16
store i32 3, i32* %2
br label %29
22: ; preds = %16
%23 = load i8, i8* %3
%24 = zext i8 %23 to i32
%25 = and i32 %24, 248
%26 = icmp eq i32 %25, 240
br i1 %26, label %27, label %28
27: ; preds = %22
store i32 4, i32* %2
br label %29
28: ; preds = %22
store i32 1, i32* %2
br label %29
29: ; preds = %28, %27, %21, %15, %9
%30 = load i32, i32* %2
ret i32 %30
}

LLVM IR (-O2):
define i32 @utf8_length(i8 zeroext %0) {
%2 = zext i8 %0 to i32
%3 = and i32 %2, 128
%4 = icmp eq i32 %3, 0
br i1 %4, label %15, label %5
5: ; preds = %1
%6 = and i32 %2, 224
%7 = icmp eq i32 %6, 192
br i1 %7, label %15, label %8
8: ; preds = %5
%9 = and i32 %2, 240
%10 = icmp eq i32 %9, 224
br i1 %10, label %15, label %11
11: ; preds = %8
%12 = and i32 %2, 248
%13 = icmp eq i32 %12, 240
%14 = select i1 %13, i32 4, i32 1
br label %15
15: ; preds = %11, %8, %5, %1
%16 = phi i32 [ 1, %1 ], [ 2, %5 ], [ 3, %8 ], [ %14, %11 ]
ret i32 %16
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ setup_tcp_communication();
int main(int argc, char **argv) {
  setup_tcp_communication();
  printf("application quits\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    $0x0,%al
call   1040 <setup_tcp_communication@plt>
lea    0xebc(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rax
xor    %eax,%eax
call   1040 <setup_tcp_communication@plt>
lea    0xed1(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [19 x i8] c"application quits\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%6 = call i32 (...) @setup_tcp_communication()
%7 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0))
ret i32 0
}

LLVM IR (-O2):
@str = [18 x i8] c"application quits\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = tail call i32 (...) @setup_tcp_communication()
%4 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str, i64 0, i64 0))
ret i32 0
}
/* Variables and functions */
float App_Get_Ki();
int /*<<< orphan*/ File_Fifo_Respond(char *);
int /*<<< orphan*/ sprintf(char *, char *, float);
void File_Fifo_Get_I_Gain(void) {
  char buffer[50];
  float gain;
  gain = App_Get_Ki();
  sprintf(buffer, "1\n%4.2f\n", gain);
  File_Fifo_Respond(buffer);
}


x86 assembly (clang, -O0):
<File_Fifo_Get_I_Gain>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    $0x0,%al
call   1030 <App_Get_Ki@plt>
movss  %xmm0,-0x44(%rbp)
lea    -0x40(%rbp),%rdi
movss  -0x44(%rbp),%xmm0
lea    0xeac(%rip),%rsi
call   1050 <sprintf@plt>
lea    -0x40(%rbp),%rdi
call   1040 <File_Fifo_Respond@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<File_Fifo_Get_I_Gain>:
push   %rbx
sub    $0x40,%rsp
xor    %eax,%eax
call   1030 <App_Get_Ki@plt>
lea    0xebd(%rip),%rsi
mov    %rsp,%rbx
mov    %rbx,%rdi
call   1050 <sprintf@plt>
mov    %rbx,%rdi
call   1040 <File_Fifo_Respond@plt>
add    $0x40,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@.str = [9 x i8] c"1\0A%4.2f\0A\00"
define void @File_Fifo_Get_I_Gain() {
%1 = alloca [50 x i8]
%2 = alloca float
%3 = call float (...) @App_Get_Ki()
store float %3, float* %2
%4 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 0, i64 0
%5 = load float, float* %2
%6 = call i32 @sprintf(i8* %4, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), float %5)
%7 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 0, i64 0
%8 = call i32 @File_Fifo_Respond(i8* %7)
ret void
}

LLVM IR (-O2):
@.str = [9 x i8] c"1\0A%4.2f\0A\00"
define void @File_Fifo_Get_I_Gain() {
%1 = alloca [50 x i8]
%2 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 0, i64 0
%3 = tail call float (...) @App_Get_Ki()
%4 = call i32 @sprintf(i8* %2, i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), float %3)
%5 = call i32 @File_Fifo_Respond(i8* %2)
ret void
}