xunge/DecIR huggingface dataset:
void close_oldrelayfs(int detach) {}


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

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

LLVM IR (-O0):
define void @close_oldrelayfs(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
ret void
}

LLVM IR (-O2):
define void @close_oldrelayfs(i32 %0) {
ret void
}
/* Type definitions */
struct pool_val {
  int dummy;
};
struct pool {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ deserialize_int(char **, int *);
struct pool_val *pool(struct pool *, char *, int);
struct pool_val *deserialize_string(char **f, struct pool *p, int type) {
  struct pool_val *ret;
  int len;
  deserialize_int(f, &len);
  ret = pool(p, *f, type);
  *f += len;
  return ret;
}


x86 assembly (clang, -O0):
<deserialize_string>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x24(%rbp),%rsi
call   1040 <deserialize_int@plt>
mov    -0x10(%rbp),%rdi
mov    -0x8(%rbp),%rax
mov    (%rax),%rsi
mov    -0x14(%rbp),%edx
call   1030 <pool@plt>
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<deserialize_string>:
push   %rbp
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %edx,%r14d
mov    %rsi,%rbx
mov    %rdi,%rbp
lea    0xc(%rsp),%rsi
call   1040 <deserialize_int@plt>
mov    0x0(%rbp),%rsi
mov    %rbx,%rdi
mov    %r14d,%edx
call   1030 <pool@plt>
movslq 0xc(%rsp),%rcx
add    %rcx,0x0(%rbp)
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
%struct.pool_val = type { i32 }
%struct.pool = type { i32 }
define %struct.pool_val* @deserialize_string(i8** %0, %struct.pool* %1, i32 %2) {
%4 = alloca i8**
%5 = alloca %struct.pool*
%6 = alloca i32
%7 = alloca %struct.pool_val*
%8 = alloca i32
store i8** %0, i8*** %4
store %struct.pool* %1, %struct.pool** %5
store i32 %2, i32* %6
%9 = load i8**, i8*** %4
%10 = call i32 @deserialize_int(i8** %9, i32* %8)
%11 = load %struct.pool*, %struct.pool** %5
%12 = load i8**, i8*** %4
%13 = load i8*, i8** %12
%14 = load i32, i32* %6
%15 = call %struct.pool_val* @pool(%struct.pool* %11, i8* %13, i32 %14)
store %struct.pool_val* %15, %struct.pool_val** %7
%16 = load i32, i32* %8
%17 = load i8**, i8*** %4
%18 = load i8*, i8** %17
%19 = sext i32 %16 to i64
%20 = getelementptr inbounds i8, i8* %18, i64 %19
store i8* %20, i8** %17
%21 = load %struct.pool_val*, %struct.pool_val** %7
ret %struct.pool_val* %21
}

LLVM IR (-O2):
%struct.pool_val = type { i32 }
%struct.pool = type { i32 }
define %struct.pool_val* @deserialize_string(i8** %0, %struct.pool* %1, i32 %2) {
%4 = alloca i32
%5 = bitcast i32* %4 to i8*
%6 = call i32 @deserialize_int(i8** %0, i32* %4)
%7 = load i8*, i8** %0
%8 = call %struct.pool_val* @pool(%struct.pool* %1, i8* %7, i32 %2)
%9 = load i32, i32* %4
%10 = load i8*, i8** %0
%11 = sext i32 %9 to i64
%12 = getelementptr inbounds i8, i8* %10, i64 %11
store i8* %12, i8** %0
ret %struct.pool_val* %8
}
/* Variables and functions */
int rj_writebyte(int, int /*<<< orphan*/);
int rj485_send(unsigned char *buf, int len) {
  int i, rval;
  for (i = 0; i < len; i++)
    rval = rj_writebyte(0x20, *buf++);
  return rval;
}


x86 assembly (clang, -O0):
<rj485_send>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    115f <rj485_send+0x4f>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%esi
mov    $0x20,%edi
call   1030 <rj_writebyte@plt>
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1126 <rj485_send+0x16>
mov    -0x14(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rj485_send>:
test   %esi,%esi
jle    114e <rj485_send+0x3e>
push   %r15
push   %r14
push   %rbx
mov    %rdi,%r14
mov    %esi,%r15d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rbx,1),%esi
mov    $0x20,%edi
call   1030 <rj_writebyte@plt>
add    $0x1,%rbx
cmp    %ebx,%r15d
jne    1130 <rj485_send+0x20>
pop    %rbx
pop    %r14
pop    %r15
ret
ret

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

LLVM IR (-O2):
define i32 @rj485_send(i8* nocapture %0, i32 %1) {
%3 = icmp sgt i32 %1, 0
br i1 %3, label %4, label %13
4: ; preds = %2, %4
%5 = phi i32 [ %11, %4 ], [ 0, %2 ]
%6 = phi i8* [ %7, %4 ], [ %0, %2 ]
%7 = getelementptr inbounds i8, i8* %6, i64 1
%8 = load i8, i8* %6
%9 = zext i8 %8 to i32
%10 = tail call i32 @rj_writebyte(i32 32, i32 %9)
%11 = add nuw nsw i32 %5, 1
%12 = icmp eq i32 %11, %1
br i1 %12, label %13, label %4
13: ; preds = %4, %2
%14 = phi i32 [ undef, %2 ], [ %10, %4 ]
ret i32 %14
}
unsigned char returnmask(int x) {
  unsigned long long ret = 1ULL;
  ret <<= 8 * sizeof(int);
  ret -= (unsigned long long)(unsigned int)x;
  ret >>= 8 * sizeof(int);
  return ret - 1;
}


x86 assembly (clang, -O0):
<returnmask>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
movq   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%rax
shl    $0x20,%rax
mov    %rax,-0x10(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
shr    $0x20,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
movzbl %al,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<returnmask>:
mov    %edi,%ecx
movabs $0x100000000,%rax
sub    %rcx,%rax
shr    $0x20,%rax
add    $0xff,%al
ret

LLVM IR (-O0):
define zeroext i8 @returnmask(i32 %0) {
%2 = alloca i32
%3 = alloca i64
store i32 %0, i32* %2
store i64 1, i64* %3
%4 = load i64, i64* %3
%5 = shl i64 %4, 32
store i64 %5, i64* %3
%6 = load i32, i32* %2
%7 = zext i32 %6 to i64
%8 = load i64, i64* %3
%9 = sub i64 %8, %7
store i64 %9, i64* %3
%10 = load i64, i64* %3
%11 = lshr i64 %10, 32
store i64 %11, i64* %3
%12 = load i64, i64* %3
%13 = sub i64 %12, 1
%14 = trunc i64 %13 to i8
ret i8 %14
}

LLVM IR (-O2):
define zeroext i8 @returnmask(i32 %0) {
%2 = zext i32 %0 to i64
%3 = sub nuw nsw i64 4294967296, %2
%4 = lshr i64 %3, 32
%5 = trunc i64 %4 to i8
%6 = add nsw i8 %5, -1
ret i8 %6
}
/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
scalar_t__ fwrite(char const *, int, int, int /*<<< orphan*/ *);
int fu_Fnwrite(FILE *stream, const char *buffer, int length) {
  return (int)fwrite(buffer, 1, length, stream);
}


x86 assembly (clang, -O0):
<fu_Fnwrite>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    -0x8(%rbp),%rcx
mov    $0x1,%esi
call   1030 <fwrite@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fu_Fnwrite>:
mov    %rdi,%rcx
mov    %rsi,%rdi
mov    $0x1,%esi
jmp    1030 <fwrite@plt>

LLVM IR (-O0):
define i32 @fu_Fnwrite(i32* %0, i8* %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i8*
%6 = alloca i32
store i32* %0, i32** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%7 = load i8*, i8** %5
%8 = load i32, i32* %6
%9 = load i32*, i32** %4
%10 = call i64 @fwrite(i8* %7, i32 1, i32 %8, i32* %9)
%11 = trunc i64 %10 to i32
ret i32 %11
}

LLVM IR (-O2):
define i32 @fu_Fnwrite(i32* nocapture %0, i8* nocapture %1, i32 %2) {
%4 = tail call i64 @fwrite(i8* %1, i32 1, i32 %2, i32* %0)
%5 = trunc i64 %4 to i32
ret i32 %5
}
int table_name() {}


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

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

LLVM IR (-O0):
define i32 @table_name() {
%1 = alloca i32
%2 = load i32, i32* %1
ret i32 %2
}

LLVM IR (-O2):
define i32 @table_name() {
ret i32 undef
}
int print_chessboard(char (*a)[8]) { return (0); }


x86 assembly (clang, -O0):
<print_chessboard>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<print_chessboard>:
xor    %eax,%eax
ret

LLVM IR (-O0):
define i32 @print_chessboard([8 x i8]* %0) {
%2 = alloca [8 x i8]*
store [8 x i8]* %0, [8 x i8]** %2
ret i32 0
}

LLVM IR (-O2):
define i32 @print_chessboard([8 x i8]* nocapture readnone %0) {
ret i32 0
}
void ble_rsp_flash_write_data(
    const struct ble_msg_flash_write_data_rsp_t *msg) {}


x86 assembly (clang, -O0):
<ble_rsp_flash_write_data>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
pop    %rbp
ret

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

LLVM IR (-O0):
%struct.ble_msg_flash_write_data_rsp_t = type opaque
define void @ble_rsp_flash_write_data(%struct.ble_msg_flash_write_data_rsp_t* %0) {
%2 = alloca %struct.ble_msg_flash_write_data_rsp_t*
store %struct.ble_msg_flash_write_data_rsp_t* %0, %struct.ble_msg_flash_write_data_rsp_t** %2
ret void
}

LLVM IR (-O2):
%struct.ble_msg_flash_write_data_rsp_t = type opaque
define void @ble_rsp_flash_write_data(%struct.ble_msg_flash_write_data_rsp_t* nocapture %0) {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ wsmlton_entry(char *, int);
void wavescope_push(void *data, char *buf, int count) {
  wsmlton_entry(buf, count);
}


x86 assembly (clang, -O0):
<wavescope_push>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1030 <wsmlton_entry@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<wavescope_push>:
mov    %rsi,%rdi
mov    %edx,%esi
jmp    1030 <wsmlton_entry@plt>

LLVM IR (-O0):
define void @wavescope_push(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 i8*, i8** %5
%8 = load i32, i32* %6
%9 = call i32 @wsmlton_entry(i8* %7, i32 %8)
ret void
}

LLVM IR (-O2):
define void @wavescope_push(i8* nocapture readnone %0, i8* %1, i32 %2) {
%4 = tail call i32 @wsmlton_entry(i8* %1, i32 %2)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *);
int hello2() {
  printf("Hello, two!\n");
  return 0;
}


x86 assembly (clang, -O0):
<hello2>:
push   %rbp
mov    %rsp,%rbp
lea    0xee5(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
pop    %rbp
ret

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

LLVM IR (-O0):
@.str = [13 x i8] c"Hello, two!\0A\00"
define i32 @hello2() {
%1 = call i32 @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0))
ret i32 0
}

LLVM IR (-O2):
@str = [12 x i8] c"Hello, two!\00"
define i32 @hello2() {
%1 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @str, i64 0, i64 0))
ret i32 0
}
void fn2() {
  asm("\tnop\t\nnop\t\nnop\t\nnop\n\tnop\t\nnop\t\nnop\t\nnop\n"
      "\tnop\t\nnop\t\nnop\t\nnop\n\tnop\t\nnop\t\nnop\t\nnop\n"
      "\tnop\t\nnop\t\nnop\t\nnop\n\tnop\t\nnop\t\nnop\t\nnop\n"
      "\tnop\t\nnop\t\nnop\t\nnop\n\tnop\t\nnop\t\nnop\t\nnop\n"
      "\txor  %rax,  %rax\n"
      "\txor  %rdx,  %rdx\n"
      "\txor  %rsi,  %rsi\n"
      "\tpush %rdx\n"
      "\tmov  $0x68732f2f6e69622f, %rdi\n"
      "\tpush %rdi\n"
      "\tmov  %rsp,  %rdi\n"
      "\tmov  $0x3b, %al\n"
      "\tsyscall\n");
}


