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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
char *calloc(int, int);
int /*<<< orphan*/ fail(char *);
int /*<<< orphan*/ free(char *);
char *malloc(int);
int /*<<< orphan*/ pr(char *);
char *realloc(char *, int);
void test_dmem(void) {
  char *segp[64], *a;
  int i, j;
  pr("malloc");
  for (i = 0; i < 20; i++) {
    if ((segp[i] = malloc(1024)) == NULL)
      break;
    for (j = 0; j < 1024; j++)
      segp[i][j] = i;
  }
  if (i < 20)
    fail("malloc-1");
  for (i = 0; i < 20; i++) {
    for (j = 0; j < 1024; j++)
      if (segp[i][j] != i)
        break;
    if (j != 1024)
      break;
  }
  if (i < 20)
    fail("malloc-2");
  pr("free");
  for (j = 0; j < i; j++)
    free(segp[j]);
  pr("calloc");
  if ((a = calloc(i, 1024)) == NULL)
    fail("calloc-1");
  for (i = 0; i < 1024; i++)
    if (a[i])
      break;
  if (i < 1024)
    fail("calloc-2");
  free(a);
  pr("realloc");
  if ((a = malloc(123)) == NULL)
    fail("malloc-3");
  for (i = 0; i < 123; i++)
    a[i] = i;
  if ((a = realloc(a, 257)) == NULL)
    fail("realloc-1");
  for (i = 0; i < 123; i++)
    if (a[i] != i)
      break;
  if (i < 123)
    fail("realloc-2");
  if ((a = realloc(a, 97)) == NULL)
    fail("realloc-3");
  for (i = 0; i < 97; i++)
    if (a[i] != i)
      break;
  if (i < 97)
    fail("realloc-4");
  free(a);
}