x86 assembly (clang, -O0):
<fn2>:
push   %rbp
mov    %rsp,%rbp
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
xor    %rax,%rax
xor    %rdx,%rdx
xor    %rsi,%rsi
push   %rdx
movabs $0x68732f2f6e69622f,%rdi
2f 73 68
push   %rdi
mov    %rsp,%rdi
mov    $0x3b,%al
syscall
pop    %rbp
ret

x86 assembly (clang, -O2):
<fn2>:
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
xor    %rax,%rax
xor    %rdx,%rdx
xor    %rsi,%rsi
push   %rdx
movabs $0x68732f2f6e69622f,%rdi
2f 73 68
push   %rdi
mov    %rsp,%rdi
mov    $0x3b,%al
syscall
ret

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

LLVM IR (-O2):
define void @fn2() {
tail call void asm sideeffect "\09nop\09\0Anop\09\0Anop\09\0Anop\0A\09nop\09\0Anop\09\0Anop\09\0Anop\0A\09nop\09\0Anop\09\0Anop\09\0Anop\0A\09nop\09\0Anop\09\0Anop\09\0Anop\0A\09nop\09\0Anop\09\0Anop\09\0Anop\0A\09nop\09\0Anop\09\0Anop\09\0Anop\0A\09nop\09\0Anop\09\0Anop\09\0Anop\0A\09nop\09\0Anop\09\0Anop\09\0Anop\0A\09xor %rax, %rax\0A\09xor %rdx, %rdx\0A\09xor %rsi, %rsi\0A\09push %rdx\0A\09mov $$0x68732f2f6e69622f, %rdi\0A\09push %rdi\0A\09mov %rsp, %rdi\0A\09mov $$0x3b, %al\0A\09syscall\0A", "~{dirflag},~{fpsr},~{flags}"()
ret void
}
/* Forward declarations */
typedef struct TYPE_2__ TYPE_1__;