x86 assembly (clang, -O0):
<test_dmem>:
push   %rbp
mov    %rsp,%rbp
sub    $0x210,%rsp
lea    0xe8e(%rip),%rdi
call   1050 <pr@plt>
movl   $0x0,-0x20c(%rbp)
cmpl   $0x14,-0x20c(%rbp)
jge    121e <test_dmem+0xbe>
mov    $0x400,%edi
call   1070 <malloc@plt>
movslq -0x20c(%rbp),%rcx
mov    %rax,-0x200(%rbp,%rcx,8)
ff
cmp    $0x0,%rax
jne    11b6 <test_dmem+0x56>
jmp    121e <test_dmem+0xbe>
movl   $0x0,-0x210(%rbp)
cmpl   $0x400,-0x210(%rbp)
jge    1205 <test_dmem+0xa5>
mov    -0x20c(%rbp),%eax
mov    %al,%dl
movslq -0x20c(%rbp),%rax
mov    -0x200(%rbp,%rax,8),%rax
ff
movslq -0x210(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x210(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x210(%rbp)
jmp    11c0 <test_dmem+0x60>
jmp    120a <test_dmem+0xaa>
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    1181 <test_dmem+0x21>
cmpl   $0x14,-0x20c(%rbp)
jge    1237 <test_dmem+0xd7>
lea    0xdd5(%rip),%rdi
call   1040 <fail@plt>
movl   $0x0,-0x20c(%rbp)
cmpl   $0x14,-0x20c(%rbp)
jge    12da <test_dmem+0x17a>
movl   $0x0,-0x210(%rbp)
cmpl   $0x400,-0x210(%rbp)
jge    12ac <test_dmem+0x14c>
movslq -0x20c(%rbp),%rax
mov    -0x200(%rbp,%rax,8),%rax
ff
movslq -0x210(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    -0x20c(%rbp),%eax
je     1293 <test_dmem+0x133>
jmp    12ac <test_dmem+0x14c>
jmp    1298 <test_dmem+0x138>
mov    -0x210(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x210(%rbp)
jmp    1258 <test_dmem+0xf8>
cmpl   $0x400,-0x210(%rbp)
je     12c1 <test_dmem+0x161>
jmp    12da <test_dmem+0x17a>
jmp    12c6 <test_dmem+0x166>
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    1241 <test_dmem+0xe1>
cmpl   $0x14,-0x20c(%rbp)
jge    12f3 <test_dmem+0x193>
lea    0xd22(%rip),%rdi
call   1040 <fail@plt>
lea    0xd1f(%rip),%rdi
call   1050 <pr@plt>
movl   $0x0,-0x210(%rbp)
mov    -0x210(%rbp),%eax
cmp    -0x20c(%rbp),%eax
jge    1343 <test_dmem+0x1e3>
movslq -0x210(%rbp),%rax
mov    -0x200(%rbp,%rax,8),%rdi
ff
call   1030 <free@plt>
mov    -0x210(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x210(%rbp)
jmp    1309 <test_dmem+0x1a9>
lea    0xcd4(%rip),%rdi
call   1050 <pr@plt>
mov    -0x20c(%rbp),%edi
mov    $0x400,%esi
call   1060 <calloc@plt>
mov    %rax,-0x208(%rbp)
cmp    $0x0,%rax
jne    137c <test_dmem+0x21c>
lea    0xcae(%rip),%rdi
call   1040 <fail@plt>
movl   $0x0,-0x20c(%rbp)
cmpl   $0x400,-0x20c(%rbp)
jge    13cc <test_dmem+0x26c>
mov    -0x208(%rbp),%rax
movslq -0x20c(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     13b3 <test_dmem+0x253>
jmp    13cc <test_dmem+0x26c>
jmp    13b8 <test_dmem+0x258>
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    1386 <test_dmem+0x226>
cmpl   $0x400,-0x20c(%rbp)
jge    13e8 <test_dmem+0x288>
lea    0xc4b(%rip),%rdi
call   1040 <fail@plt>
mov    -0x208(%rbp),%rdi
call   1030 <free@plt>
lea    0xc3c(%rip),%rdi
call   1050 <pr@plt>
mov    $0x7b,%edi
call   1070 <malloc@plt>
mov    %rax,-0x208(%rbp)
cmp    $0x0,%rax
jne    1427 <test_dmem+0x2c7>
lea    0xc1d(%rip),%rdi
call   1040 <fail@plt>
movl   $0x0,-0x20c(%rbp)
cmpl   $0x7b,-0x20c(%rbp)
jge    146b <test_dmem+0x30b>
mov    -0x20c(%rbp),%eax
mov    %al,%dl
mov    -0x208(%rbp),%rax
movslq -0x20c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    1431 <test_dmem+0x2d1>
mov    -0x208(%rbp),%rdi
mov    $0x101,%esi
call   1080 <realloc@plt>
mov    %rax,-0x208(%rbp)
cmp    $0x0,%rax
jne    1499 <test_dmem+0x339>
lea    0xbb4(%rip),%rdi
call   1040 <fail@plt>
movl   $0x0,-0x20c(%rbp)
cmpl   $0x7b,-0x20c(%rbp)
jge    14ec <test_dmem+0x38c>
mov    -0x208(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    -0x20c(%rbp),%eax
je     14d3 <test_dmem+0x373>
jmp    14ec <test_dmem+0x38c>
jmp    14d8 <test_dmem+0x378>
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    14a3 <test_dmem+0x343>
cmpl   $0x7b,-0x20c(%rbp)
jge    1505 <test_dmem+0x3a5>
lea    0xb52(%rip),%rdi
call   1040 <fail@plt>
mov    -0x208(%rbp),%rdi
mov    $0x61,%esi
call   1080 <realloc@plt>
mov    %rax,-0x208(%rbp)
cmp    $0x0,%rax
jne    1533 <test_dmem+0x3d3>
lea    0xb2e(%rip),%rdi
call   1040 <fail@plt>
movl   $0x0,-0x20c(%rbp)
cmpl   $0x61,-0x20c(%rbp)
jge    1586 <test_dmem+0x426>
mov    -0x208(%rbp),%rax
movslq -0x20c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    -0x20c(%rbp),%eax
je     156d <test_dmem+0x40d>
jmp    1586 <test_dmem+0x426>
jmp    1572 <test_dmem+0x412>
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    153d <test_dmem+0x3dd>
cmpl   $0x61,-0x20c(%rbp)
jge    159f <test_dmem+0x43f>
lea    0xacc(%rip),%rdi
call   1040 <fail@plt>
mov    -0x208(%rbp),%rdi
call   1030 <free@plt>
add    $0x210,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_dmem>:
push   %r15
push   %r14
push   %rbx
sub    $0x200,%rsp
lea    0xeed(%rip),%rdi
call   1050 <pr@plt>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    $0x400,%edi
call   1080 <malloc@plt>
mov    %rax,(%rsp,%rbx,8)
test   %rax,%rax
je     11be <test_dmem+0x4e>
mov    $0x400,%edx
mov    %rax,%rdi
mov    %ebx,%esi
call   1060 <memset@plt>
add    $0x1,%rbx
cmp    $0x14,%rbx
jne    1190 <test_dmem+0x20>
jmp    11ca <test_dmem+0x5a>
lea    0xeb2(%rip),%rdi
call   1040 <fail@plt>
mov    $0x1,%al
xor    %r14d,%r14d
mov    (%rsp,%r14,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movsbq (%rcx,%rdx,1),%rsi
mov    %esi,%esi
cmp    %rsi,%r14
jne    1248 <test_dmem+0xd8>
movsbq 0x1(%rcx,%rdx,1),%rsi
mov    %esi,%esi
cmp    %rsi,%r14
jne    1248 <test_dmem+0xd8>
movsbq 0x2(%rcx,%rdx,1),%rsi
mov    %esi,%esi
cmp    %rsi,%r14
jne    1248 <test_dmem+0xd8>
movsbq 0x3(%rcx,%rdx,1),%rsi
mov    %esi,%esi
cmp    %rsi,%r14
jne    1248 <test_dmem+0xd8>
add    $0x4,%rdx
cmp    $0x400,%rdx
jne    11e0 <test_dmem+0x70>
cmp    $0x13,%r14
lea    0x1(%r14),%rcx
setb   %al
mov    %rcx,%r14
cmp    $0x14,%rcx
jne    11cf <test_dmem+0x5f>
lea    0xe4e(%rip),%rdi
call   1050 <pr@plt>
mov    $0x14,%r14d
jmp    1269 <test_dmem+0xf9>
test   $0x1,%al
je     1258 <test_dmem+0xe8>
lea    0xe2d(%rip),%rdi
call   1040 <fail@plt>
lea    0xe2a(%rip),%rdi
call   1050 <pr@plt>
test   %r14d,%r14d
je     1284 <test_dmem+0x114>
mov    %r14d,%r15d
xor    %ebx,%ebx
xchg   %ax,%ax
mov    (%rsp,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1270 <test_dmem+0x100>
jmp    1287 <test_dmem+0x117>
xor    %r14d,%r14d
lea    0xe00(%rip),%rdi
call   1050 <pr@plt>
mov    %r14d,%edi
mov    $0x400,%esi
call   1070 <calloc@plt>
mov    %rax,%rbx
test   %rax,%rax
jne    12b4 <test_dmem+0x144>
lea    0xde6(%rip),%rdi
call   1040 <fail@plt>
mov    $0x4,%eax
nopl   0x0(%rax)
cmpb   $0x0,-0x3(%rbx,%rax,1)
jne    12e7 <test_dmem+0x177>
cmpb   $0x0,-0x2(%rbx,%rax,1)
jne    12e7 <test_dmem+0x177>
cmpb   $0x0,-0x1(%rbx,%rax,1)
jne    12e7 <test_dmem+0x177>
cmp    $0x400,%rax
je     12f3 <test_dmem+0x183>
cmpb   $0x0,(%rbx,%rax,1)
lea    0x4(%rax),%rax
je     12c0 <test_dmem+0x150>
lea    0xdb0(%rip),%rdi
call   1040 <fail@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
lea    0xda5(%rip),%rdi
call   1050 <pr@plt>
mov    $0x7b,%edi
call   1080 <malloc@plt>
mov    %rax,%rbx
test   %rax,%rax
jne    1325 <test_dmem+0x1b5>
lea    0xd8f(%rip),%rdi
call   1040 <fail@plt>
movaps 0xcd4(%rip),%xmm0
movups %xmm0,(%rbx)
movaps 0xcda(%rip),%xmm0
movups %xmm0,0x10(%rbx)
movaps 0xcdf(%rip),%xmm0
movups %xmm0,0x20(%rbx)
movaps 0xce4(%rip),%xmm0
movups %xmm0,0x30(%rbx)
movaps 0xce9(%rip),%xmm0
movups %xmm0,0x40(%rbx)
movaps 0xcee(%rip),%xmm0
movups %xmm0,0x50(%rbx)
movaps 0xcf3(%rip),%xmm0
movups %xmm0,0x60(%rbx)
movabs $0x7776757473727170,%rax
75 76 77
mov    %rax,0x70(%rbx)
movw   $0x7978,0x78(%rbx)
movb   $0x7a,0x7a(%rbx)
mov    %rbx,%rdi
mov    $0x101,%esi
call   1090 <realloc@plt>
mov    %rax,%rbx
test   %rax,%rax
jne    13aa <test_dmem+0x23a>
lea    0xd13(%rip),%rdi
call   1040 <fail@plt>
xor    %eax,%eax
nopl   0x0(%rax)
movsbq (%rbx,%rax,1),%rcx
mov    %ecx,%ecx
cmp    %rcx,%rax
jne    13ed <test_dmem+0x27d>
movsbq 0x1(%rbx,%rax,1),%rcx
mov    %ecx,%edx
lea    0x1(%rax),%rcx
cmp    %rdx,%rcx
jne    13ed <test_dmem+0x27d>
movsbq 0x2(%rbx,%rax,1),%rax
mov    %eax,%eax
add    $0x1,%rcx
cmp    %rax,%rcx
jne    13ed <test_dmem+0x27d>
add    $0x1,%rcx
mov    %rcx,%rax
cmp    $0x7b,%rcx
jne    13b0 <test_dmem+0x240>
jmp    13f9 <test_dmem+0x289>
lea    0xcce(%rip),%rdi
call   1040 <fail@plt>
mov    %rbx,%rdi
mov    $0x61,%esi
call   1090 <realloc@plt>
mov    %rax,%rbx
test   %rax,%rax
jne    141a <test_dmem+0x2aa>
lea    0xcb7(%rip),%rdi
call   1040 <fail@plt>
xor    %eax,%eax
nopl   0x0(%rax)
movsbq (%rbx,%rax,1),%rcx
mov    %ecx,%ecx
cmp    %rcx,%rax
jne    146e <test_dmem+0x2fe>
lea    0x1(%rax),%rcx
cmp    $0x61,%rcx
je     147a <test_dmem+0x30a>
movsbq 0x1(%rbx,%rax,1),%rdx
mov    %edx,%edx
cmp    %rdx,%rcx
jne    146e <test_dmem+0x2fe>
movsbq 0x2(%rbx,%rax,1),%rdx
mov    %edx,%edx
add    $0x1,%rcx
cmp    %rdx,%rcx
jne    146e <test_dmem+0x2fe>
movsbq 0x3(%rbx,%rax,1),%rax
mov    %eax,%eax
add    $0x1,%rcx
cmp    %rax,%rcx
jne    146e <test_dmem+0x2fe>
add    $0x1,%rcx
mov    %rcx,%rax
jmp    1420 <test_dmem+0x2b0>
lea    0xc61(%rip),%rdi
call   1040 <fail@plt>
mov    %rbx,%rdi
add    $0x200,%rsp
pop    %rbx
pop    %r14
pop    %r15
jmp    1030 <free@plt>

LLVM IR (-O0):
@.str = [7 x i8] c"malloc\00"
@.str.1 = [9 x i8] c"malloc-1\00"
@.str.2 = [9 x i8] c"malloc-2\00"
@.str.3 = [5 x i8] c"free\00"
@.str.4 = [7 x i8] c"calloc\00"
@.str.5 = [9 x i8] c"calloc-1\00"
@.str.6 = [9 x i8] c"calloc-2\00"
@.str.7 = [8 x i8] c"realloc\00"
@.str.8 = [9 x i8] c"malloc-3\00"
@.str.9 = [10 x i8] c"realloc-1\00"
@.str.10 = [10 x i8] c"realloc-2\00"
@.str.11 = [10 x i8] c"realloc-3\00"
@.str.12 = [10 x i8] c"realloc-4\00"
define void @test_dmem() {
%1 = alloca [64 x i8*]
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i32
%5 = call i32 @pr(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %3
br label %6
6: ; preds = %34, %0
%7 = load i32, i32* %3
%8 = icmp slt i32 %7, 20
br i1 %8, label %9, label %37
9: ; preds = %6
%10 = call i8* @malloc(i32 1024)
%11 = load i32, i32* %3
%12 = sext i32 %11 to i64
%13 = getelementptr inbounds [64 x i8*], [64 x i8*]* %1, i64 0, i64 %12
store i8* %10, i8** %13
%14 = icmp eq i8* %10, null
br i1 %14, label %15, label %16
15: ; preds = %9
br label %37
16: ; preds = %9
store i32 0, i32* %4
br label %17
17: ; preds = %30, %16
%18 = load i32, i32* %4
%19 = icmp slt i32 %18, 1024
br i1 %19, label %20, label %33
20: ; preds = %17
%21 = load i32, i32* %3
%22 = trunc i32 %21 to i8
%23 = load i32, i32* %3
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [64 x i8*], [64 x i8*]* %1, i64 0, i64 %24
%26 = load i8*, i8** %25
%27 = load i32, i32* %4
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds i8, i8* %26, i64 %28
store i8 %22, i8* %29
br label %30
30: ; preds = %20
%31 = load i32, i32* %4
%32 = add nsw i32 %31, 1
store i32 %32, i32* %4
br label %17
33: ; preds = %17
br label %34
34: ; preds = %33
%35 = load i32, i32* %3
%36 = add nsw i32 %35, 1
store i32 %36, i32* %3
br label %6
37: ; preds = %15, %6
%38 = load i32, i32* %3
%39 = icmp slt i32 %38, 20
br i1 %39, label %40, label %42
40: ; preds = %37
%41 = call i32 @fail(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i64 0, i64 0))
br label %42
42: ; preds = %40, %37
store i32 0, i32* %3
br label %43
43: ; preds = %72, %42
%44 = load i32, i32* %3
%45 = icmp slt i32 %44, 20
br i1 %45, label %46, label %75
46: ; preds = %43
store i32 0, i32* %4
br label %47
47: ; preds = %64, %46
%48 = load i32, i32* %4
%49 = icmp slt i32 %48, 1024
br i1 %49, label %50, label %67
50: ; preds = %47
%51 = load i32, i32* %3
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [64 x i8*], [64 x i8*]* %1, i64 0, i64 %52
%54 = load i8*, i8** %53
%55 = load i32, i32* %4
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %54, i64 %56
%58 = load i8, i8* %57
%59 = sext i8 %58 to i32
%60 = load i32, i32* %3
%61 = icmp ne i32 %59, %60
br i1 %61, label %62, label %63
62: ; preds = %50
br label %67
63: ; preds = %50
br label %64
64: ; preds = %63
%65 = load i32, i32* %4
%66 = add nsw i32 %65, 1
store i32 %66, i32* %4
br label %47
67: ; preds = %62, %47
%68 = load i32, i32* %4
%69 = icmp ne i32 %68, 1024
br i1 %69, label %70, label %71
70: ; preds = %67
br label %75
71: ; preds = %67
br label %72
72: ; preds = %71
%73 = load i32, i32* %3
%74 = add nsw i32 %73, 1
store i32 %74, i32* %3
br label %43
75: ; preds = %70, %43
%76 = load i32, i32* %3
%77 = icmp slt i32 %76, 20
br i1 %77, label %78, label %80
78: ; preds = %75
%79 = call i32 @fail(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0))
br label %80
80: ; preds = %78, %75
%81 = call i32 @pr(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
store i32 0, i32* %4
br label %82
82: ; preds = %92, %80
%83 = load i32, i32* %4
%84 = load i32, i32* %3
%85 = icmp slt i32 %83, %84
br i1 %85, label %86, label %95
86: ; preds = %82
%87 = load i32, i32* %4
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds [64 x i8*], [64 x i8*]* %1, i64 0, i64 %88
%90 = load i8*, i8** %89
%91 = call i32 @free(i8* %90)
br label %92
92: ; preds = %86
%93 = load i32, i32* %4
%94 = add nsw i32 %93, 1
store i32 %94, i32* %4
br label %82
95: ; preds = %82
%96 = call i32 @pr(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0))
%97 = load i32, i32* %3
%98 = call i8* @calloc(i32 %97, i32 1024)
store i8* %98, i8** %2
%99 = icmp eq i8* %98, null
br i1 %99, label %100, label %102
100: ; preds = %95
%101 = call i32 @fail(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0))
br label %102
102: ; preds = %100, %95
store i32 0, i32* %3
br label %103
103: ; preds = %115, %102
%104 = load i32, i32* %3
%105 = icmp slt i32 %104, 1024
br i1 %105, label %106, label %118
106: ; preds = %103
%107 = load i8*, i8** %2
%108 = load i32, i32* %3
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i8, i8* %107, i64 %109
%111 = load i8, i8* %110
%112 = icmp ne i8 %111, 0
br i1 %112, label %113, label %114
113: ; preds = %106
br label %118
114: ; preds = %106
br label %115
115: ; preds = %114
%116 = load i32, i32* %3
%117 = add nsw i32 %116, 1
store i32 %117, i32* %3
br label %103
118: ; preds = %113, %103
%119 = load i32, i32* %3
%120 = icmp slt i32 %119, 1024
br i1 %120, label %121, label %123
121: ; preds = %118
%122 = call i32 @fail(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.6, i64 0, i64 0))
br label %123
123: ; preds = %121, %118
%124 = load i8*, i8** %2
%125 = call i32 @free(i8* %124)
%126 = call i32 @pr(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0))
%127 = call i8* @malloc(i32 123)
store i8* %127, i8** %2
%128 = icmp eq i8* %127, null
br i1 %128, label %129, label %131
129: ; preds = %123
%130 = call i32 @fail(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.8, i64 0, i64 0))
br label %131
131: ; preds = %129, %123
store i32 0, i32* %3
br label %132
132: ; preds = %142, %131
%133 = load i32, i32* %3
%134 = icmp slt i32 %133, 123
br i1 %134, label %135, label %145
135: ; preds = %132
%136 = load i32, i32* %3
%137 = trunc i32 %136 to i8
%138 = load i8*, i8** %2
%139 = load i32, i32* %3
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i8, i8* %138, i64 %140
store i8 %137, i8* %141
br label %142
142: ; preds = %135
%143 = load i32, i32* %3
%144 = add nsw i32 %143, 1
store i32 %144, i32* %3
br label %132
145: ; preds = %132
%146 = load i8*, i8** %2
%147 = call i8* @realloc(i8* %146, i32 257)
store i8* %147, i8** %2
%148 = icmp eq i8* %147, null
br i1 %148, label %149, label %151
149: ; preds = %145
%150 = call i32 @fail(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.9, i64 0, i64 0))
br label %151
151: ; preds = %149, %145
store i32 0, i32* %3
br label %152
152: ; preds = %166, %151
%153 = load i32, i32* %3
%154 = icmp slt i32 %153, 123
br i1 %154, label %155, label %169
155: ; preds = %152
%156 = load i8*, i8** %2
%157 = load i32, i32* %3
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i8, i8* %156, i64 %158
%160 = load i8, i8* %159
%161 = sext i8 %160 to i32
%162 = load i32, i32* %3
%163 = icmp ne i32 %161, %162
br i1 %163, label %164, label %165
164: ; preds = %155
br label %169
165: ; preds = %155
br label %166
166: ; preds = %165
%167 = load i32, i32* %3
%168 = add nsw i32 %167, 1
store i32 %168, i32* %3
br label %152
169: ; preds = %164, %152
%170 = load i32, i32* %3
%171 = icmp slt i32 %170, 123
br i1 %171, label %172, label %174
172: ; preds = %169
%173 = call i32 @fail(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i64 0, i64 0))
br label %174
174: ; preds = %172, %169
%175 = load i8*, i8** %2
%176 = call i8* @realloc(i8* %175, i32 97)
store i8* %176, i8** %2
%177 = icmp eq i8* %176, null
br i1 %177, label %178, label %180
178: ; preds = %174
%179 = call i32 @fail(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i64 0, i64 0))
br label %180
180: ; preds = %178, %174
store i32 0, i32* %3
br label %181
181: ; preds = %195, %180
%182 = load i32, i32* %3
%183 = icmp slt i32 %182, 97
br i1 %183, label %184, label %198
184: ; preds = %181
%185 = load i8*, i8** %2
%186 = load i32, i32* %3
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i8, i8* %185, i64 %187
%189 = load i8, i8* %188
%190 = sext i8 %189 to i32
%191 = load i32, i32* %3
%192 = icmp ne i32 %190, %191
br i1 %192, label %193, label %194
193: ; preds = %184
br label %198
194: ; preds = %184
br label %195
195: ; preds = %194
%196 = load i32, i32* %3
%197 = add nsw i32 %196, 1
store i32 %197, i32* %3
br label %181
198: ; preds = %193, %181
%199 = load i32, i32* %3
%200 = icmp slt i32 %199, 97
br i1 %200, label %201, label %203
201: ; preds = %198
%202 = call i32 @fail(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.12, i64 0, i64 0))
br label %203
203: ; preds = %201, %198
%204 = load i8*, i8** %2
%205 = call i32 @free(i8* %204)
ret void
}