/* Type definitions */
struct TYPE_2__ {
  scalar_t__ type;
};
typedef TYPE_1__ XResizeRequestEvent;

/* Variables and functions */
int get_XResizeRequestEvent_type(void *_p) {
  return (int)((XResizeRequestEvent *)_p)->type;
}


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

x86 assembly (clang, -O2):
<get_XResizeRequestEvent_type>:
mov    (%rdi),%eax
ret

LLVM IR (-O0):
%struct.TYPE_2__ = type { i64 }
define i32 @get_XResizeRequestEvent_type(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = bitcast i8* %3 to %struct.TYPE_2__*
%5 = getelementptr inbounds %struct.TYPE_2__, %struct.TYPE_2__* %4, i32 0, i32 0
%6 = load i64, i64* %5
%7 = trunc i64 %6 to i32
ret i32 %7
}

LLVM IR (-O2):
define i32 @get_XResizeRequestEvent_type(i8* nocapture %0) {
%2 = bitcast i8* %0 to i64*
%3 = load i64, i64* %2
%4 = trunc i64 %3 to i32
ret i32 %4
}
/* Variables and functions */
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ stdout;
void help(const char *name) {
  fprintf(stdout, "Usage:\n");
  fprintf(stdout, "%s [options] <input file>\n\n", name);
  fprintf(stdout, "-h t\tHelp\n");
  exit(-1);
}


x86 assembly (clang, -O0):
<help>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    0x2ead(%rip),%rax
mov    (%rax),%edi
lea    0xec4(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e96(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%rdx
lea    0xeb1(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e7b(%rip),%rax
mov    (%rax),%edi
lea    0xeb6(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    $0xffffffff,%edi
call   1040 <exit@plt>

x86 assembly (clang, -O2):
<help>:
push   %r14
push   %rbx
push   %rax
mov    %rdi,%rbx
mov    0x2eb2(%rip),%r14
mov    (%r14),%edi
lea    0xec8(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%r14),%edi
lea    0xebf(%rip),%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%r14),%edi
lea    0xec7(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    $0xffffffff,%edi
call   1040 <exit@plt>

LLVM IR (-O0):
@stdout = global i32 0
@.str = [8 x i8] c"Usage:\0A\00"
@.str.1 = [28 x i8] c"%s [options] <input file>\0A\0A\00"
@.str.2 = [11 x i8] c"-h t\09Help\0A\00"
define void @help(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i32, i32* @stdout
%4 = call i32 (i32, i8*, ...) @fprintf(i32 %3, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%5 = load i32, i32* @stdout
%6 = load i8*, i8** %2
%7 = call i32 (i32, i8*, ...) @fprintf(i32 %5, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.1, i64 0, i64 0), i8* %6)
%8 = load i32, i32* @stdout
%9 = call i32 (i32, i8*, ...) @fprintf(i32 %8, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
%10 = call i32 @exit(i32 -1)
unreachable
}

LLVM IR (-O2):
@stdout = global i32 0
@.str = [8 x i8] c"Usage:\0A\00"
@.str.1 = [28 x i8] c"%s [options] <input file>\0A\0A\00"
@.str.2 = [11 x i8] c"-h t\09Help\0A\00"
define void @help(i8* %0) {
%2 = load i32, i32* @stdout
%3 = tail call i32 (i32, i8*, ...) @fprintf(i32 %2, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%4 = load i32, i32* @stdout
%5 = tail call i32 (i32, i8*, ...) @fprintf(i32 %4, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.1, i64 0, i64 0), i8* %0)
%6 = load i32, i32* @stdout
%7 = tail call i32 (i32, i8*, ...) @fprintf(i32 %6, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
%8 = tail call i32 @exit(i32 -1)
unreachable
}
void ASN1_PRINTABLESTRING_new(void) {}


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

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

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

LLVM IR (-O2):
define void @ASN1_PRINTABLESTRING_new() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ errmsg(char *);
int /*<<< orphan*/ exit(int);
void giveup(char *msg) {
  errmsg(msg);
  exit(1);
}


x86 assembly (clang, -O0):
<giveup>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <errmsg@plt>
mov    $0x1,%edi
call   1040 <exit@plt>

x86 assembly (clang, -O2):
<giveup>:
push   %rax
call   1030 <errmsg@plt>
mov    $0x1,%edi
call   1040 <exit@plt>

LLVM IR (-O0):
define void @giveup(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = call i32 @errmsg(i8* %3)
%5 = call i32 @exit(i32 1)
unreachable
}

LLVM IR (-O2):
define void @giveup(i8* %0) {
%2 = tail call i32 @errmsg(i8* %0)
%3 = tail call i32 @exit(i32 1)
unreachable
}
/* Variables and functions */
int ax2eu(double *, double *, int);
int ho2ax(double *, double *, int);
int ho2eu(double *ho, double *eu, int p) {
  double ax[4];
  int trash;
  trash = ho2ax(ho, ax, p);
  trash = ax2eu(ax, eu, p);
  return 1;
}


x86 assembly (clang, -O0):
<ho2eu>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x40(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   1030 <ho2ax@plt>
mov    %eax,-0x44(%rbp)
lea    -0x40(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   1040 <ax2eu@plt>
mov    %eax,-0x44(%rbp)
mov    $0x1,%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ho2eu>:
push   %r15
push   %r14
push   %rbx
sub    $0x20,%rsp
mov    %edx,%ebx
mov    %rsi,%r14
mov    %rsp,%r15
mov    %r15,%rsi
call   1030 <ho2ax@plt>
mov    %r15,%rdi
mov    %r14,%rsi
mov    %ebx,%edx
call   1040 <ax2eu@plt>
mov    $0x1,%eax
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define i32 @ho2eu(double* %0, double* %1, i32 %2) {
%4 = alloca double*
%5 = alloca double*
%6 = alloca i32
%7 = alloca [4 x double]
%8 = alloca i32
store double* %0, double** %4
store double* %1, double** %5
store i32 %2, i32* %6
%9 = load double*, double** %4
%10 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 0
%11 = load i32, i32* %6
%12 = call i32 @ho2ax(double* %9, double* %10, i32 %11)
store i32 %12, i32* %8
%13 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 0
%14 = load double*, double** %5
%15 = load i32, i32* %6
%16 = call i32 @ax2eu(double* %13, double* %14, i32 %15)
store i32 %16, i32* %8
ret i32 1
}

LLVM IR (-O2):
define i32 @ho2eu(double* %0, double* %1, i32 %2) {
%4 = alloca [4 x double]
%5 = bitcast [4 x double]* %4 to i8*
%6 = getelementptr inbounds [4 x double], [4 x double]* %4, i64 0, i64 0
%7 = call i32 @ho2ax(double* %0, double* %6, i32 %2)
%8 = call i32 @ax2eu(double* %6, double* %1, i32 %2)
ret i32 1
}
double compute_jaccard(double union_area, double intersection_area) {
  return intersection_area / union_area;
}


x86 assembly (clang, -O0):
<compute_jaccard>:
push   %rbp
mov    %rsp,%rbp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  -0x10(%rbp),%xmm0
divsd  -0x8(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_jaccard>:
divsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
ret

LLVM IR (-O0):
define double @compute_jaccard(double %0, double %1) {
%3 = alloca double
%4 = alloca double
store double %0, double* %3
store double %1, double* %4
%5 = load double, double* %4
%6 = load double, double* %3
%7 = fdiv double %5, %6
ret double %7
}

LLVM IR (-O2):
define double @compute_jaccard(double %0, double %1) {
%3 = fdiv double %1, %0
ret double %3
}
/* Type definitions */
struct __test_metadata {
  int dummy;
};
struct __fixture_variant_metadata {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ epoll58(struct __test_metadata *);
void wrapper_epoll58(struct __test_metadata *_metadata,
                     struct __fixture_variant_metadata *variant) {
  epoll58(_metadata);
}


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

x86 assembly (clang, -O2):
<wrapper_epoll58>:
jmp    1030 <epoll58@plt>

LLVM IR (-O0):
%struct.__test_metadata = type { i32 }
%struct.__fixture_variant_metadata = type { i32 }
define void @wrapper_epoll58(%struct.__test_metadata* %0, %struct.__fixture_variant_metadata* %1) {
%3 = alloca %struct.__test_metadata*
%4 = alloca %struct.__fixture_variant_metadata*
store %struct.__test_metadata* %0, %struct.__test_metadata** %3
store %struct.__fixture_variant_metadata* %1, %struct.__fixture_variant_metadata** %4
%5 = load %struct.__test_metadata*, %struct.__test_metadata** %3
%6 = call i32 @epoll58(%struct.__test_metadata* %5)
ret void
}

LLVM IR (-O2):
%struct.__test_metadata = type { i32 }
%struct.__fixture_variant_metadata = type { i32 }
define void @wrapper_epoll58(%struct.__test_metadata* %0, %struct.__fixture_variant_metadata* nocapture readnone %1) {
%3 = tail call i32 @epoll58(%struct.__test_metadata* %0)
ret void
}
/* Variables and functions */
double ignpoi(double);
void pois_rndc(int n, double mu, double *array) {
  int i;
  for (i = 0; i < n; i++)
    *(array + i) = ignpoi(mu);
}


x86 assembly (clang, -O0):
<pois_rndc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    115c <pois_rndc+0x4c>
movsd  -0x10(%rbp),%xmm0
call   1030 <ignpoi@plt>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112b <pois_rndc+0x1b>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pois_rndc>:
push   %r15
push   %r14
push   %rbx
sub    $0x10,%rsp
test   %edi,%edi
jle    114a <pois_rndc+0x3a>
mov    %rsi,%r14
mov    %edi,%r15d
xor    %ebx,%ebx
movsd  %xmm0,0x8(%rsp)
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rsp),%xmm0
call   1030 <ignpoi@plt>
movsd  %xmm0,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1130 <pois_rndc+0x20>
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @pois_rndc(i32 %0, double %1, double* nocapture writeonly %2) {
%4 = icmp sgt i32 %0, 0
br i1 %4, label %5, label %13
5: ; preds = %3
%6 = zext i32 %0 to i64
br label %7
7: ; preds = %5, %7
%8 = phi i64 [ 0, %5 ], [ %11, %7 ]
%9 = tail call double @ignpoi(double %1)
%10 = getelementptr inbounds double, double* %2, i64 %8
store double %9, double* %10
%11 = add nuw nsw i64 %8, 1
%12 = icmp eq i64 %11, %6
br i1 %12, label %13, label %7
13: ; preds = %7, %3
ret void
}
int test_imm_98uint16_reg(unsigned short val) {
  return ((val) & (0x98 << 0)) ? -20 : -40;
}


x86 assembly (clang, -O0):
<test_imm_98uint16_reg>:
push   %rbp
mov    %rsp,%rbp
mov    %di,%ax
mov    %ax,-0x2(%rbp)
movzwl -0x2(%rbp),%edx
and    $0x98,%edx
mov    $0xffffffd8,%eax
mov    $0xffffffec,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_imm_98uint16_reg>:
test   $0x98,%dil
mov    $0xffffffd8,%ecx
mov    $0xffffffec,%eax
cmove  %ecx,%eax
ret

LLVM IR (-O0):
define i32 @test_imm_98uint16_reg(i16 zeroext %0) {
%2 = alloca i16
store i16 %0, i16* %2
%3 = load i16, i16* %2
%4 = zext i16 %3 to i32
%5 = and i32 %4, 152
%6 = icmp ne i32 %5, 0
%7 = zext i1 %6 to i64
%8 = select i1 %6, i32 -20, i32 -40
ret i32 %8
}

LLVM IR (-O2):
define i32 @test_imm_98uint16_reg(i16 zeroext %0) {
%2 = and i16 %0, 152
%3 = icmp eq i16 %2, 0
%4 = select i1 %3, i32 -40, i32 -20
ret i32 %4
}
/* Variables and functions */
void stub1(short, short);
void testClosureSSrV(void (*closure)(short, short), short a1, short a2) {
  if (closure != NULL)
    (*closure)(a1, a2);
}


x86 assembly (clang, -O0):
<testClosureSSrV>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %dx,%ax
mov    %si,%cx
mov    %rdi,-0x8(%rbp)
mov    %cx,-0xa(%rbp)
mov    %ax,-0xc(%rbp)
cmpq   $0x0,-0x8(%rbp)
je     1136 <testClosureSSrV+0x36>
mov    -0x8(%rbp),%rax
mov    -0xa(%rbp),%cx
movswl %cx,%edi
movswl -0xc(%rbp),%esi
call   *%rax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<testClosureSSrV>:
test   %rdi,%rdi
je     1110 <testClosureSSrV+0x10>
mov    %rdi,%rax
movswl %si,%edi
movswl %dx,%esi
jmp    *%rax
ret

LLVM IR (-O0):
define void @testClosureSSrV(void (i16, i16)* %0, i16 signext %1, i16 signext %2) {
%4 = alloca void (i16, i16)*
%5 = alloca i16
%6 = alloca i16
store void (i16, i16)* %0, void (i16, i16)** %4
store i16 %1, i16* %5
store i16 %2, i16* %6
%7 = load void (i16, i16)*, void (i16, i16)** %4
%8 = icmp ne void (i16, i16)* %7, null
br i1 %8, label %9, label %13
9: ; preds = %3
%10 = load void (i16, i16)*, void (i16, i16)** %4
%11 = load i16, i16* %5
%12 = load i16, i16* %6
br label %13
13: ; preds = %9, %3
ret void
}

LLVM IR (-O2):
define void @testClosureSSrV(void (i16, i16)* %0, i16 signext %1, i16 signext %2) {
%4 = icmp eq void (i16, i16)* %0, null
br i1 %4, label %6, label %5
5: ; preds = %3
tail call void %0(i16 signext %1, i16 signext %2)
br label %6
6: ; preds = %5, %3
ret void
}
/* Variables and functions */
int ciao_start(int, char **);
int /*<<< orphan*/ printf(char *);
int main(int argc, char *argv[]) {
  printf("Ciao Loader...\n");
  return ciao_start(argc, argv);
}


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)
lea    0xec3(%rip),%rdi
call   1040 <printf@plt>
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   1030 <ciao_start@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %rbx
push   %rax
mov    %rsi,%rbx
mov    %edi,%ebp
lea    0xed1(%rip),%rdi
call   1030 <puts@plt>
mov    %ebp,%edi
mov    %rbx,%rsi
add    $0x8,%rsp
pop    %rbx
pop    %rbp
jmp    1040 <ciao_start@plt>

LLVM IR (-O0):
@.str = [16 x i8] c"Ciao Loader...\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 @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0))
%7 = load i32, i32* %4
%8 = load i8**, i8*** %5
%9 = call i32 @ciao_start(i32 %7, i8** %8)
ret i32 %9
}

LLVM IR (-O2):
@str = [15 x i8] c"Ciao Loader...\00"
define i32 @main(i32 %0, i8** %1) {
%3 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @str, i64 0, i64 0))
%4 = tail call i32 @ciao_start(i32 %0, i8** %1)
ret i32 %4
}
/* Variables and functions */
int transform(char *);
int hash(char *key) { return (transform(key) % 13); }


x86 assembly (clang, -O0):
<hash>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <transform@plt>
mov    $0xd,%ecx
cltd
idiv   %ecx
mov    %edx,%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hash>:
push   %rax
call   1030 <transform@plt>
cltq
imul   $0x4ec4ec4f,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x22,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,2),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %ecx,%eax
pop    %rcx
ret

LLVM IR (-O0):
define i32 @hash(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = call i32 @transform(i8* %3)
%5 = srem i32 %4, 13
ret i32 %5
}

LLVM IR (-O2):
define i32 @hash(i8* %0) {
%2 = tail call i32 @transform(i8* %0)
%3 = srem i32 %2, 13
ret i32 %3
}
/* Type definitions */
struct UPnPService {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ printf(char *, int, char *);
void AVRCP_ResponseSink_ConnectionManager_GetCurrentConnectionIDs(
    struct UPnPService *Service, int ErrorCode, void *User,
    char *ConnectionIDs) {
  printf("AVRCP_ Invoke Response: "
         "ConnectionManager/GetCurrentConnectionIDs[ErrorCode:%d](%s)\r\n",
         ErrorCode, ConnectionIDs);
}


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

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

LLVM IR (-O0):
%struct.UPnPService = type { i32 }
@.str = [86 x i8] c"AVRCP_ Invoke Response: ConnectionManager/GetCurrentConnectionIDs[ErrorCode:%d](%s)\0D\0A\00"
define void @AVRCP_ResponseSink_ConnectionManager_GetCurrentConnectionIDs(%struct.UPnPService* %0, i32 %1, i8* %2, i8* %3) {
%5 = alloca %struct.UPnPService*
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i8*
store %struct.UPnPService* %0, %struct.UPnPService** %5
store i32 %1, i32* %6
store i8* %2, i8** %7
store i8* %3, i8** %8
%9 = load i32, i32* %6
%10 = load i8*, i8** %8
%11 = call i32 @printf(i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str, i64 0, i64 0), i32 %9, i8* %10)
ret void
}

LLVM IR (-O2):
%struct.UPnPService = type { i32 }
@.str = [86 x i8] c"AVRCP_ Invoke Response: ConnectionManager/GetCurrentConnectionIDs[ErrorCode:%d](%s)\0D\0A\00"
define void @AVRCP_ResponseSink_ConnectionManager_GetCurrentConnectionIDs(%struct.UPnPService* nocapture readnone %0, i32 %1, i8* nocapture readnone %2, i8* %3) {
%5 = tail call i32 @printf(i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str, i64 0, i64 0), i32 %1, i8* %3)
ret void
}
void reportusage(void) { return; }


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

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

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

LLVM IR (-O2):
define void @reportusage() {
ret void
}
/* Variables and functions */
int /*<<< orphan*/ printf(char *, int);
void printdata(void const *data) { printf("%d,", *(int *)data); }


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

x86 assembly (clang, -O2):
<printdata>:
mov    (%rdi),%esi
lea    0xee7(%rip),%rdi
jmp    1030 <printf@plt>

LLVM IR (-O0):
@.str = [4 x i8] c"%d,\00"
define void @printdata(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = bitcast i8* %3 to i32*
%5 = load i32, i32* %4
%6 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %5)
ret void
}

LLVM IR (-O2):
@.str = [4 x i8] c"%d,\00"
define void @printdata(i8* nocapture %0) {
%2 = bitcast i8* %0 to i32*
%3 = load i32, i32* %2
%4 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %3)
ret void
}
/* Variables and functions */
int /*<<< orphan*/ fatal(char *);
void wfff_xml_rd_init(const char *fname) {
  fatal("wfff_xml"
        ": This build excluded WFFF_XML support because expat was not "
        "installed.\n");
}


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

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

LLVM IR (-O0):
@.str = [81 x i8] c"wfff_xml: This build excluded WFFF_XML support because expat was not installed.\0A\00"
define void @wfff_xml_rd_init(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = call i32 @fatal(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [81 x i8] c"wfff_xml: This build excluded WFFF_XML support because expat was not installed.\0A\00"
define void @wfff_xml_rd_init(i8* nocapture readnone %0) {
%2 = tail call i32 @fatal(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str, i64 0, i64 0))
ret void
}
unsigned int sysmon_adc2vcc(unsigned int adc_value) {
  return (adc_value * 3000) >> 16;
}


x86 assembly (clang, -O0):
<sysmon_adc2vcc>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
imul   $0xbb8,-0x4(%rbp),%eax
shr    $0x10,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<sysmon_adc2vcc>:
imul   $0xbb8,%edi,%eax
shr    $0x10,%eax
ret

LLVM IR (-O0):
define i32 @sysmon_adc2vcc(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
%3 = load i32, i32* %2
%4 = mul i32 %3, 3000
%5 = lshr i32 %4, 16
ret i32 %5
}

LLVM IR (-O2):
define i32 @sysmon_adc2vcc(i32 %0) {
%2 = mul i32 %0, 3000
%3 = lshr i32 %2, 16
ret i32 %3
}
int omp_set_num_threads(int num_threads) { return 1; }


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

x86 assembly (clang, -O2):
<omp_set_num_threads>:
mov    $0x1,%eax
ret

LLVM IR (-O0):
define i32 @omp_set_num_threads(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
ret i32 1
}

LLVM IR (-O2):
define i32 @omp_set_num_threads(i32 %0) {
ret i32 1
}
char *pchat_platform_support_get_user_home_dir(const char *name) { return 0; }


x86 assembly (clang, -O0):
<pchat_platform_support_get_user_home_dir>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<pchat_platform_support_get_user_home_dir>:
xor    %eax,%eax
ret

LLVM IR (-O0):
define i8* @pchat_platform_support_get_user_home_dir(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
ret i8* null
}

LLVM IR (-O2):
define noalias i8* @pchat_platform_support_get_user_home_dir(i8* nocapture readnone %0) {
ret i8* null
}
int fun_pp_in_release_so(int **x, int **y) { return 20 + **x + **y; }


x86 assembly (clang, -O0):
<fun_pp_in_release_so>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    (%rax),%eax
add    $0x14,%eax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
add    (%rcx),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<fun_pp_in_release_so>:
mov    (%rdi),%rax
mov    (%rax),%eax
mov    (%rsi),%rcx
mov    (%rcx),%ecx
add    %ecx,%eax
add    $0x14,%eax
ret

LLVM IR (-O0):
define i32 @fun_pp_in_release_so(i32** %0, i32** %1) {
%3 = alloca i32**
%4 = alloca i32**
store i32** %0, i32*** %3
store i32** %1, i32*** %4
%5 = load i32**, i32*** %3
%6 = load i32*, i32** %5
%7 = load i32, i32* %6
%8 = add nsw i32 20, %7
%9 = load i32**, i32*** %4
%10 = load i32*, i32** %9
%11 = load i32, i32* %10
%12 = add nsw i32 %8, %11
ret i32 %12
}

LLVM IR (-O2):
define i32 @fun_pp_in_release_so(i32** nocapture %0, i32** nocapture %1) {
%3 = load i32*, i32** %0
%4 = load i32, i32* %3
%5 = add nsw i32 %4, 20
%6 = load i32*, i32** %1
%7 = load i32, i32* %6
%8 = add nsw i32 %5, %7
ret i32 %8
}
int c_func_add_1(int x) { return x + 1; }


x86 assembly (clang, -O0):
<c_func_add_1>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<c_func_add_1>:
lea    0x1(%rdi),%eax
ret

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

LLVM IR (-O2):
define i32 @c_func_add_1(i32 %0) {
%2 = add nsw i32 %0, 1
ret i32 %2
}
int offbit(bits, first, last)
unsigned long *bits;
int first;
int last;
{
  while (++first <= last)
    if ((!((bits[(unsigned)(first - 1) >> 5] &
            (1L << ((first - 1) & ((1 << 5) - 1)))))))
      return first;
  return 0;
}


x86 assembly (clang, -O0):
<offbit>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmp    -0x18(%rbp),%eax
jg     1166 <offbit+0x66>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
shr    $0x5,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
and    $0x1f,%ecx
mov    %ecx,%ecx
mov    $0x1,%edx
shl    %cl,%rdx
mov    %rdx,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    1161 <offbit+0x61>
mov    -0x14(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    116d <offbit+0x6d>
jmp    110e <offbit+0xe>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<offbit>:
cmp    %esi,%edx
cmovle %esi,%edx
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %esi,%edx
je     1127 <offbit+0x27>
mov    %esi,%eax
shr    $0x5,%eax
mov    (%rdi,%rax,8),%ecx
lea    0x1(%rsi),%eax
bt     %esi,%ecx
mov    %eax,%esi
jb     1110 <offbit+0x10>
ret
xor    %eax,%eax
ret

LLVM IR (-O0):
define i32 @offbit(i64* %0, i32 %1, i32 %2) {
%4 = alloca i32
%5 = alloca i64*
%6 = alloca i32
%7 = alloca i32
store i64* %0, i64** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
br label %8
8: ; preds = %30, %3
%9 = load i32, i32* %6
%10 = add nsw i32 %9, 1
store i32 %10, i32* %6
%11 = load i32, i32* %7
%12 = icmp sle i32 %10, %11
br i1 %12, label %13, label %31
13: ; preds = %8
%14 = load i64*, i64** %5
%15 = load i32, i32* %6
%16 = sub nsw i32 %15, 1
%17 = lshr i32 %16, 5
%18 = zext i32 %17 to i64
%19 = getelementptr inbounds i64, i64* %14, i64 %18
%20 = load i64, i64* %19
%21 = load i32, i32* %6
%22 = sub nsw i32 %21, 1
%23 = and i32 %22, 31
%24 = zext i32 %23 to i64
%25 = shl i64 1, %24
%26 = and i64 %20, %25
%27 = icmp ne i64 %26, 0
br i1 %27, label %30, label %28
28: ; preds = %13
%29 = load i32, i32* %6
store i32 %29, i32* %4
br label %32
30: ; preds = %13
br label %8
31: ; preds = %8
store i32 0, i32* %4
br label %32
32: ; preds = %31, %28
%33 = load i32, i32* %4
ret i32 %33
}

LLVM IR (-O2):
define i32 @offbit(i64* nocapture %0, i32 %1, i32 %2) {
%4 = call i32 @llvm.smax.i32(i32 %2, i32 %1)
br label %5
5: ; preds = %9, %3
%6 = phi i32 [ %1, %3 ], [ %7, %9 ]
%7 = add i32 %6, 1
%8 = icmp eq i32 %6, %4
br i1 %8, label %19, label %9
9: ; preds = %5
%10 = lshr i32 %6, 5
%11 = zext i32 %10 to i64
%12 = getelementptr inbounds i64, i64* %0, i64 %11
%13 = load i64, i64* %12
%14 = and i32 %6, 31
%15 = zext i32 %14 to i64
%16 = shl nuw nsw i64 1, %15
%17 = and i64 %13, %16
%18 = icmp eq i64 %17, 0
br i1 %18, label %19, label %5
19: ; preds = %5, %9
%20 = phi i32 [ %7, %9 ], [ 0, %5 ]
ret i32 %20
}
int round_up(int n, int m) { return (n + m - 1) & ~(m - 1); }


x86 assembly (clang, -O0):
<round_up>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    -0x4(%rbp),%eax
add    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<round_up>:
lea    (%rdi,%rsi,1),%eax
add    $0xffffffff,%eax
neg    %esi
and    %esi,%eax
ret

LLVM IR (-O0):
define i32 @round_up(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
store i32 %0, i32* %3
store i32 %1, i32* %4
%5 = load i32, i32* %3
%6 = load i32, i32* %4
%7 = add nsw i32 %5, %6
%8 = sub nsw i32 %7, 1
%9 = load i32, i32* %4
%10 = sub nsw i32 %9, 1
%11 = xor i32 %10, -1
%12 = and i32 %8, %11
ret i32 %12
}

LLVM IR (-O2):
define i32 @round_up(i32 %0, i32 %1) {
%3 = add i32 %0, -1
%4 = add i32 %3, %1
%5 = sub i32 0, %1
%6 = and i32 %4, %5
ret i32 %6
}
/* Variables and functions */
int any_decrqpsr(char const *, int);
int tst_DECTABSR(const char *the_title) { return any_decrqpsr(the_title, 2); }


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

x86 assembly (clang, -O2):
<tst_DECTABSR>:
mov    $0x2,%esi
jmp    1030 <any_decrqpsr@plt>

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

LLVM IR (-O2):
define i32 @tst_DECTABSR(i8* %0) {
%2 = tail call i32 @any_decrqpsr(i8* %0, i32 2)
ret i32 %2
}
int sysfs_rename_link(struct kobject *k, struct kobject *t,
                      const char *old_name, const char *new_name) {
  return 0;
}


x86 assembly (clang, -O0):
<sysfs_rename_link>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<sysfs_rename_link>:
xor    %eax,%eax
ret

LLVM IR (-O0):
%struct.kobject = type opaque
define i32 @sysfs_rename_link(%struct.kobject* %0, %struct.kobject* %1, i8* %2, i8* %3) {
%5 = alloca %struct.kobject*
%6 = alloca %struct.kobject*
%7 = alloca i8*
%8 = alloca i8*
store %struct.kobject* %0, %struct.kobject** %5
store %struct.kobject* %1, %struct.kobject** %6
store i8* %2, i8** %7
store i8* %3, i8** %8
ret i32 0
}

LLVM IR (-O2):
%struct.kobject = type opaque
define i32 @sysfs_rename_link(%struct.kobject* nocapture readnone %0, %struct.kobject* nocapture readnone %1, i8* nocapture readnone %2, i8* nocapture readnone %3) {
ret i32 0
}
/* Type definitions */
typedef char *uint32_t;

/* Variables and functions */
uint32_t logical_and(uint32_t a, uint32_t b) {
  asm volatile("and %0, %1" : "+r"(a) : "r"(b));
  return a;
}


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

x86 assembly (clang, -O2):
<logical_and>:
mov    %rdi,%rax
and    %rax,%rsi
ret

LLVM IR (-O0):
define i8* @logical_and(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
store i8* %0, i8** %3
store i8* %1, i8** %4
%5 = load i8*, i8** %3
%6 = load i8*, i8** %4
%7 = call i8* asm sideeffect "and $0, $1", "=r,r,0,~{dirflag},~{fpsr},~{flags}"(i8* %6, i8* %5)
store i8* %7, i8** %3
%8 = load i8*, i8** %3
ret i8* %8
}

LLVM IR (-O2):
define i8* @logical_and(i8* %0, i8* %1) {
%3 = tail call i8* asm sideeffect "and $0, $1", "=r,r,0,~{dirflag},~{fpsr},~{flags}"(i8* %1, i8* %0)
ret i8* %3
}
void WriteHomotopyItem(double v, const char *str) { ; }


x86 assembly (clang, -O0):
<WriteHomotopyItem>:
push   %rbp
mov    %rsp,%rbp
movsd  %xmm0,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
pop    %rbp
ret

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

LLVM IR (-O0):
define void @WriteHomotopyItem(double %0, i8* %1) {
%3 = alloca double
%4 = alloca i8*
store double %0, double* %3
store i8* %1, i8** %4
ret void
}

LLVM IR (-O2):
define void @WriteHomotopyItem(double %0, i8* nocapture %1) {
ret void
}
/* Type definitions */
typedef scalar_t__ uint8_t;
typedef int uint16_t;

/* Variables and functions */
int is_big_endian(void) {
  uint16_t endianess = 1;
  if (*((uint8_t *)(&endianess)))
    return 0;
  else
    return 1;
}


x86 assembly (clang, -O0):
<is_big_endian>:
push   %rbp
mov    %rsp,%rbp
movl   $0x1,-0x8(%rbp)
cmpq   $0x0,-0x8(%rbp)
je     1122 <is_big_endian+0x22>
movl   $0x0,-0x4(%rbp)
jmp    1129 <is_big_endian+0x29>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<is_big_endian>:
xor    %eax,%eax
ret

LLVM IR (-O0):
define i32 @is_big_endian() {
%1 = alloca i32
%2 = alloca i32
store i32 1, i32* %2
%3 = bitcast i32* %2 to i64*
%4 = load i64, i64* %3
%5 = icmp ne i64 %4, 0
br i1 %5, label %6, label %7
6: ; preds = %0
store i32 0, i32* %1
br label %8
7: ; preds = %0
store i32 1, i32* %1
br label %8
8: ; preds = %7, %6
%9 = load i32, i32* %1
ret i32 %9
}

LLVM IR (-O2):
define i32 @is_big_endian() {
ret i32 0
}
/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int strlen(char *);
int /*<<< orphan*/ wrbuf(int /*<<< orphan*/ *, char *, size_t);
int /*<<< orphan*/ wrint(int /*<<< orphan*/ *, int);
void wrstr(FILE *fd, char *val) {
  size_t len;
  if (!val) {
    wrint(fd, -1);
  } else {
    wrint(fd, strlen(val));
    len = strlen(val);
    wrbuf(fd, val, len);
  }
}


x86 assembly (clang, -O0):
<wrstr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    115e <wrstr+0x2e>
mov    -0x8(%rbp),%rdi
mov    $0xffffffff,%esi
call   1050 <wrint@plt>
jmp    119a <wrstr+0x6a>
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0x20(%rbp),%rdi
mov    %eax,%esi
call   1050 <wrint@plt>
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
cltq
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
call   1030 <wrbuf@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<wrstr>:
push   %r14
push   %rbx
push   %rax
mov    %rdi,%r14
test   %rsi,%rsi
je     116e <wrstr+0x3e>
mov    %rsi,%rbx
mov    %rsi,%rdi
call   1040 <strlen@plt>
mov    %r14,%rdi
mov    %eax,%esi
call   1050 <wrint@plt>
mov    %rbx,%rdi
call   1040 <strlen@plt>
movslq %eax,%rdx
mov    %r14,%rdi
mov    %rbx,%rsi
add    $0x8,%rsp
pop    %rbx
pop    %r14
jmp    1030 <wrbuf@plt>
mov    %r14,%rdi
mov    $0xffffffff,%esi
add    $0x8,%rsp
pop    %rbx
pop    %r14
jmp    1050 <wrint@plt>

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

LLVM IR (-O2):
define void @wrstr(i32* %0, i8* %1) {
%3 = icmp eq i8* %1, null
br i1 %3, label %4, label %6
4: ; preds = %2
%5 = tail call i32 @wrint(i32* %0, i32 -1)
br label %12
6: ; preds = %2
%7 = tail call i32 @strlen(i8* %1)
%8 = tail call i32 @wrint(i32* %0, i32 %7)
%9 = tail call i32 @strlen(i8* %1)
%10 = sext i32 %9 to i64
%11 = tail call i32 @wrbuf(i32* %0, i8* %1, i64 %10)
br label %12
12: ; preds = %6, %4
ret void
}
void mem_checkblocks(void) {}


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

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

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

LLVM IR (-O2):
define void @mem_checkblocks() {
ret void
}