LLVM IR (-O2):
@.str = [7 x i8] c"malloc\00"
@.str.1 = [9 x i8] c"malloc-1\00"
@.str.2 = [9 x i8] c"malloc-2\00"
@.str.3 = [5 x i8] c"free\00"
@.str.4 = [7 x i8] c"calloc\00"
@.str.5 = [9 x i8] c"calloc-1\00"
@.str.6 = [9 x i8] c"calloc-2\00"
@.str.7 = [8 x i8] c"realloc\00"
@.str.8 = [9 x i8] c"malloc-3\00"
@.str.9 = [10 x i8] c"realloc-1\00"
@.str.10 = [10 x i8] c"realloc-2\00"
@.str.11 = [10 x i8] c"realloc-3\00"
@.str.12 = [10 x i8] c"realloc-4\00"
define void @test_dmem() {
%1 = alloca [64 x i8*]
%2 = bitcast [64 x i8*]* %1 to i8*
%3 = tail call i32 @pr(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0))
br label %4
4: ; preds = %0, %9
%5 = phi i64 [ 0, %0 ], [ %11, %9 ]
%6 = tail call dereferenceable_or_null(1024) i8* @malloc(i32 1024)
%7 = getelementptr inbounds [64 x i8*], [64 x i8*]* %1, i64 0, i64 %5
store i8* %6, i8** %7
%8 = icmp eq i8* %6, null
br i1 %8, label %13, label %9
9: ; preds = %4
%10 = trunc i64 %5 to i8
%11 = add nuw nsw i64 %5, 1
%12 = icmp eq i64 %11, 20
br i1 %12, label %15, label %4
13: ; preds = %4
%14 = tail call i32 @fail(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i64 0, i64 0))
br label %15
15: ; preds = %9, %13
br label %16
16: ; preds = %15, %52
%17 = phi i64 [ %53, %52 ], [ 0, %15 ]
%18 = phi i1 [ %54, %52 ], [ true, %15 ]
%19 = getelementptr inbounds [64 x i8*], [64 x i8*]* %1, i64 0, i64 %17
%20 = load i8*, i8** %19
br label %21
21: ; preds = %49, %16
%22 = phi i64 [ 0, %16 ], [ %50, %49 ]
%23 = getelementptr inbounds i8, i8* %20, i64 %22
%24 = load i8, i8* %23
%25 = sext i8 %24 to i64
%26 = and i64 %25, 4294967295
%27 = icmp eq i64 %17, %26
br i1 %27, label %28, label %58
28: ; preds = %21
%29 = or i64 %22, 1
%30 = getelementptr inbounds i8, i8* %20, i64 %29
%31 = load i8, i8* %30
%32 = sext i8 %31 to i64
%33 = and i64 %32, 4294967295
%34 = icmp eq i64 %17, %33
br i1 %34, label %35, label %58
35: ; preds = %28
%36 = or i64 %22, 2
%37 = getelementptr inbounds i8, i8* %20, i64 %36
%38 = load i8, i8* %37
%39 = sext i8 %38 to i64
%40 = and i64 %39, 4294967295
%41 = icmp eq i64 %17, %40
br i1 %41, label %42, label %58
42: ; preds = %35
%43 = or i64 %22, 3
%44 = getelementptr inbounds i8, i8* %20, i64 %43
%45 = load i8, i8* %44
%46 = sext i8 %45 to i64
%47 = and i64 %46, 4294967295
%48 = icmp eq i64 %17, %47
br i1 %48, label %49, label %58
49: ; preds = %42
%50 = add nuw nsw i64 %22, 4
%51 = icmp eq i64 %50, 1024
br i1 %51, label %52, label %21
52: ; preds = %49
%53 = add nuw nsw i64 %17, 1
%54 = icmp ult i64 %17, 19
%55 = icmp eq i64 %53, 20
br i1 %55, label %56, label %16
56: ; preds = %52
%57 = tail call i32 @pr(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
br label %65
58: ; preds = %42, %35, %28, %21
%59 = trunc i64 %17 to i32
br i1 %18, label %60, label %62
60: ; preds = %58
%61 = tail call i32 @fail(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0))
br label %62
62: ; preds = %60, %58
%63 = tail call i32 @pr(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0))
%64 = icmp eq i32 %59, 0
br i1 %64, label %75, label %65
65: ; preds = %56, %62
%66 = phi i32 [ 20, %56 ], [ %59, %62 ]
%67 = zext i32 %66 to i64
br label %68
68: ; preds = %65, %68
%69 = phi i64 [ 0, %65 ], [ %73, %68 ]
%70 = getelementptr inbounds [64 x i8*], [64 x i8*]* %1, i64 0, i64 %69
%71 = load i8*, i8** %70
%72 = tail call i32 @free(i8* %71)
%73 = add nuw nsw i64 %69, 1
%74 = icmp eq i64 %73, %67
br i1 %74, label %75, label %68
75: ; preds = %68, %62
%76 = phi i32 [ 0, %62 ], [ %66, %68 ]
%77 = tail call i32 @pr(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0))
%78 = tail call i8* @calloc(i32 %76, i32 1024)
%79 = icmp eq i8* %78, null
br i1 %79, label %80, label %82
80: ; preds = %75
%81 = tail call i32 @fail(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0))
br label %82
82: ; preds = %80, %75
br label %83
83: ; preds = %102, %82
%84 = phi i64 [ 0, %82 ], [ %100, %102 ]
%85 = or i64 %84, 1
%86 = getelementptr inbounds i8, i8* %78, i64 %85
%87 = load i8, i8* %86
%88 = icmp eq i8 %87, 0
br i1 %88, label %89, label %106
89: ; preds = %83
%90 = or i64 %84, 2
%91 = getelementptr inbounds i8, i8* %78, i64 %90
%92 = load i8, i8* %91
%93 = icmp eq i8 %92, 0
br i1 %93, label %94, label %106
94: ; preds = %89
%95 = or i64 %84, 3
%96 = getelementptr inbounds i8, i8* %78, i64 %95
%97 = load i8, i8* %96
%98 = icmp eq i8 %97, 0
br i1 %98, label %99, label %106
99: ; preds = %94
%100 = add nuw nsw i64 %84, 4
%101 = icmp eq i64 %100, 1024
br i1 %101, label %108, label %102
102: ; preds = %99
%103 = getelementptr inbounds i8, i8* %78, i64 %100
%104 = load i8, i8* %103
%105 = icmp eq i8 %104, 0
br i1 %105, label %83, label %106
106: ; preds = %102, %94, %89, %83
%107 = tail call i32 @fail(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.6, i64 0, i64 0))
br label %108
108: ; preds = %99, %106
%109 = tail call i32 @free(i8* %78)
%110 = tail call i32 @pr(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0))
%111 = tail call dereferenceable_or_null(123) i8* @malloc(i32 123)
%112 = icmp eq i8* %111, null
br i1 %112, label %113, label %115
113: ; preds = %108
%114 = tail call i32 @fail(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.8, i64 0, i64 0))
br label %115
115: ; preds = %113, %108
%116 = bitcast i8* %111 to <16 x i8>*
store <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, <16 x i8>* %116
%117 = getelementptr inbounds i8, i8* %111, i64 16
%118 = bitcast i8* %117 to <16 x i8>*
store <16 x i8> <i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31>, <16 x i8>* %118
%119 = getelementptr inbounds i8, i8* %111, i64 32
%120 = bitcast i8* %119 to <16 x i8>*
store <16 x i8> <i8 32, i8 33, i8 34, i8 35, i8 36, i8 37, i8 38, i8 39, i8 40, i8 41, i8 42, i8 43, i8 44, i8 45, i8 46, i8 47>, <16 x i8>* %120
%121 = getelementptr inbounds i8, i8* %111, i64 48
%122 = bitcast i8* %121 to <16 x i8>*
store <16 x i8> <i8 48, i8 49, i8 50, i8 51, i8 52, i8 53, i8 54, i8 55, i8 56, i8 57, i8 58, i8 59, i8 60, i8 61, i8 62, i8 63>, <16 x i8>* %122
%123 = getelementptr inbounds i8, i8* %111, i64 64
%124 = bitcast i8* %123 to <16 x i8>*
store <16 x i8> <i8 64, i8 65, i8 66, i8 67, i8 68, i8 69, i8 70, i8 71, i8 72, i8 73, i8 74, i8 75, i8 76, i8 77, i8 78, i8 79>, <16 x i8>* %124
%125 = getelementptr inbounds i8, i8* %111, i64 80
%126 = bitcast i8* %125 to <16 x i8>*
store <16 x i8> <i8 80, i8 81, i8 82, i8 83, i8 84, i8 85, i8 86, i8 87, i8 88, i8 89, i8 90, i8 91, i8 92, i8 93, i8 94, i8 95>, <16 x i8>* %126
%127 = getelementptr inbounds i8, i8* %111, i64 96
%128 = bitcast i8* %127 to <16 x i8>*
store <16 x i8> <i8 96, i8 97, i8 98, i8 99, i8 100, i8 101, i8 102, i8 103, i8 104, i8 105, i8 106, i8 107, i8 108, i8 109, i8 110, i8 111>, <16 x i8>* %128
%129 = getelementptr inbounds i8, i8* %111, i64 112
store i8 112, i8* %129
%130 = getelementptr inbounds i8, i8* %111, i64 113
store i8 113, i8* %130
%131 = getelementptr inbounds i8, i8* %111, i64 114
store i8 114, i8* %131
%132 = getelementptr inbounds i8, i8* %111, i64 115
store i8 115, i8* %132
%133 = getelementptr inbounds i8, i8* %111, i64 116
store i8 116, i8* %133
%134 = getelementptr inbounds i8, i8* %111, i64 117
store i8 117, i8* %134
%135 = getelementptr inbounds i8, i8* %111, i64 118
store i8 118, i8* %135
%136 = getelementptr inbounds i8, i8* %111, i64 119
store i8 119, i8* %136
%137 = getelementptr inbounds i8, i8* %111, i64 120
store i8 120, i8* %137
%138 = getelementptr inbounds i8, i8* %111, i64 121
store i8 121, i8* %138
%139 = getelementptr inbounds i8, i8* %111, i64 122
store i8 122, i8* %139
%140 = tail call i8* @realloc(i8* %111, i32 257)
%141 = icmp eq i8* %140, null
br i1 %141, label %142, label %144
142: ; preds = %115
%143 = tail call i32 @fail(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.9, i64 0, i64 0))
br label %144
144: ; preds = %142, %115
br label %162
145: ; preds = %162
%146 = add nuw nsw i64 %163, 1
%147 = getelementptr inbounds i8, i8* %140, i64 %146
%148 = load i8, i8* %147
%149 = sext i8 %148 to i64
%150 = and i64 %149, 4294967295
%151 = icmp eq i64 %146, %150
br i1 %151, label %152, label %169
152: ; preds = %145
%153 = add nuw nsw i64 %163, 2
%154 = getelementptr inbounds i8, i8* %140, i64 %153
%155 = load i8, i8* %154
%156 = sext i8 %155 to i64
%157 = and i64 %156, 4294967295
%158 = icmp eq i64 %153, %157
br i1 %158, label %159, label %169
159: ; preds = %152
%160 = add nuw nsw i64 %163, 3
%161 = icmp eq i64 %160, 123
br i1 %161, label %171, label %162
162: ; preds = %159, %144
%163 = phi i64 [ 0, %144 ], [ %160, %159 ]
%164 = getelementptr inbounds i8, i8* %140, i64 %163
%165 = load i8, i8* %164
%166 = sext i8 %165 to i64
%167 = and i64 %166, 4294967295
%168 = icmp eq i64 %163, %167
br i1 %168, label %145, label %169
169: ; preds = %152, %145, %162
%170 = tail call i32 @fail(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i64 0, i64 0))
br label %171
171: ; preds = %159, %169
%172 = tail call i8* @realloc(i8* %140, i32 97)
%173 = icmp eq i8* %172, null
br i1 %173, label %174, label %176
174: ; preds = %171
%175 = tail call i32 @fail(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i64 0, i64 0))
br label %176
176: ; preds = %174, %171
br label %202
177: ; preds = %202
%178 = or i64 %203, 1
%179 = icmp eq i64 %178, 97
br i1 %179, label %211, label %180
180: ; preds = %177
%181 = getelementptr inbounds i8, i8* %172, i64 %178
%182 = load i8, i8* %181
%183 = sext i8 %182 to i64
%184 = and i64 %183, 4294967295
%185 = icmp eq i64 %178, %184
br i1 %185, label %186, label %209
186: ; preds = %180
%187 = or i64 %203, 2
%188 = getelementptr inbounds i8, i8* %172, i64 %187
%189 = load i8, i8* %188
%190 = sext i8 %189 to i64
%191 = and i64 %190, 4294967295
%192 = icmp eq i64 %187, %191
br i1 %192, label %193, label %209
193: ; preds = %186
%194 = or i64 %203, 3
%195 = getelementptr inbounds i8, i8* %172, i64 %194
%196 = load i8, i8* %195
%197 = sext i8 %196 to i64
%198 = and i64 %197, 4294967295
%199 = icmp eq i64 %194, %198
br i1 %199, label %200, label %209
200: ; preds = %193
%201 = add nuw nsw i64 %203, 4
br label %202
202: ; preds = %200, %176
%203 = phi i64 [ 0, %176 ], [ %201, %200 ]
%204 = getelementptr inbounds i8, i8* %172, i64 %203
%205 = load i8, i8* %204
%206 = sext i8 %205 to i64
%207 = and i64 %206, 4294967295
%208 = icmp eq i64 %203, %207
br i1 %208, label %177, label %209
209: ; preds = %193, %186, %180, %202
%210 = tail call i32 @fail(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.12, i64 0, i64 0))
br label %211
211: ; preds = %177, %209
%212 = tail call i32 @free(i8* %172)
ret void
}