Re: [llvmlinux] percpu | bitmap issue? (Cannot boot on bare metal due to a kernel NULL pointer dereference)

From: Sedat Dilek
Date: Tue Sep 08 2015 - 23:04:23 EST

Next message: J O'Neill & Co Solicitors: "Private Message"
Previous message: Fabio Estevam: "Re: [PATCH] power: bq24261_charger: Add support for TI BQ24261 charger"
In reply to: Sedat Dilek: "Re: [llvmlinux] percpu | bitmap issue? (Cannot boot on bare metal due to a kernel NULL pointer dereference)"
Next in thread: Sedat Dilek: "Re: [llvmlinux] percpu | bitmap issue? (Cannot boot on bare metal due to a kernel NULL pointer dereference)"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

On Wed, Sep 9, 2015 at 4:51 AM, Sedat Dilek <sedat.dilek@xxxxxxxxx> wrote:
> On Wed, Sep 9, 2015 at 4:29 AM, Baoquan He <bhe@xxxxxxxxxx> wrote:
>>
>> Seems it happened when call num_possible_cpus() which is a inline
>> function to call __bitmap_weight(). So did you check
>> lib/bitmap.c:__bitmap_weight() by objdump?
>>
>> setup_percpu: NR_CPUS:256 nr_cpumask_bits:256 nr_cpu_ids:1 nr_node_ids:1
>>
>
> [ CC->TO Denys ]
>
> Hi Boaquan,
>
> Thanks for your reply.
>
> I tried a lot in the meantime :-).
>
> For example I applied a patch from Denys Vlasenko <dvlasenk@xxxxxxxxxx>...
>
> commit 1a1d48a4a8fde49aedc045d894efe67173d59fe0
> "linux/bitmap: Force inlining of bitmap weight functions"
>
> ...on top of Linux v4.2.
>
> This resulted in the same call-trace in QEMU.
>
> I hacked around to only re-build mm/percpu.c with GCC (rest with
> CLANG) with some guidance from Linus (compiler warapper-script) etc.
>
> What do you need for outputs?
> objdump of lib/bitmap.o?
> From both builds - with GCC and CLANG?
>
> Please give me clear instructions, Thanks!
>
> Regards,
> - Sedat -
>
> [1] http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=1a1d48a4a8fde49aedc045d894efe67173d59fe0

Below snippets against Linux v4.2 and Linux v4.2 plus llvmlinux-fixes
(see file-attachment)...
( The patch "linux/bitmap: Force inlining of bitmap weight functions"
from Denys was not applied. )

[ lib-bitmap_o-objdump-drw_CLANG-3-7.txt ]

0000000000000670 <__bitmap_weight>:
670: 49 89 f8 mov %rdi,%r8
673: 31 d2 xor %edx,%edx
675: 41 89 f1 mov %esi,%r9d
678: 41 c1 e9 06 shr $0x6,%r9d
67c: b8 00 00 00 00 mov $0x0,%eax
681: 74 26 je 6a9 <__bitmap_weight+0x39>
683: 31 d2 xor %edx,%edx
685: 45 89 ca mov %r9d,%r10d
688: 4c 89 c1 mov %r8,%rcx
68b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
690: 48 8b 39 mov (%rcx),%rdi
693: e8 00 00 00 00 callq 698
<__bitmap_weight+0x28> 694: R_X86_64_PC32
__sw_hweight64-0x4
698: 89 d2 mov %edx,%edx
69a: 48 01 c2 add %rax,%rdx
69d: 48 83 c1 08 add $0x8,%rcx
6a1: 41 ff ca dec %r10d
6a4: 75 ea jne 690 <__bitmap_weight+0x20>
6a6: 44 89 c8 mov %r9d,%eax
6a9: 40 f6 c6 3f test $0x3f,%sil
6ad: 74 1c je 6cb <__bitmap_weight+0x5b>
6af: f7 de neg %esi
6b1: 48 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%rdi
6b8: 40 88 f1 mov %sil,%cl
6bb: 48 d3 ef shr %cl,%rdi
6be: 49 23 3c c0 and (%r8,%rax,8),%rdi
6c2: e8 00 00 00 00 callq 6c7
<__bitmap_weight+0x57> 6c3: R_X86_64_PC32
__sw_hweight64-0x4
6c7: 01 d0 add %edx,%eax
6c9: 89 c2 mov %eax,%edx
6cb: 89 d0 mov %edx,%eax
6cd: c3 retq
6ce: 66 90 xchg %ax,%ax

[ lib-bitmap_o-objdump-drw_GCC-4-9.txt ]

0000000000000d60 <__bitmap_weight>:
d60: 89 f1 mov %esi,%ecx
d62: 55 push %rbp
d63: 49 89 fa mov %rdi,%r10
d66: c1 e9 06 shr $0x6,%ecx
d69: 85 c9 test %ecx,%ecx
d6b: 48 89 e5 mov %rsp,%rbp
d6e: 74 52 je dc2 <__bitmap_weight+0x62>
d70: 8d 41 ff lea -0x1(%rcx),%eax
d73: 48 89 fa mov %rdi,%rdx
d76: 45 31 c0 xor %r8d,%r8d
d79: 4c 8d 0c c5 08 00 00 00 lea 0x8(,%rax,8),%r9
d81: 49 01 f9 add %rdi,%r9
d84: 48 8b 3a mov (%rdx),%rdi
d87: 48 83 c2 08 add $0x8,%rdx
d8b: e8 00 00 00 00 callq d90 <__bitmap_weight+0x30>
d8c: R_X86_64_PC32 __sw_hweight64-0x4
d90: 41 01 c0 add %eax,%r8d
d93: 4c 39 ca cmp %r9,%rdx
d96: 75 ec jne d84 <__bitmap_weight+0x24>
d98: 40 f6 c6 3f test $0x3f,%sil
d9c: 44 89 c0 mov %r8d,%eax
d9f: 74 1f je dc0 <__bitmap_weight+0x60>
da1: f7 de neg %esi
da3: 89 ca mov %ecx,%edx
da5: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax
dac: 89 f1 mov %esi,%ecx
dae: 48 d3 e8 shr %cl,%rax
db1: 49 23 04 d2 and (%r10,%rdx,8),%rax
db5: 48 89 c7 mov %rax,%rdi
db8: e8 00 00 00 00 callq dbd <__bitmap_weight+0x5d>
db9: R_X86_64_PC32 __sw_hweight64-0x4
dbd: 44 01 c0 add %r8d,%eax
dc0: 5d pop %rbp
dc1: c3 retq
dc2: 85 f6 test %esi,%esi
dc4: 74 19 je ddf <__bitmap_weight+0x7f>
dc6: f7 de neg %esi
dc8: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax
dcf: 45 31 c0 xor %r8d,%r8d
dd2: 89 f1 mov %esi,%ecx
dd4: 48 d3 e8 shr %cl,%rax
dd7: 49 23 02 and (%r10),%rax
dda: 48 89 c7 mov %rax,%rdi
ddd: eb d9 jmp db8 <__bitmap_weight+0x58>
ddf: 31 c0 xor %eax,%eax
de1: 5d pop %rbp
de2: c3 retq
de3: 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32
nopw %cs:0x0(%rax,%rax,1)

- Sedat -

lib/bitmap.o: file format elf64-x86-64

Disassembly of section .text:

0000000000000000 <__bitmap_equal>:
0: 45 31 c9 xor %r9d,%r9d
3: 41 89 d0 mov %edx,%r8d
6: 41 c1 e8 06 shr $0x6,%r8d
a: 74 31 je 3d <__bitmap_equal+0x3d>
c: 49 89 fa mov %rdi,%r10
f: 48 89 f1 mov %rsi,%rcx
12: 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
20: 4d 8b 1a mov (%r10),%r11
23: 31 c0 xor %eax,%eax
25: 4c 3b 19 cmp (%rcx),%r11
28: 75 3a jne 64 <__bitmap_equal+0x64>
2a: 41 ff c1 inc %r9d
2d: 48 83 c1 08 add $0x8,%rcx
31: 49 83 c2 08 add $0x8,%r10
35: 45 39 c1 cmp %r8d,%r9d
38: 72 e6 jb 20 <__bitmap_equal+0x20>
3a: 45 89 c9 mov %r9d,%r9d
3d: f6 c2 3f test $0x3f,%dl
40: 74 1d je 5f <__bitmap_equal+0x5f>
42: 4a 8b 34 ce mov (%rsi,%r9,8),%rsi
46: 4a 33 34 cf xor (%rdi,%r9,8),%rsi
4a: f7 da neg %edx
4c: 48 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%rdi
53: 88 d1 mov %dl,%cl
55: 48 d3 ef shr %cl,%rdi
58: 31 c0 xor %eax,%eax
5a: 48 85 fe test %rdi,%rsi
5d: 75 05 jne 64 <__bitmap_equal+0x64>
5f: b8 01 00 00 00 mov $0x1,%eax
64: c3 retq
65: 66 66 2e 0f 1f 84 00 00 00 00 00 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000000070 <__bitmap_complement>:
70: 31 c0 xor %eax,%eax
72: 41 89 d0 mov %edx,%r8d
75: 41 c1 e8 06 shr $0x6,%r8d
79: 0f 84 8c 00 00 00 je 10b <__bitmap_complement+0x9b>
7f: 45 8d 48 ff lea -0x1(%r8),%r9d
83: 31 c9 xor %ecx,%ecx
85: 41 f6 c0 03 test $0x3,%r8b
89: 74 28 je b3 <__bitmap_complement+0x43>
8b: 45 89 c2 mov %r8d,%r10d
8e: 41 83 e2 03 and $0x3,%r10d
92: 31 c9 xor %ecx,%ecx
94: 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 nopw %cs:0x0(%rax,%rax,1)
a0: 48 8b 04 ce mov (%rsi,%rcx,8),%rax
a4: 48 f7 d0 not %rax
a7: 48 89 04 cf mov %rax,(%rdi,%rcx,8)
ab: 48 ff c1 inc %rcx
ae: 41 39 ca cmp %ecx,%r10d
b1: 75 ed jne a0 <__bitmap_complement+0x30>
b3: 41 83 f9 03 cmp $0x3,%r9d
b7: 72 4f jb 108 <__bitmap_complement+0x98>
b9: 45 89 c1 mov %r8d,%r9d
bc: 41 29 c9 sub %ecx,%r9d
bf: 4c 8d 54 cf 18 lea 0x18(%rdi,%rcx,8),%r10
c4: 48 8d 4c ce 18 lea 0x18(%rsi,%rcx,8),%rcx
c9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
d0: 48 8b 41 e8 mov -0x18(%rcx),%rax
d4: 48 f7 d0 not %rax
d7: 49 89 42 e8 mov %rax,-0x18(%r10)
db: 48 8b 41 f0 mov -0x10(%rcx),%rax
df: 48 f7 d0 not %rax
e2: 49 89 42 f0 mov %rax,-0x10(%r10)
e6: 48 8b 41 f8 mov -0x8(%rcx),%rax
ea: 48 f7 d0 not %rax
ed: 49 89 42 f8 mov %rax,-0x8(%r10)
f1: 48 8b 01 mov (%rcx),%rax
f4: 48 f7 d0 not %rax
f7: 49 89 02 mov %rax,(%r10)
fa: 49 83 c2 20 add $0x20,%r10
fe: 48 83 c1 20 add $0x20,%rcx
102: 41 83 c1 fc add $0xfffffffc,%r9d
106: 75 c8 jne d0 <__bitmap_complement+0x60>
108: 44 89 c0 mov %r8d,%eax
10b: f6 c2 3f test $0x3f,%dl
10e: 74 0b je 11b <__bitmap_complement+0xab>
110: 48 8b 0c c6 mov (%rsi,%rax,8),%rcx
114: 48 f7 d1 not %rcx
117: 48 89 0c c7 mov %rcx,(%rdi,%rax,8)
11b: c3 retq
11c: 0f 1f 40 00 nopl 0x0(%rax)

0000000000000120 <__bitmap_shift_right>:
120: 55 push %rbp
121: 48 89 e5 mov %rsp,%rbp
124: 41 57 push %r15
126: 41 56 push %r14
128: 41 55 push %r13
12a: 41 54 push %r12
12c: 53 push %rbx
12d: 48 83 ec 18 sub $0x18,%rsp
131: 89 cb mov %ecx,%ebx
133: 4c 8d 53 3f lea 0x3f(%rbx),%r10
137: 49 c1 ea 06 shr $0x6,%r10
13b: 41 89 d0 mov %edx,%r8d
13e: 41 c1 e8 06 shr $0x6,%r8d
142: f7 d9 neg %ecx
144: 49 c7 c4 ff ff ff ff mov $0xffffffffffffffff,%r12
14b: 49 d3 ec shr %cl,%r12
14e: 44 89 d0 mov %r10d,%eax
151: 44 29 c0 sub %r8d,%eax
154: 48 89 45 c8 mov %rax,-0x38(%rbp)
158: 0f 86 9b 00 00 00 jbe 1f9 <__bitmap_shift_right+0xd9>
15e: 83 e2 3f and $0x3f,%edx
161: 41 89 d6 mov %edx,%r14d
164: b8 40 00 00 00 mov $0x40,%eax
169: 29 d0 sub %edx,%eax
16b: 48 89 45 d0 mov %rax,-0x30(%rbp)
16f: 48 83 c3 3f add $0x3f,%rbx
173: 48 c1 eb 06 shr $0x6,%rbx
177: 41 89 df mov %ebx,%r15d
17a: 45 29 c7 sub %r8d,%r15d
17d: 4e 8d 6c c6 08 lea 0x8(%rsi,%r8,8),%r13
182: ff cb dec %ebx
184: 4d 89 c1 mov %r8,%r9
187: 49 29 d9 sub %rbx,%r9
18a: 31 db xor %ebx,%ebx
18c: 0f 1f 40 00 nopl 0x0(%rax)
190: 4d 8d 1c 19 lea (%r9,%rbx,1),%r11
194: 85 d2 test %edx,%edx
196: 74 38 je 1d0 <__bitmap_shift_right+0xb0>
198: 49 8d 4c 18 01 lea 0x1(%r8,%rbx,1),%rcx
19d: 4c 39 d1 cmp %r10,%rcx
1a0: be 00 00 00 00 mov $0x0,%esi
1a5: 73 2b jae 1d2 <__bitmap_shift_right+0xb2>
1a7: 49 8d 4c 19 01 lea 0x1(%r9,%rbx,1),%rcx
1ac: 48 83 f9 01 cmp $0x1,%rcx
1b0: 48 19 f6 sbb %rsi,%rsi
1b3: 48 f7 d6 not %rsi
1b6: 4c 09 e6 or %r12,%rsi
1b9: 49 23 74 dd 00 and 0x0(%r13,%rbx,8),%rsi
1be: 48 8b 4d d0 mov -0x30(%rbp),%rcx
1c2: 48 d3 e6 shl %cl,%rsi
1c5: eb 0b jmp 1d2 <__bitmap_shift_right+0xb2>
1c7: 66 0f 1f 84 00 00 00 00 00 nopw 0x0(%rax,%rax,1)
1d0: 31 f6 xor %esi,%esi
1d2: 49 83 fb 01 cmp $0x1,%r11
1d6: 48 19 c0 sbb %rax,%rax
1d9: 48 f7 d0 not %rax
1dc: 4c 09 e0 or %r12,%rax
1df: 49 23 44 dd f8 and -0x8(%r13,%rbx,8),%rax
1e4: 44 88 f1 mov %r14b,%cl
1e7: 48 d3 e8 shr %cl,%rax
1ea: 48 09 f0 or %rsi,%rax
1ed: 48 89 04 df mov %rax,(%rdi,%rbx,8)
1f1: 48 ff c3 inc %rbx
1f4: 41 39 df cmp %ebx,%r15d
1f7: 75 97 jne 190 <__bitmap_shift_right+0x70>
1f9: 45 85 c0 test %r8d,%r8d
1fc: 74 16 je 214 <__bitmap_shift_right+0xf4>
1fe: 48 8b 45 c8 mov -0x38(%rbp),%rax
202: 48 8d 3c c7 lea (%rdi,%rax,8),%rdi
206: 44 89 c2 mov %r8d,%edx
209: 48 c1 e2 03 shl $0x3,%rdx
20d: 31 f6 xor %esi,%esi
20f: e8 00 00 00 00 callq 214 <__bitmap_shift_right+0xf4> 210: R_X86_64_PC32 memset-0x4
214: 48 83 c4 18 add $0x18,%rsp
218: 5b pop %rbx
219: 41 5c pop %r12
21b: 41 5d pop %r13
21d: 41 5e pop %r14
21f: 41 5f pop %r15
221: 5d pop %rbp
222: c3 retq
223: 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000000230 <__bitmap_shift_left>:
230: 55 push %rbp
231: 48 89 e5 mov %rsp,%rbp
234: 41 57 push %r15
236: 41 56 push %r14
238: 53 push %rbx
239: 50 push %rax
23a: 41 89 cb mov %ecx,%r11d
23d: 49 8d 43 3f lea 0x3f(%r11),%rax
241: 48 c1 e8 06 shr $0x6,%rax
245: 41 89 d2 mov %edx,%r10d
248: 41 c1 ea 06 shr $0x6,%r10d
24c: 44 39 d0 cmp %r10d,%eax
24f: 0f 8e 80 00 00 00 jle 2d5 <__bitmap_shift_left+0xa5>
255: 83 e2 3f and $0x3f,%edx
258: 41 b8 40 00 00 00 mov $0x40,%r8d
25e: 41 29 d0 sub %edx,%r8d
261: 41 89 d1 mov %edx,%r9d
264: 49 83 c3 3f add $0x3f,%r11
268: 49 c1 eb 06 shr $0x6,%r11
26c: 44 89 d8 mov %r11d,%eax
26f: 44 29 d0 sub %r10d,%eax
272: 48 98 cltq
274: 48 ff c8 dec %rax
277: 41 8d 4b fe lea -0x2(%r11),%ecx
27b: 44 29 d1 sub %r10d,%ecx
27e: 48 63 c9 movslq %ecx,%rcx
281: 4c 8d 3c ce lea (%rsi,%rcx,8),%r15
285: 41 ff cb dec %r11d
288: 0f 1f 84 00 00 00 00 00 nopl 0x0(%rax,%rax,1)
290: 85 d2 test %edx,%edx
292: 74 1c je 2b0 <__bitmap_shift_left+0x80>
294: 85 c0 test %eax,%eax
296: 41 be 00 00 00 00 mov $0x0,%r14d
29c: 7e 15 jle 2b3 <__bitmap_shift_left+0x83>
29e: 4d 8b 37 mov (%r15),%r14
2a1: 44 88 c1 mov %r8b,%cl
2a4: 49 d3 ee shr %cl,%r14
2a7: eb 0a jmp 2b3 <__bitmap_shift_left+0x83>
2a9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
2b0: 45 31 f6 xor %r14d,%r14d
2b3: 48 8b 1c c6 mov (%rsi,%rax,8),%rbx
2b7: 44 88 c9 mov %r9b,%cl
2ba: 48 d3 e3 shl %cl,%rbx
2bd: 4c 09 f3 or %r14,%rbx
2c0: 44 89 d9 mov %r11d,%ecx
2c3: 48 89 1c cf mov %rbx,(%rdi,%rcx,8)
2c7: 48 ff c8 dec %rax
2ca: 49 83 c7 f8 add $0xfffffffffffffff8,%r15
2ce: 41 ff cb dec %r11d
2d1: 85 c0 test %eax,%eax
2d3: 79 bb jns 290 <__bitmap_shift_left+0x60>
2d5: 45 85 d2 test %r10d,%r10d
2d8: 74 0e je 2e8 <__bitmap_shift_left+0xb8>
2da: 44 89 d2 mov %r10d,%edx
2dd: 48 c1 e2 03 shl $0x3,%rdx
2e1: 31 f6 xor %esi,%esi
2e3: e8 00 00 00 00 callq 2e8 <__bitmap_shift_left+0xb8> 2e4: R_X86_64_PC32 memset-0x4
2e8: 48 83 c4 08 add $0x8,%rsp
2ec: 5b pop %rbx
2ed: 41 5e pop %r14
2ef: 41 5f pop %r15
2f1: 5d pop %rbp
2f2: c3 retq
2f3: 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000000300 <__bitmap_and>:
300: 41 56 push %r14
302: 53 push %rbx
303: 31 c0 xor %eax,%eax
305: 41 89 c8 mov %ecx,%r8d
308: 41 c1 e8 06 shr $0x6,%r8d
30c: 41 b9 00 00 00 00 mov $0x0,%r9d
312: 74 6c je 380 <__bitmap_and+0x80>
314: 31 db xor %ebx,%ebx
316: 0f ba e1 06 bt $0x6,%ecx
31a: b8 00 00 00 00 mov $0x0,%eax
31f: 73 0e jae 32f <__bitmap_and+0x2f>
321: 48 8b 02 mov (%rdx),%rax
324: 48 23 06 and (%rsi),%rax
327: 48 89 07 mov %rax,(%rdi)
32a: bb 01 00 00 00 mov $0x1,%ebx
32f: 41 83 f8 01 cmp $0x1,%r8d
333: 74 48 je 37d <__bitmap_and+0x7d>
335: 45 89 c1 mov %r8d,%r9d
338: 41 29 d9 sub %ebx,%r9d
33b: 4c 8d 54 de 08 lea 0x8(%rsi,%rbx,8),%r10
340: 4c 8d 5c da 08 lea 0x8(%rdx,%rbx,8),%r11
345: 4c 8d 74 df 08 lea 0x8(%rdi,%rbx,8),%r14
34a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1)
350: 49 8b 5b f8 mov -0x8(%r11),%rbx
354: 49 23 5a f8 and -0x8(%r10),%rbx
358: 49 89 5e f8 mov %rbx,-0x8(%r14)
35c: 48 09 c3 or %rax,%rbx
35f: 49 8b 03 mov (%r11),%rax
362: 49 23 02 and (%r10),%rax
365: 49 89 06 mov %rax,(%r14)
368: 48 09 d8 or %rbx,%rax
36b: 49 83 c2 10 add $0x10,%r10
36f: 49 83 c3 10 add $0x10,%r11
373: 49 83 c6 10 add $0x10,%r14
377: 41 83 c1 fe add $0xfffffffe,%r9d
37b: 75 d3 jne 350 <__bitmap_and+0x50>
37d: 45 89 c1 mov %r8d,%r9d
380: f6 c1 3f test $0x3f,%cl
383: 74 1b je 3a0 <__bitmap_and+0xa0>
385: f7 d9 neg %ecx
387: 48 c7 c3 ff ff ff ff mov $0xffffffffffffffff,%rbx
38e: 48 d3 eb shr %cl,%rbx
391: 4a 23 1c ce and (%rsi,%r9,8),%rbx
395: 4a 23 1c ca and (%rdx,%r9,8),%rbx
399: 4a 89 1c cf mov %rbx,(%rdi,%r9,8)
39d: 48 09 d8 or %rbx,%rax
3a0: 48 85 c0 test %rax,%rax
3a3: 0f 95 c0 setne %al
3a6: 0f b6 c0 movzbl %al,%eax
3a9: 5b pop %rbx
3aa: 41 5e pop %r14
3ac: c3 retq
3ad: 0f 1f 00 nopl (%rax)

00000000000003b0 <__bitmap_or>:
3b0: 89 c8 mov %ecx,%eax
3b2: 48 8d 48 3f lea 0x3f(%rax),%rcx
3b6: 48 c1 e9 06 shr $0x6,%rcx
3ba: 85 c9 test %ecx,%ecx
3bc: 74 78 je 436 <__bitmap_or+0x86>
3be: 48 8d 48 3f lea 0x3f(%rax),%rcx
3c2: 49 89 c9 mov %rcx,%r9
3c5: 49 c1 e9 06 shr $0x6,%r9
3c9: 45 31 c0 xor %r8d,%r8d
3cc: 48 0f ba e1 06 bt $0x6,%rcx
3d1: 73 0f jae 3e2 <__bitmap_or+0x32>
3d3: 48 8b 0a mov (%rdx),%rcx
3d6: 48 0b 0e or (%rsi),%rcx
3d9: 48 89 0f mov %rcx,(%rdi)
3dc: 41 b8 01 00 00 00 mov $0x1,%r8d
3e2: 41 83 f9 01 cmp $0x1,%r9d
3e6: 74 4e je 436 <__bitmap_or+0x86>
3e8: 48 83 c0 3f add $0x3f,%rax
3ec: 48 c1 e8 06 shr $0x6,%rax
3f0: 44 29 c0 sub %r8d,%eax
3f3: 4a 8d 4c c6 08 lea 0x8(%rsi,%r8,8),%rcx
3f8: 4a 8d 54 c2 08 lea 0x8(%rdx,%r8,8),%rdx
3fd: 4a 8d 74 c7 08 lea 0x8(%rdi,%r8,8),%rsi
402: 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
410: 48 8b 7a f8 mov -0x8(%rdx),%rdi
414: 48 0b 79 f8 or -0x8(%rcx),%rdi
418: 48 89 7e f8 mov %rdi,-0x8(%rsi)
41c: 48 8b 3a mov (%rdx),%rdi
41f: 48 0b 39 or (%rcx),%rdi
422: 48 89 3e mov %rdi,(%rsi)
425: 48 83 c1 10 add $0x10,%rcx
429: 48 83 c2 10 add $0x10,%rdx
42d: 48 83 c6 10 add $0x10,%rsi
431: 83 c0 fe add $0xfffffffe,%eax
434: 75 da jne 410 <__bitmap_or+0x60>
436: c3 retq
437: 66 0f 1f 84 00 00 00 00 00 nopw 0x0(%rax,%rax,1)

0000000000000440 <__bitmap_xor>:
440: 89 c8 mov %ecx,%eax
442: 48 8d 48 3f lea 0x3f(%rax),%rcx
446: 48 c1 e9 06 shr $0x6,%rcx
44a: 85 c9 test %ecx,%ecx
44c: 74 78 je 4c6 <__bitmap_xor+0x86>
44e: 48 8d 48 3f lea 0x3f(%rax),%rcx
452: 49 89 c9 mov %rcx,%r9
455: 49 c1 e9 06 shr $0x6,%r9
459: 45 31 c0 xor %r8d,%r8d
45c: 48 0f ba e1 06 bt $0x6,%rcx
461: 73 0f jae 472 <__bitmap_xor+0x32>
463: 48 8b 0a mov (%rdx),%rcx
466: 48 33 0e xor (%rsi),%rcx
469: 48 89 0f mov %rcx,(%rdi)
46c: 41 b8 01 00 00 00 mov $0x1,%r8d
472: 41 83 f9 01 cmp $0x1,%r9d
476: 74 4e je 4c6 <__bitmap_xor+0x86>
478: 48 83 c0 3f add $0x3f,%rax
47c: 48 c1 e8 06 shr $0x6,%rax
480: 44 29 c0 sub %r8d,%eax
483: 4a 8d 4c c6 08 lea 0x8(%rsi,%r8,8),%rcx
488: 4a 8d 54 c2 08 lea 0x8(%rdx,%r8,8),%rdx
48d: 4a 8d 74 c7 08 lea 0x8(%rdi,%r8,8),%rsi
492: 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
4a0: 48 8b 7a f8 mov -0x8(%rdx),%rdi
4a4: 48 33 79 f8 xor -0x8(%rcx),%rdi
4a8: 48 89 7e f8 mov %rdi,-0x8(%rsi)
4ac: 48 8b 3a mov (%rdx),%rdi
4af: 48 33 39 xor (%rcx),%rdi
4b2: 48 89 3e mov %rdi,(%rsi)
4b5: 48 83 c1 10 add $0x10,%rcx
4b9: 48 83 c2 10 add $0x10,%rdx
4bd: 48 83 c6 10 add $0x10,%rsi
4c1: 83 c0 fe add $0xfffffffe,%eax
4c4: 75 da jne 4a0 <__bitmap_xor+0x60>
4c6: c3 retq
4c7: 66 0f 1f 84 00 00 00 00 00 nopw 0x0(%rax,%rax,1)

00000000000004d0 <__bitmap_andnot>:
4d0: 41 56 push %r14
4d2: 53 push %rbx
4d3: 31 c0 xor %eax,%eax
4d5: 41 89 c8 mov %ecx,%r8d
4d8: 41 c1 e8 06 shr $0x6,%r8d
4dc: 41 b9 00 00 00 00 mov $0x0,%r9d
4e2: 74 72 je 556 <__bitmap_andnot+0x86>
4e4: 31 db xor %ebx,%ebx
4e6: 0f ba e1 06 bt $0x6,%ecx
4ea: b8 00 00 00 00 mov $0x0,%eax
4ef: 73 11 jae 502 <__bitmap_andnot+0x32>
4f1: 48 8b 02 mov (%rdx),%rax
4f4: 48 f7 d0 not %rax
4f7: 48 23 06 and (%rsi),%rax
4fa: 48 89 07 mov %rax,(%rdi)
4fd: bb 01 00 00 00 mov $0x1,%ebx
502: 41 83 f8 01 cmp $0x1,%r8d
506: 74 4b je 553 <__bitmap_andnot+0x83>
508: 45 89 c1 mov %r8d,%r9d
50b: 41 29 d9 sub %ebx,%r9d
50e: 4c 8d 54 de 08 lea 0x8(%rsi,%rbx,8),%r10
513: 4c 8d 5c da 08 lea 0x8(%rdx,%rbx,8),%r11
518: 4c 8d 74 df 08 lea 0x8(%rdi,%rbx,8),%r14
51d: 0f 1f 00 nopl (%rax)
520: 49 8b 5b f8 mov -0x8(%r11),%rbx
524: 48 f7 d3 not %rbx
527: 49 23 5a f8 and -0x8(%r10),%rbx
52b: 49 89 5e f8 mov %rbx,-0x8(%r14)
52f: 48 09 c3 or %rax,%rbx
532: 49 8b 03 mov (%r11),%rax
535: 48 f7 d0 not %rax
538: 49 23 02 and (%r10),%rax
53b: 49 89 06 mov %rax,(%r14)
53e: 48 09 d8 or %rbx,%rax
541: 49 83 c2 10 add $0x10,%r10
545: 49 83 c3 10 add $0x10,%r11
549: 49 83 c6 10 add $0x10,%r14
54d: 41 83 c1 fe add $0xfffffffe,%r9d
551: 75 cd jne 520 <__bitmap_andnot+0x50>
553: 45 89 c1 mov %r8d,%r9d
556: f6 c1 3f test $0x3f,%cl
559: 74 21 je 57c <__bitmap_andnot+0xac>
55b: 4a 8b 14 ca mov (%rdx,%r9,8),%rdx
55f: 48 f7 d2 not %rdx
562: f7 d9 neg %ecx
564: 48 c7 c3 ff ff ff ff mov $0xffffffffffffffff,%rbx
56b: 48 d3 eb shr %cl,%rbx
56e: 4a 23 1c ce and (%rsi,%r9,8),%rbx
572: 48 21 d3 and %rdx,%rbx
575: 4a 89 1c cf mov %rbx,(%rdi,%r9,8)
579: 48 09 d8 or %rbx,%rax
57c: 48 85 c0 test %rax,%rax
57f: 0f 95 c0 setne %al
582: 0f b6 c0 movzbl %al,%eax
585: 5b pop %rbx
586: 41 5e pop %r14
588: c3 retq
589: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)

0000000000000590 <__bitmap_intersects>:
590: 45 31 c0 xor %r8d,%r8d
593: 41 89 d1 mov %edx,%r9d
596: 41 c1 e9 06 shr $0x6,%r9d
59a: 74 34 je 5d0 <__bitmap_intersects+0x40>
59c: 49 89 fa mov %rdi,%r10
59f: 48 89 f1 mov %rsi,%rcx
5a2: 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
5b0: 4c 8b 19 mov (%rcx),%r11
5b3: b8 01 00 00 00 mov $0x1,%eax
5b8: 4d 85 1a test %r11,(%r10)
5bb: 75 37 jne 5f4 <__bitmap_intersects+0x64>
5bd: 41 ff c0 inc %r8d
5c0: 48 83 c1 08 add $0x8,%rcx
5c4: 49 83 c2 08 add $0x8,%r10
5c8: 45 39 c8 cmp %r9d,%r8d
5cb: 72 e3 jb 5b0 <__bitmap_intersects+0x20>
5cd: 45 89 c0 mov %r8d,%r8d
5d0: f6 c2 3f test $0x3f,%dl
5d3: 74 1d je 5f2 <__bitmap_intersects+0x62>
5d5: f7 da neg %edx
5d7: 49 c7 c1 ff ff ff ff mov $0xffffffffffffffff,%r9
5de: 88 d1 mov %dl,%cl
5e0: 49 d3 e9 shr %cl,%r9
5e3: 4e 23 0c c7 and (%rdi,%r8,8),%r9
5e7: b8 01 00 00 00 mov $0x1,%eax
5ec: 4e 85 0c c6 test %r9,(%rsi,%r8,8)
5f0: 75 02 jne 5f4 <__bitmap_intersects+0x64>
5f2: 31 c0 xor %eax,%eax
5f4: c3 retq
5f5: 66 66 2e 0f 1f 84 00 00 00 00 00 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000000600 <__bitmap_subset>:
600: 45 31 c0 xor %r8d,%r8d
603: 41 89 d1 mov %edx,%r9d
606: 41 c1 e9 06 shr $0x6,%r9d
60a: 74 34 je 640 <__bitmap_subset+0x40>
60c: 49 89 fa mov %rdi,%r10
60f: 49 89 f3 mov %rsi,%r11
612: 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
620: 49 8b 0b mov (%r11),%rcx
623: 48 f7 d1 not %rcx
626: 31 c0 xor %eax,%eax
628: 49 85 0a test %rcx,(%r10)
62b: 75 3d jne 66a <__bitmap_subset+0x6a>
62d: 41 ff c0 inc %r8d
630: 49 83 c3 08 add $0x8,%r11
634: 49 83 c2 08 add $0x8,%r10
638: 45 39 c8 cmp %r9d,%r8d
63b: 72 e3 jb 620 <__bitmap_subset+0x20>
63d: 45 89 c0 mov %r8d,%r8d
640: f6 c2 3f test $0x3f,%dl
643: 74 20 je 665 <__bitmap_subset+0x65>
645: 4e 8b 0c c6 mov (%rsi,%r8,8),%r9
649: 49 f7 d1 not %r9
64c: f7 da neg %edx
64e: 48 c7 c6 ff ff ff ff mov $0xffffffffffffffff,%rsi
655: 88 d1 mov %dl,%cl
657: 48 d3 ee shr %cl,%rsi
65a: 4a 23 34 c7 and (%rdi,%r8,8),%rsi
65e: 31 c0 xor %eax,%eax
660: 4c 85 ce test %r9,%rsi
663: 75 05 jne 66a <__bitmap_subset+0x6a>
665: b8 01 00 00 00 mov $0x1,%eax
66a: c3 retq
66b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)

0000000000000670 <__bitmap_weight>:
670: 49 89 f8 mov %rdi,%r8
673: 31 d2 xor %edx,%edx
675: 41 89 f1 mov %esi,%r9d
678: 41 c1 e9 06 shr $0x6,%r9d
67c: b8 00 00 00 00 mov $0x0,%eax
681: 74 26 je 6a9 <__bitmap_weight+0x39>
683: 31 d2 xor %edx,%edx
685: 45 89 ca mov %r9d,%r10d
688: 4c 89 c1 mov %r8,%rcx
68b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
690: 48 8b 39 mov (%rcx),%rdi
693: e8 00 00 00 00 callq 698 <__bitmap_weight+0x28> 694: R_X86_64_PC32 __sw_hweight64-0x4
698: 89 d2 mov %edx,%edx
69a: 48 01 c2 add %rax,%rdx
69d: 48 83 c1 08 add $0x8,%rcx
6a1: 41 ff ca dec %r10d
6a4: 75 ea jne 690 <__bitmap_weight+0x20>
6a6: 44 89 c8 mov %r9d,%eax
6a9: 40 f6 c6 3f test $0x3f,%sil
6ad: 74 1c je 6cb <__bitmap_weight+0x5b>
6af: f7 de neg %esi
6b1: 48 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%rdi
6b8: 40 88 f1 mov %sil,%cl
6bb: 48 d3 ef shr %cl,%rdi
6be: 49 23 3c c0 and (%r8,%rax,8),%rdi
6c2: e8 00 00 00 00 callq 6c7 <__bitmap_weight+0x57> 6c3: R_X86_64_PC32 __sw_hweight64-0x4
6c7: 01 d0 add %edx,%eax
6c9: 89 c2 mov %eax,%edx
6cb: 89 d0 mov %edx,%eax
6cd: c3 retq
6ce: 66 90 xchg %ax,%ax

00000000000006d0 <bitmap_set>:
6d0: 53 push %rbx
6d1: 89 f1 mov %esi,%ecx
6d3: 41 89 ca mov %ecx,%r10d
6d6: 41 c1 ea 06 shr $0x6,%r10d
6da: 4a 8d 04 d7 lea (%rdi,%r10,8),%rax
6de: 49 c7 c3 ff ff ff ff mov $0xffffffffffffffff,%r11
6e5: 49 d3 e3 shl %cl,%r11
6e8: 89 cb mov %ecx,%ebx
6ea: 83 cb c0 or $0xffffffc0,%ebx
6ed: 41 89 d8 mov %ebx,%r8d
6f0: 41 01 d0 add %edx,%r8d
6f3: 78 42 js 737 <bitmap_set+0x67>
6f5: 45 89 c1 mov %r8d,%r9d
6f8: 41 c1 e9 06 shr $0x6,%r9d
6fc: 41 8d 71 01 lea 0x1(%r9),%esi
700: 40 f6 c6 03 test $0x3,%sil
704: 74 36 je 73c <bitmap_set+0x6c>
706: 01 d3 add %edx,%ebx
708: c1 eb 06 shr $0x6,%ebx
70b: ff c3 inc %ebx
70d: 83 e3 03 and $0x3,%ebx
710: f7 db neg %ebx
712: 44 89 c6 mov %r8d,%esi
715: 66 66 2e 0f 1f 84 00 00 00 00 00 data32 nopw %cs:0x0(%rax,%rax,1)
720: 4c 09 18 or %r11,(%rax)
723: 48 83 c0 08 add $0x8,%rax
727: 83 c6 c0 add $0xffffffc0,%esi
72a: ff c3 inc %ebx
72c: 49 c7 c3 ff ff ff ff mov $0xffffffffffffffff,%r11
733: 75 eb jne 720 <bitmap_set+0x50>
735: eb 08 jmp 73f <bitmap_set+0x6f>
737: 41 89 d0 mov %edx,%r8d
73a: eb 60 jmp 79c <bitmap_set+0xcc>
73c: 44 89 c6 mov %r8d,%esi
73f: 4b 8d 5c 0a 01 lea 0x1(%r10,%r9,1),%rbx
744: 41 c1 e1 06 shl $0x6,%r9d
748: 41 81 f8 c0 00 00 00 cmp $0xc0,%r8d
74f: 72 3d jb 78e <bitmap_set+0xbe>
751: 66 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
760: 4c 09 18 or %r11,(%rax)
763: 48 c7 40 08 ff ff ff ff movq $0xffffffffffffffff,0x8(%rax)
76b: 48 c7 40 10 ff ff ff ff movq $0xffffffffffffffff,0x10(%rax)
773: 48 c7 40 18 ff ff ff ff movq $0xffffffffffffffff,0x18(%rax)
77b: 48 83 c0 20 add $0x20,%rax
77f: 81 c6 00 ff ff ff add $0xffffff00,%esi
785: 49 c7 c3 ff ff ff ff mov $0xffffffffffffffff,%r11
78c: 79 d2 jns 760 <bitmap_set+0x90>
78e: 48 8d 04 df lea (%rdi,%rbx,8),%rax
792: 45 29 c8 sub %r9d,%r8d
795: 49 c7 c3 ff ff ff ff mov $0xffffffffffffffff,%r11
79c: 45 85 c0 test %r8d,%r8d
79f: 74 14 je 7b5 <bitmap_set+0xe5>
7a1: 01 d1 add %edx,%ecx
7a3: f7 d9 neg %ecx
7a5: 48 c7 c2 ff ff ff ff mov $0xffffffffffffffff,%rdx
7ac: 48 d3 ea shr %cl,%rdx
7af: 49 21 d3 and %rdx,%r11
7b2: 4c 09 18 or %r11,(%rax)
7b5: 5b pop %rbx
7b6: c3 retq
7b7: 66 0f 1f 84 00 00 00 00 00 nopw 0x0(%rax,%rax,1)

00000000000007c0 <bitmap_clear>:
7c0: 41 56 push %r14
7c2: 53 push %rbx
7c3: 89 f1 mov %esi,%ecx
7c5: 41 89 ca mov %ecx,%r10d
7c8: 41 c1 ea 06 shr $0x6,%r10d
7cc: 4a 8d 04 d7 lea (%rdi,%r10,8),%rax
7d0: 49 c7 c3 ff ff ff ff mov $0xffffffffffffffff,%r11
7d7: 49 d3 e3 shl %cl,%r11
7da: 89 cb mov %ecx,%ebx
7dc: 83 cb c0 or $0xffffffc0,%ebx
7df: 41 89 d9 mov %ebx,%r9d
7e2: 41 01 d1 add %edx,%r9d
7e5: 78 3f js 826 <bitmap_clear+0x66>
7e7: 49 f7 d3 not %r11
7ea: 45 89 c8 mov %r9d,%r8d
7ed: 41 c1 e8 06 shr $0x6,%r8d
7f1: 41 8d 70 01 lea 0x1(%r8),%esi
7f5: 40 f6 c6 03 test $0x3,%sil
7f9: 74 30 je 82b <bitmap_clear+0x6b>
7fb: 01 d3 add %edx,%ebx
7fd: c1 eb 06 shr $0x6,%ebx
800: ff c3 inc %ebx
802: 83 e3 03 and $0x3,%ebx
805: f7 db neg %ebx
807: 45 31 f6 xor %r14d,%r14d
80a: 44 89 ce mov %r9d,%esi
80d: 0f 1f 00 nopl (%rax)
810: 4c 21 18 and %r11,(%rax)
813: 48 83 c0 08 add $0x8,%rax
817: 83 c6 c0 add $0xffffffc0,%esi
81a: ff c3 inc %ebx
81c: 41 bb 00 00 00 00 mov $0x0,%r11d
822: 75 ec jne 810 <bitmap_clear+0x50>
824: eb 0b jmp 831 <bitmap_clear+0x71>
826: 41 89 d1 mov %edx,%r9d
829: eb 60 jmp 88b <bitmap_clear+0xcb>
82b: 44 89 ce mov %r9d,%esi
82e: 4d 89 de mov %r11,%r14
831: 4b 8d 5c 02 01 lea 0x1(%r10,%r8,1),%rbx
836: 41 c1 e0 06 shl $0x6,%r8d
83a: 41 81 f9 c0 00 00 00 cmp $0xc0,%r9d
841: 72 3a jb 87d <bitmap_clear+0xbd>
843: 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
850: 4c 21 30 and %r14,(%rax)
853: 48 c7 40 08 00 00 00 00 movq $0x0,0x8(%rax)
85b: 48 c7 40 10 00 00 00 00 movq $0x0,0x10(%rax)
863: 48 c7 40 18 00 00 00 00 movq $0x0,0x18(%rax)
86b: 48 83 c0 20 add $0x20,%rax
86f: 81 c6 00 ff ff ff add $0xffffff00,%esi
875: 41 be 00 00 00 00 mov $0x0,%r14d
87b: 79 d3 jns 850 <bitmap_clear+0x90>
87d: 48 8d 04 df lea (%rdi,%rbx,8),%rax
881: 45 29 c1 sub %r8d,%r9d
884: 49 c7 c3 ff ff ff ff mov $0xffffffffffffffff,%r11
88b: 45 85 c9 test %r9d,%r9d
88e: 74 17 je 8a7 <bitmap_clear+0xe7>
890: 01 d1 add %edx,%ecx
892: f7 d9 neg %ecx
894: 48 c7 c2 ff ff ff ff mov $0xffffffffffffffff,%rdx
89b: 48 d3 ea shr %cl,%rdx
89e: 49 21 d3 and %rdx,%r11
8a1: 49 f7 d3 not %r11
8a4: 4c 21 18 and %r11,(%rax)
8a7: 5b pop %rbx
8a8: 41 5e pop %r14
8aa: c3 retq
8ab: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)

00000000000008b0 <bitmap_find_next_zero_area_off>:
8b0: 55 push %rbp
8b1: 48 89 e5 mov %rsp,%rbp
8b4: 41 57 push %r15
8b6: 41 56 push %r14
8b8: 41 55 push %r13
8ba: 41 54 push %r12
8bc: 53 push %rbx
8bd: 48 83 ec 18 sub $0x18,%rsp
8c1: 4d 89 ce mov %r9,%r14
8c4: 4c 89 75 d0 mov %r14,-0x30(%rbp)
8c8: 4d 89 c7 mov %r8,%r15
8cb: 89 4d c0 mov %ecx,-0x40(%rbp)
8ce: 49 89 f5 mov %rsi,%r13
8d1: 49 89 fc mov %rdi,%r12
8d4: e8 00 00 00 00 callq 8d9 <bitmap_find_next_zero_area_off+0x29> 8d5: R_X86_64_PC32 find_next_zero_bit-0x4
8d9: 4b 8d 0c 3e lea (%r14,%r15,1),%rcx
8dd: 48 89 4d c8 mov %rcx,-0x38(%rbp)
8e1: 48 8d 1c 08 lea (%rax,%rcx,1),%rbx
8e5: 49 f7 d7 not %r15
8e8: 4c 21 fb and %r15,%rbx
8eb: 4c 29 f3 sub %r14,%rbx
8ee: 8b 45 c0 mov -0x40(%rbp),%eax
8f1: 48 89 45 c0 mov %rax,-0x40(%rbp)
8f5: eb 2d jmp 924 <bitmap_find_next_zero_area_off+0x74>
8f7: 66 0f 1f 84 00 00 00 00 00 nopw 0x0(%rax,%rax,1)
900: 48 ff c0 inc %rax
903: 4c 89 e7 mov %r12,%rdi
906: 4c 89 ee mov %r13,%rsi
909: 48 89 c2 mov %rax,%rdx
90c: e8 00 00 00 00 callq 911 <bitmap_find_next_zero_area_off+0x61> 90d: R_X86_64_PC32 find_next_zero_bit-0x4
911: 48 8b 4d c8 mov -0x38(%rbp),%rcx
915: 48 8d 1c 08 lea (%rax,%rcx,1),%rbx
919: 4c 21 fb and %r15,%rbx
91c: 48 2b 5d d0 sub -0x30(%rbp),%rbx
920: 48 8b 45 c0 mov -0x40(%rbp),%rax
924: 4c 8d 34 03 lea (%rbx,%rax,1),%r14
928: 4d 39 ee cmp %r13,%r14
92b: 77 16 ja 943 <bitmap_find_next_zero_area_off+0x93>
92d: 4c 89 e7 mov %r12,%rdi
930: 4c 89 f6 mov %r14,%rsi
933: 48 89 da mov %rbx,%rdx
936: e8 00 00 00 00 callq 93b <bitmap_find_next_zero_area_off+0x8b> 937: R_X86_64_PC32 find_next_bit-0x4
93b: 4c 39 f0 cmp %r14,%rax
93e: 49 89 de mov %rbx,%r14
941: 72 bd jb 900 <bitmap_find_next_zero_area_off+0x50>
943: 4c 89 f0 mov %r14,%rax
946: 48 83 c4 18 add $0x18,%rsp
94a: 5b pop %rbx
94b: 41 5c pop %r12
94d: 41 5d pop %r13
94f: 41 5e pop %r14
951: 41 5f pop %r15
953: 5d pop %rbp
954: c3 retq
955: 66 66 2e 0f 1f 84 00 00 00 00 00 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000000960 <__bitmap_parse>:
960: 55 push %rbp
961: 48 89 e5 mov %rsp,%rbp
964: 41 57 push %r15
966: 41 56 push %r14
968: 41 55 push %r13
96a: 41 54 push %r12
96c: 53 push %rbx
96d: 48 83 ec 48 sub $0x48,%rsp
971: 44 89 45 bc mov %r8d,-0x44(%rbp)
975: 49 89 cf mov %rcx,%r15
978: 89 55 d0 mov %edx,-0x30(%rbp)
97b: 41 89 f4 mov %esi,%r12d
97e: 49 89 fd mov %rdi,%r13
981: 44 89 c3 mov %r8d,%ebx
984: 48 83 c3 3f add $0x3f,%rbx
988: 48 c1 eb 06 shr $0x6,%rbx
98c: 48 8d 14 dd 00 00 00 00 lea 0x0(,%rbx,8),%rdx
994: 45 31 f6 xor %r14d,%r14d
997: 31 f6 xor %esi,%esi
999: 4c 89 ff mov %r15,%rdi
99c: e8 00 00 00 00 callq 9a1 <__bitmap_parse+0x41> 99d: R_X86_64_PC32 memset-0x4
9a1: 49 89 d9 mov %rbx,%r9
9a4: 4d 89 f8 mov %r15,%r8
9a7: 4d 89 ca mov %r9,%r10
9aa: 49 ff ca dec %r10
9ad: 41 8d 41 fe lea -0x2(%r9),%eax
9b1: 48 98 cltq
9b3: 49 8d 04 c0 lea (%r8,%rax,8),%rax
9b7: 48 89 45 b0 mov %rax,-0x50(%rbp)
9bb: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%rbp)
9c2: 31 ff xor %edi,%edi
9c4: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%rbp)
9cb: 4d 89 ef mov %r13,%r15
9ce: 89 7d c8 mov %edi,-0x38(%rbp)
9d1: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%rbp)
9d8: 45 31 db xor %r11d,%r11d
9db: 44 89 e3 mov %r12d,%ebx
9de: eb 40 jmp a20 <__bitmap_parse+0xc0>
9e0: 45 89 dc mov %r11d,%r12d
9e3: 41 c1 e4 04 shl $0x4,%r12d
9e7: 44 89 f7 mov %r14d,%edi
9ea: 4c 89 45 a8 mov %r8,-0x58(%rbp)
9ee: 4c 89 4d 98 mov %r9,-0x68(%rbp)
9f2: 4c 89 55 a0 mov %r10,-0x60(%rbp)
9f6: e8 00 00 00 00 callq 9fb <__bitmap_parse+0x9b> 9f7: R_X86_64_PC32 hex_to_bin-0x4
9fb: 8b 7d c8 mov -0x38(%rbp),%edi
9fe: 4c 8b 55 a0 mov -0x60(%rbp),%r10
a02: 4c 8b 4d 98 mov -0x68(%rbp),%r9
a06: 4c 8b 45 a8 mov -0x58(%rbp),%r8
a0a: 41 09 c4 or %eax,%r12d
a0d: 45 89 e3 mov %r12d,%r11d
a10: ff 45 cc incl -0x34(%rbp)
a13: ff 45 c0 incl -0x40(%rbp)
a16: 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:0x0(%rax,%rax,1)
a20: 44 89 f6 mov %r14d,%esi
a23: 45 31 e4 xor %r12d,%r12d
a26: 85 db test %ebx,%ebx
a28: 0f 84 a8 00 00 00 je ad6 <__bitmap_parse+0x176>
a2e: 83 7d d0 00 cmpl $0x0,-0x30(%rbp)
a32: 74 2c je a60 <__bitmap_parse+0x100>
a34: 31 c9 xor %ecx,%ecx
a36: 90 nop
a37: 90 nop
a38: 90 nop
a39: 41 8a 55 00 mov 0x0(%r13),%dl
a3d: 90 nop
a3e: 90 nop
a3f: 90 nop
a40: b8 f2 ff ff ff mov $0xfffffff2,%eax
a45: 85 c9 test %ecx,%ecx
a47: 0f 85 26 01 00 00 jne b73 <__bitmap_parse+0x213>
a4d: 49 ff c5 inc %r13
a50: eb 14 jmp a66 <__bitmap_parse+0x106>
a52: 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
a60: 41 8a 17 mov (%r15),%dl
a63: 49 ff c7 inc %r15
a66: 44 0f be f2 movsbl %dl,%r14d
a6a: ff cb dec %ebx
a6c: 41 0f b6 c6 movzbl %r14b,%eax
a70: 8a 88 00 00 00 00 mov 0x0(%rax),%cl a72: R_X86_64_32S _ctype
a76: f6 c1 20 test $0x20,%cl
a79: 75 a5 jne a20 <__bitmap_parse+0xc0>
a7b: 83 7d c0 00 cmpl $0x0,-0x40(%rbp)
a7f: 74 1a je a9b <__bitmap_parse+0x13b>
a81: 84 d2 test %dl,%dl
a83: 74 16 je a9b <__bitmap_parse+0x13b>
a85: 40 0f b6 f6 movzbl %sil,%esi
a89: b8 ea ff ff ff mov $0xffffffea,%eax
a8e: f6 86 00 00 00 00 20 testb $0x20,0x0(%rsi) a90: R_X86_64_32S _ctype
a95: 0f 85 d8 00 00 00 jne b73 <__bitmap_parse+0x213>
a9b: 84 d2 test %dl,%dl
a9d: 74 31 je ad0 <__bitmap_parse+0x170>
a9f: 0f b6 c2 movzbl %dl,%eax
aa2: 83 f8 2c cmp $0x2c,%eax
aa5: 74 29 je ad0 <__bitmap_parse+0x170>
aa7: b8 ea ff ff ff mov $0xffffffea,%eax
aac: f6 c1 44 test $0x44,%cl
aaf: 0f 84 be 00 00 00 je b73 <__bitmap_parse+0x213>
ab5: b8 b5 ff ff ff mov $0xffffffb5,%eax
aba: 41 81 fb ff ff ff 0f cmp $0xfffffff,%r11d
ac1: 0f 86 19 ff ff ff jbe 9e0 <__bitmap_parse+0x80>
ac7: e9 a7 00 00 00 jmpq b73 <__bitmap_parse+0x213>
acc: 0f 1f 40 00 nopl 0x0(%rax)
ad0: 44 89 f6 mov %r14d,%esi
ad3: 41 89 dc mov %ebx,%r12d
ad6: 8b 4d cc mov -0x34(%rbp),%ecx
ad9: b8 ea ff ff ff mov $0xffffffea,%eax
ade: 85 c9 test %ecx,%ecx
ae0: 0f 84 8d 00 00 00 je b73 <__bitmap_parse+0x213>
ae6: 44 89 d8 mov %r11d,%eax
ae9: 09 f8 or %edi,%eax
aeb: 74 70 je b5d <__bitmap_parse+0x1fd>
aed: 89 fb mov %edi,%ebx
aef: 45 85 c9 test %r9d,%r9d
af2: 48 8b 45 b0 mov -0x50(%rbp),%rax
af6: 4c 89 d1 mov %r10,%rcx
af9: 74 2e je b29 <__bitmap_parse+0x1c9>
afb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
b00: 48 85 c9 test %rcx,%rcx
b03: ba 00 00 00 00 mov $0x0,%edx
b08: 7e 03 jle b0d <__bitmap_parse+0x1ad>
b0a: 8b 50 04 mov 0x4(%rax),%edx
b0d: 49 8b 3c c8 mov (%r8,%rcx,8),%rdi
b11: 48 c1 e7 20 shl $0x20,%rdi
b15: 48 09 d7 or %rdx,%rdi
b18: 89 ca mov %ecx,%edx
b1a: 49 89 3c d0 mov %rdi,(%r8,%rdx,8)
b1e: 48 ff c9 dec %rcx
b21: 48 83 c0 f8 add $0xfffffffffffffff8,%rax
b25: 85 c9 test %ecx,%ecx
b27: 79 d7 jns b00 <__bitmap_parse+0x1a0>
b29: 44 89 d8 mov %r11d,%eax
b2c: 49 09 00 or %rax,(%r8)
b2f: b8 20 00 00 00 mov $0x20,%eax
b34: 89 df mov %ebx,%edi
b36: 85 ff test %edi,%edi
b38: 75 0f jne b49 <__bitmap_parse+0x1e9>
b3a: 44 89 5d d4 mov %r11d,-0x2c(%rbp)
b3e: b8 ff ff ff ff mov $0xffffffff,%eax
b43: 0f bd 45 d4 bsr -0x2c(%rbp),%eax
b47: ff c0 inc %eax
b49: 8b 4d c4 mov -0x3c(%rbp),%ecx
b4c: 01 c1 add %eax,%ecx
b4e: 89 4d c4 mov %ecx,-0x3c(%rbp)
b51: b8 b5 ff ff ff mov $0xffffffb5,%eax
b56: 3b 4d bc cmp -0x44(%rbp),%ecx
b59: 7f 18 jg b73 <__bitmap_parse+0x213>
b5b: ff c7 inc %edi
b5d: 31 c0 xor %eax,%eax
b5f: 83 fe 2c cmp $0x2c,%esi
b62: 75 0f jne b73 <__bitmap_parse+0x213>
b64: 41 be 2c 00 00 00 mov $0x2c,%r14d
b6a: 45 85 e4 test %r12d,%r12d
b6d: 0f 85 5b fe ff ff jne 9ce <__bitmap_parse+0x6e>
b73: 48 83 c4 48 add $0x48,%rsp
b77: 5b pop %rbx
b78: 41 5c pop %r12
b7a: 41 5d pop %r13
b7c: 41 5e pop %r14
b7e: 41 5f pop %r15
b80: 5d pop %rbp
b81: c3 retq
b82: 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000000b90 <bitmap_parse_user>:
b90: 55 push %rbp
b91: 48 89 e5 mov %rsp,%rbp
b94: 41 89 c8 mov %ecx,%r8d
b97: 49 89 d1 mov %rdx,%r9
b9a: 89 f2 mov %esi,%edx
b9c: 65 48 8b 0c 25 00 00 00 00 mov %gs:0x0,%rcx ba1: R_X86_64_32S cpu_tss+0x4
ba5: b8 f2 ff ff ff mov $0xfffffff2,%eax
baa: 48 01 fa add %rdi,%rdx
bad: 72 16 jb bc5 <bitmap_parse_user+0x35>
baf: 48 3b 91 18 c0 ff ff cmp -0x3fe8(%rcx),%rdx
bb6: 77 0d ja bc5 <bitmap_parse_user+0x35>
bb8: ba 01 00 00 00 mov $0x1,%edx
bbd: 4c 89 c9 mov %r9,%rcx
bc0: e8 00 00 00 00 callq bc5 <bitmap_parse_user+0x35> bc1: R_X86_64_PC32 __bitmap_parse-0x4
bc5: 5d pop %rbp
bc6: c3 retq
bc7: 66 0f 1f 84 00 00 00 00 00 nopw 0x0(%rax,%rax,1)

0000000000000bd0 <bitmap_print_to_pagebuf>:
bd0: 55 push %rbp
bd1: 48 89 e5 mov %rsp,%rbp
bd4: 49 89 d0 mov %rdx,%r8
bd7: 4c 8d 8e fe 1f 00 00 lea 0x1ffe(%rsi),%r9
bde: 49 81 e1 00 f0 ff ff and $0xfffffffffffff000,%r9
be5: 49 29 f1 sub %rsi,%r9
be8: 31 c0 xor %eax,%eax
bea: 49 83 f9 02 cmp $0x2,%r9
bee: 7c 22 jl c12 <bitmap_print_to_pagebuf+0x42>
bf0: 40 84 ff test %dil,%dil
bf3: 74 09 je bfe <bitmap_print_to_pagebuf+0x2e>
bf5: 48 c7 c2 00 00 00 00 mov $0x0,%rdx bf8: R_X86_64_32S .rodata.str1.1
bfc: eb 07 jmp c05 <bitmap_print_to_pagebuf+0x35>
bfe: 48 c7 c2 00 00 00 00 mov $0x0,%rdx c01: R_X86_64_32S .rodata.str1.1+0x7
c05: 31 c0 xor %eax,%eax
c07: 48 89 f7 mov %rsi,%rdi
c0a: 4c 89 ce mov %r9,%rsi
c0d: e8 00 00 00 00 callq c12 <bitmap_print_to_pagebuf+0x42> c0e: R_X86_64_PC32 scnprintf-0x4
c12: 5d pop %rbp
c13: c3 retq
c14: 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000000c20 <bitmap_parselist>:
c20: 55 push %rbp
c21: 48 89 e5 mov %rsp,%rbp
c24: 41 57 push %r15
c26: 41 56 push %r14
c28: 53 push %rbx
c29: 50 push %rax
c2a: 41 89 d6 mov %edx,%r14d
c2d: 49 89 f7 mov %rsi,%r15
c30: 48 89 fb mov %rdi,%rbx
c33: be 0a 00 00 00 mov $0xa,%esi
c38: e8 00 00 00 00 callq c3d <bitmap_parselist+0x1d> c39: R_X86_64_PC32 strchrnul-0x4
c3d: 29 d8 sub %ebx,%eax
c3f: 31 d2 xor %edx,%edx
c41: 48 89 df mov %rbx,%rdi
c44: 89 c6 mov %eax,%esi
c46: 4c 89 f9 mov %r15,%rcx
c49: 45 89 f0 mov %r14d,%r8d
c4c: e8 0f 00 00 00 callq c60 <__bitmap_parselist>
c51: 48 83 c4 08 add $0x8,%rsp
c55: 5b pop %rbx
c56: 41 5e pop %r14
c58: 41 5f pop %r15
c5a: 5d pop %rbp
c5b: c3 retq
c5c: 0f 1f 40 00 nopl 0x0(%rax)

0000000000000c60 <__bitmap_parselist>:
c60: 55 push %rbp
c61: 48 89 e5 mov %rsp,%rbp
c64: 41 57 push %r15
c66: 41 56 push %r14
c68: 41 55 push %r13
c6a: 41 54 push %r12
c6c: 53 push %rbx
c6d: 48 83 ec 18 sub $0x18,%rsp
c71: 44 89 45 d0 mov %r8d,-0x30(%rbp)
c75: 49 89 cf mov %rcx,%r15
c78: 41 89 d4 mov %edx,%r12d
c7b: 89 f3 mov %esi,%ebx
c7d: 49 89 fd mov %rdi,%r13
c80: 44 89 c2 mov %r8d,%edx
c83: 48 83 c2 3f add $0x3f,%rdx
c87: 48 c1 ea 03 shr $0x3,%rdx
c8b: 81 e2 f8 ff ff 3f and $0x3ffffff8,%edx
c91: 45 31 f6 xor %r14d,%r14d
c94: 31 f6 xor %esi,%esi
c96: 4c 89 ff mov %r15,%rdi
c99: e8 00 00 00 00 callq c9e <__bitmap_parselist+0x3e> c9a: R_X86_64_PC32 memset-0x4
c9e: c7 45 d4 01 00 00 00 movl $0x1,-0x2c(%rbp)
ca5: 31 f6 xor %esi,%esi
ca7: 31 d2 xor %edx,%edx
ca9: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%rbp)
cb0: 45 31 d2 xor %r10d,%r10d
cb3: 4c 89 e9 mov %r13,%rcx
cb6: eb 28 jmp ce0 <__bitmap_parselist+0x80>
cb8: 43 8d 04 9b lea (%r11,%r11,4),%eax
cbc: 44 8d 74 46 d0 lea -0x30(%rsi,%rax,2),%r14d
cc1: 45 85 d2 test %r10d,%r10d
cc4: 41 0f 44 d6 cmove %r14d,%edx
cc8: ff 45 cc incl -0x34(%rbp)
ccb: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%rbp)
cd2: 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)
ce0: 89 d8 mov %ebx,%eax
ce2: 45 89 f3 mov %r14d,%r11d
ce5: 89 c3 mov %eax,%ebx
ce7: 66 0f 1f 84 00 00 00 00 00 nopw 0x0(%rax,%rax,1)
cf0: 89 f7 mov %esi,%edi
cf2: 31 c0 xor %eax,%eax
cf4: 85 db test %ebx,%ebx
cf6: 0f 84 94 00 00 00 je d90 <__bitmap_parselist+0x130>
cfc: 45 85 e4 test %r12d,%r12d
cff: 74 1f je d20 <__bitmap_parselist+0xc0>
d01: 31 f6 xor %esi,%esi
d03: 90 nop
d04: 90 nop
d05: 90 nop
d06: 41 8a 45 00 mov 0x0(%r13),%al
d0a: 90 nop
d0b: 90 nop
d0c: 90 nop
d0d: 41 be f2 ff ff ff mov $0xfffffff2,%r14d
d13: 85 f6 test %esi,%esi
d15: 0f 85 dc 00 00 00 jne df7 <__bitmap_parselist+0x197>
d1b: 49 ff c5 inc %r13
d1e: eb 05 jmp d25 <__bitmap_parselist+0xc5>
d20: 8a 01 mov (%rcx),%al
d22: 48 ff c1 inc %rcx
d25: 0f be f0 movsbl %al,%esi
d28: ff cb dec %ebx
d2a: 44 0f b6 ce movzbl %sil,%r9d
d2e: 45 8a 81 00 00 00 00 mov 0x0(%r9),%r8b d31: R_X86_64_32S _ctype
d35: 41 f6 c0 20 test $0x20,%r8b
d39: 75 b5 jne cf0 <__bitmap_parselist+0x90>
d3b: 83 7d cc 00 cmpl $0x0,-0x34(%rbp)
d3f: 74 1b je d5c <__bitmap_parselist+0xfc>
d41: 84 c0 test %al,%al
d43: 74 17 je d5c <__bitmap_parselist+0xfc>
d45: 40 0f b6 ff movzbl %dil,%edi
d49: 41 be ea ff ff ff mov $0xffffffea,%r14d
d4f: f6 87 00 00 00 00 20 testb $0x20,0x0(%rdi) d51: R_X86_64_32S _ctype
d56: 0f 85 9b 00 00 00 jne df7 <__bitmap_parselist+0x197>
d5c: 41 83 f9 2d cmp $0x2d,%r9d
d60: 75 1b jne d7d <__bitmap_parselist+0x11d>
d62: 41 be ea ff ff ff mov $0xffffffea,%r14d
d68: 45 31 db xor %r11d,%r11d
d6b: 44 0b 55 d4 or -0x2c(%rbp),%r10d
d6f: 41 ba 01 00 00 00 mov $0x1,%r10d
d75: 0f 84 75 ff ff ff je cf0 <__bitmap_parselist+0x90>
d7b: eb 7a jmp df7 <__bitmap_parselist+0x197>
d7d: 84 c0 test %al,%al
d7f: 74 08 je d89 <__bitmap_parselist+0x129>
d81: 0f b6 c0 movzbl %al,%eax
d84: 83 f8 2c cmp $0x2c,%eax
d87: 75 5e jne de7 <__bitmap_parselist+0x187>
d89: 89 f7 mov %esi,%edi
d8b: 89 d8 mov %ebx,%eax
d8d: 0f 1f 00 nopl (%rax)
d90: 41 be ea ff ff ff mov $0xffffffea,%r14d
d96: 44 39 da cmp %r11d,%edx
d99: 77 5c ja df7 <__bitmap_parselist+0x197>
d9b: 41 be de ff ff ff mov $0xffffffde,%r14d
da1: 44 3b 5d d0 cmp -0x30(%rbp),%r11d
da5: 73 50 jae df7 <__bitmap_parselist+0x197>
da7: 83 7d d4 00 cmpl $0x0,-0x2c(%rbp)
dab: 75 11 jne dbe <__bitmap_parselist+0x15e>
dad: 0f 1f 00 nopl (%rax)
db0: 89 d6 mov %edx,%esi
db2: f0 49 0f ab 37 lock bts %rsi,(%r15)
db7: ff c2 inc %edx
db9: 44 39 da cmp %r11d,%edx
dbc: 76 f2 jbe db0 <__bitmap_parselist+0x150>
dbe: 45 31 f6 xor %r14d,%r14d
dc1: 83 ff 2c cmp $0x2c,%edi
dc4: 75 31 jne df7 <__bitmap_parselist+0x197>
dc6: c7 45 d4 01 00 00 00 movl $0x1,-0x2c(%rbp)
dcd: be 2c 00 00 00 mov $0x2c,%esi
dd2: 85 c0 test %eax,%eax
dd4: ba 00 00 00 00 mov $0x0,%edx
dd9: 41 ba 00 00 00 00 mov $0x0,%r10d
ddf: 0f 85 fd fe ff ff jne ce2 <__bitmap_parselist+0x82>
de5: eb 10 jmp df7 <__bitmap_parselist+0x197>
de7: 41 be ea ff ff ff mov $0xffffffea,%r14d
ded: 41 f6 c0 04 test $0x4,%r8b
df1: 0f 85 c1 fe ff ff jne cb8 <__bitmap_parselist+0x58>
df7: 44 89 f0 mov %r14d,%eax
dfa: 48 83 c4 18 add $0x18,%rsp
dfe: 5b pop %rbx
dff: 41 5c pop %r12
e01: 41 5d pop %r13
e03: 41 5e pop %r14
e05: 41 5f pop %r15
e07: 5d pop %rbp
e08: c3 retq
e09: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)

0000000000000e10 <bitmap_parselist_user>:
e10: 55 push %rbp
e11: 48 89 e5 mov %rsp,%rbp
e14: 41 89 c8 mov %ecx,%r8d
e17: 49 89 d1 mov %rdx,%r9
e1a: 89 f2 mov %esi,%edx
e1c: 65 48 8b 0c 25 00 00 00 00 mov %gs:0x0,%rcx e21: R_X86_64_32S cpu_tss+0x4
e25: b8 f2 ff ff ff mov $0xfffffff2,%eax
e2a: 48 01 fa add %rdi,%rdx
e2d: 72 16 jb e45 <bitmap_parselist_user+0x35>
e2f: 48 3b 91 18 c0 ff ff cmp -0x3fe8(%rcx),%rdx
e36: 77 0d ja e45 <bitmap_parselist_user+0x35>
e38: ba 01 00 00 00 mov $0x1,%edx
e3d: 4c 89 c9 mov %r9,%rcx
e40: e8 1b fe ff ff callq c60 <__bitmap_parselist>
e45: 5d pop %rbp
e46: c3 retq
e47: 66 0f 1f 84 00 00 00 00 00 nopw 0x0(%rax,%rax,1)

0000000000000e50 <bitmap_ord_to_pos>:
e50: 55 push %rbp
e51: 48 89 e5 mov %rsp,%rbp
e54: 41 57 push %r15
e56: 41 56 push %r14
e58: 41 55 push %r13
e5a: 41 54 push %r12
e5c: 53 push %rbx
e5d: 50 push %rax
e5e: 41 89 d7 mov %edx,%r15d
e61: 41 89 f4 mov %esi,%r12d
e64: 49 89 fe mov %rdi,%r14
e67: 45 89 fd mov %r15d,%r13d
e6a: 4c 89 ee mov %r13,%rsi
e6d: e8 00 00 00 00 callq e72 <bitmap_ord_to_pos+0x22> e6e: R_X86_64_PC32 find_first_bit-0x4
e72: 45 85 e4 test %r12d,%r12d
e75: 74 34 je eab <bitmap_ord_to_pos+0x5b>
e77: 44 39 f8 cmp %r15d,%eax
e7a: 73 2f jae eab <bitmap_ord_to_pos+0x5b>
e7c: bb 01 00 00 00 mov $0x1,%ebx
e81: 44 29 e3 sub %r12d,%ebx
e84: 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 nopw %cs:0x0(%rax,%rax,1)
e90: ff c0 inc %eax
e92: 4c 89 f7 mov %r14,%rdi
e95: 4c 89 ee mov %r13,%rsi
e98: 48 89 c2 mov %rax,%rdx
e9b: e8 00 00 00 00 callq ea0 <bitmap_ord_to_pos+0x50> e9c: R_X86_64_PC32 find_next_bit-0x4
ea0: 85 db test %ebx,%ebx
ea2: 74 07 je eab <bitmap_ord_to_pos+0x5b>
ea4: ff c3 inc %ebx
ea6: 44 39 f8 cmp %r15d,%eax
ea9: 72 e5 jb e90 <bitmap_ord_to_pos+0x40>
eab: 48 83 c4 08 add $0x8,%rsp
eaf: 5b pop %rbx
eb0: 41 5c pop %r12
eb2: 41 5d pop %r13
eb4: 41 5e pop %r14
eb6: 41 5f pop %r15
eb8: 5d pop %rbp
eb9: c3 retq
eba: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1)

0000000000000ec0 <bitmap_remap>:
ec0: 55 push %rbp
ec1: 48 89 e5 mov %rsp,%rbp
ec4: 41 57 push %r15
ec6: 41 56 push %r14
ec8: 41 55 push %r13
eca: 41 54 push %r12
ecc: 53 push %rbx
ecd: 48 83 ec 28 sub $0x28,%rsp
ed1: 45 89 c4 mov %r8d,%r12d
ed4: 48 89 4d c8 mov %rcx,-0x38(%rbp)
ed8: 48 89 d3 mov %rdx,%rbx
edb: 48 89 5d b0 mov %rbx,-0x50(%rbp)
edf: 48 89 75 c0 mov %rsi,-0x40(%rbp)
ee3: 48 89 7d b8 mov %rdi,-0x48(%rbp)
ee7: 48 39 f7 cmp %rsi,%rdi
eea: 0f 84 9e 01 00 00 je 108e <bitmap_remap+0x1ce>
ef0: 41 be ff ff ff ff mov $0xffffffff,%r14d
ef6: 44 89 e0 mov %r12d,%eax
ef9: 48 89 45 d0 mov %rax,-0x30(%rbp)
efd: 48 8d 50 3f lea 0x3f(%rax),%rdx
f01: 48 c1 ea 03 shr $0x3,%rdx
f05: 81 e2 f8 ff ff 3f and $0x3ffffff8,%edx
f0b: 45 31 ff xor %r15d,%r15d
f0e: 31 f6 xor %esi,%esi
f10: 48 8b 7d b8 mov -0x48(%rbp),%rdi
f14: e8 00 00 00 00 callq f19 <bitmap_remap+0x59> f15: R_X86_64_PC32 memset-0x4
f19: 44 89 e1 mov %r12d,%ecx
f1c: c1 e9 06 shr $0x6,%ecx
f1f: b8 00 00 00 00 mov $0x0,%eax
f24: 74 22 je f48 <bitmap_remap+0x88>
f26: 45 31 ff xor %r15d,%r15d
f29: 48 8b 55 c8 mov -0x38(%rbp),%rdx
f2d: 89 ce mov %ecx,%esi
f2f: 90 nop
f30: 48 8b 3a mov (%rdx),%rdi
f33: e8 00 00 00 00 callq f38 <bitmap_remap+0x78> f34: R_X86_64_PC32 __sw_hweight64-0x4
f38: 4d 21 f7 and %r14,%r15
f3b: 49 01 c7 add %rax,%r15
f3e: 48 83 c2 08 add $0x8,%rdx
f42: ff ce dec %esi
f44: 75 ea jne f30 <bitmap_remap+0x70>
f46: 89 c8 mov %ecx,%eax
f48: 41 f6 c4 3f test $0x3f,%r12b
f4c: 74 22 je f70 <bitmap_remap+0xb0>
f4e: 44 89 e1 mov %r12d,%ecx
f51: f7 d9 neg %ecx
f53: 48 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%rdi
f5a: 48 d3 ef shr %cl,%rdi
f5d: 48 8b 4d c8 mov -0x38(%rbp),%rcx
f61: 48 23 3c c1 and (%rcx,%rax,8),%rdi
f65: e8 00 00 00 00 callq f6a <bitmap_remap+0xaa> f66: R_X86_64_PC32 __sw_hweight64-0x4
f6a: 44 01 f8 add %r15d,%eax
f6d: 41 89 c7 mov %eax,%r15d
f70: 48 8b 7d c0 mov -0x40(%rbp),%rdi
f74: 48 8b 75 d0 mov -0x30(%rbp),%rsi
f78: e8 00 00 00 00 callq f7d <bitmap_remap+0xbd> f79: R_X86_64_PC32 find_first_bit-0x4
f7d: eb 17 jmp f96 <bitmap_remap+0xd6>
f7f: 90 nop
f80: 41 ff c5 inc %r13d
f83: 4d 21 f5 and %r14,%r13
f86: 48 8b 7d c0 mov -0x40(%rbp),%rdi
f8a: 48 8b 75 d0 mov -0x30(%rbp),%rsi
f8e: 4c 89 ea mov %r13,%rdx
f91: e8 00 00 00 00 callq f96 <bitmap_remap+0xd6> f92: R_X86_64_PC32 find_next_bit-0x4
f96: 49 89 c5 mov %rax,%r13
f99: 45 39 e5 cmp %r12d,%r13d
f9c: 0f 83 ec 00 00 00 jae 108e <bitmap_remap+0x1ce>
fa2: 4d 89 e8 mov %r13,%r8
fa5: 4d 21 f0 and %r14,%r8
fa8: 4c 0f a3 03 bt %r8,(%rbx)
fac: 19 c0 sbb %eax,%eax
fae: 85 c0 test %eax,%eax
fb0: 0f 84 ca 00 00 00 je 1080 <bitmap_remap+0x1c0>
fb6: 31 f6 xor %esi,%esi
fb8: 44 89 ea mov %r13d,%edx
fbb: c1 ea 06 shr $0x6,%edx
fbe: b8 00 00 00 00 mov $0x0,%eax
fc3: 74 26 je feb <bitmap_remap+0x12b>
fc5: 48 89 d8 mov %rbx,%rax
fc8: 49 89 c2 mov %rax,%r10
fcb: 89 d1 mov %edx,%ecx
fcd: 31 f6 xor %esi,%esi
fcf: 90 nop
fd0: 48 8b 3b mov (%rbx),%rdi
fd3: e8 00 00 00 00 callq fd8 <bitmap_remap+0x118> fd4: R_X86_64_PC32 __sw_hweight64-0x4
fd8: 4c 21 f6 and %r14,%rsi
fdb: 48 01 c6 add %rax,%rsi
fde: 48 83 c3 08 add $0x8,%rbx
fe2: ff c9 dec %ecx
fe4: 75 ea jne fd0 <bitmap_remap+0x110>
fe6: 89 d0 mov %edx,%eax
fe8: 4c 89 d3 mov %r10,%rbx
feb: 41 f6 c5 3f test $0x3f,%r13b
fef: 74 1c je 100d <bitmap_remap+0x14d>
ff1: 44 89 e9 mov %r13d,%ecx
ff4: f7 d9 neg %ecx
ff6: 48 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%rdi
ffd: 48 d3 ef shr %cl,%rdi
1000: 48 23 3c c3 and (%rbx,%rax,8),%rdi
1004: e8 00 00 00 00 callq 1009 <bitmap_remap+0x149> 1005: R_X86_64_PC32 __sw_hweight64-0x4
1009: 01 f0 add %esi,%eax
100b: 89 c6 mov %eax,%esi
100d: 45 85 ff test %r15d,%r15d
1010: 74 6e je 1080 <bitmap_remap+0x1c0>
1012: 85 f6 test %esi,%esi
1014: 78 6a js 1080 <bitmap_remap+0x1c0>
1016: 31 d2 xor %edx,%edx
1018: 89 f0 mov %esi,%eax
101a: 41 f7 f7 div %r15d
101d: 89 d3 mov %edx,%ebx
101f: 48 8b 7d c8 mov -0x38(%rbp),%rdi
1023: 48 8b 75 d0 mov -0x30(%rbp),%rsi
1027: e8 00 00 00 00 callq 102c <bitmap_remap+0x16c> 1028: R_X86_64_PC32 find_first_bit-0x4
102c: 89 d9 mov %ebx,%ecx
102e: 85 c9 test %ecx,%ecx
1030: 74 2e je 1060 <bitmap_remap+0x1a0>
1032: 44 39 e0 cmp %r12d,%eax
1035: 73 29 jae 1060 <bitmap_remap+0x1a0>
1037: bb 01 00 00 00 mov $0x1,%ebx
103c: 29 cb sub %ecx,%ebx
103e: 66 90 xchg %ax,%ax
1040: ff c0 inc %eax
1042: 4c 21 f0 and %r14,%rax
1045: 48 8b 7d c8 mov -0x38(%rbp),%rdi
1049: 48 8b 75 d0 mov -0x30(%rbp),%rsi
104d: 48 89 c2 mov %rax,%rdx
1050: e8 00 00 00 00 callq 1055 <bitmap_remap+0x195> 1051: R_X86_64_PC32 find_next_bit-0x4
1055: 85 db test %ebx,%ebx
1057: 74 07 je 1060 <bitmap_remap+0x1a0>
1059: ff c3 inc %ebx
105b: 44 39 e0 cmp %r12d,%eax
105e: 72 e0 jb 1040 <bitmap_remap+0x180>
1060: 4c 21 f0 and %r14,%rax
1063: 48 8b 4d b8 mov -0x48(%rbp),%rcx
1067: f0 48 0f ab 01 lock bts %rax,(%rcx)
106c: 48 8b 5d b0 mov -0x50(%rbp),%rbx
1070: e9 0b ff ff ff jmpq f80 <bitmap_remap+0xc0>
1075: 66 66 2e 0f 1f 84 00 00 00 00 00 data32 nopw %cs:0x0(%rax,%rax,1)
1080: 48 8b 45 b8 mov -0x48(%rbp),%rax
1084: f0 4c 0f ab 00 lock bts %r8,(%rax)
1089: e9 f2 fe ff ff jmpq f80 <bitmap_remap+0xc0>
108e: 48 83 c4 28 add $0x28,%rsp
1092: 5b pop %rbx
1093: 41 5c pop %r12
1095: 41 5d pop %r13
1097: 41 5e pop %r14
1099: 41 5f pop %r15
109b: 5d pop %rbp
109c: c3 retq
109d: 0f 1f 00 nopl (%rax)

00000000000010a0 <bitmap_bitremap>:
10a0: 55 push %rbp
10a1: 48 89 e5 mov %rsp,%rbp
10a4: 41 57 push %r15
10a6: 41 56 push %r14
10a8: 41 55 push %r13
10aa: 41 54 push %r12
10ac: 53 push %rbx
10ad: 50 push %rax
10ae: 41 89 cf mov %ecx,%r15d
10b1: 49 89 d6 mov %rdx,%r14
10b4: 41 89 f8 mov %edi,%r8d
10b7: 41 bd ff ff ff ff mov $0xffffffff,%r13d
10bd: 31 db xor %ebx,%ebx
10bf: 45 89 f9 mov %r15d,%r9d
10c2: 41 c1 e9 06 shr $0x6,%r9d
10c6: b8 00 00 00 00 mov $0x0,%eax
10cb: 74 2c je 10f9 <bitmap_bitremap+0x59>
10cd: 31 db xor %ebx,%ebx
10cf: 4c 89 f2 mov %r14,%rdx
10d2: 44 89 c9 mov %r9d,%ecx
10d5: 66 66 2e 0f 1f 84 00 00 00 00 00 data32 nopw %cs:0x0(%rax,%rax,1)
10e0: 48 8b 3a mov (%rdx),%rdi
10e3: e8 00 00 00 00 callq 10e8 <bitmap_bitremap+0x48> 10e4: R_X86_64_PC32 __sw_hweight64-0x4
10e8: 4c 21 eb and %r13,%rbx
10eb: 48 01 c3 add %rax,%rbx
10ee: 48 83 c2 08 add $0x8,%rdx
10f2: ff c9 dec %ecx
10f4: 75 ea jne 10e0 <bitmap_bitremap+0x40>
10f6: 44 89 c8 mov %r9d,%eax
10f9: 41 f6 c7 3f test $0x3f,%r15b
10fd: 74 1c je 111b <bitmap_bitremap+0x7b>
10ff: 44 89 f9 mov %r15d,%ecx
1102: f7 d9 neg %ecx
1104: 48 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%rdi
110b: 48 d3 ef shr %cl,%rdi
110e: 49 23 3c c6 and (%r14,%rax,8),%rdi
1112: e8 00 00 00 00 callq 1117 <bitmap_bitremap+0x77> 1113: R_X86_64_PC32 __sw_hweight64-0x4
1117: 01 d8 add %ebx,%eax
1119: 89 c3 mov %eax,%ebx
111b: 45 39 f8 cmp %r15d,%r8d
111e: 0f 83 d0 00 00 00 jae 11f4 <bitmap_bitremap+0x154>
1124: 44 89 c0 mov %r8d,%eax
1127: 48 0f a3 06 bt %rax,(%rsi)
112b: 19 c0 sbb %eax,%eax
112d: 85 c0 test %eax,%eax
112f: 0f 84 bf 00 00 00 je 11f4 <bitmap_bitremap+0x154>
1135: 45 31 d2 xor %r10d,%r10d
1138: 45 89 c1 mov %r8d,%r9d
113b: 41 c1 e9 06 shr $0x6,%r9d
113f: b8 00 00 00 00 mov $0x0,%eax
1144: 74 23 je 1169 <bitmap_bitremap+0xc9>
1146: 45 31 d2 xor %r10d,%r10d
1149: 48 89 f1 mov %rsi,%rcx
114c: 44 89 ca mov %r9d,%edx
114f: 90 nop
1150: 48 8b 39 mov (%rcx),%rdi
1153: e8 00 00 00 00 callq 1158 <bitmap_bitremap+0xb8> 1154: R_X86_64_PC32 __sw_hweight64-0x4
1158: 4d 21 ea and %r13,%r10
115b: 49 01 c2 add %rax,%r10
115e: 48 83 c1 08 add $0x8,%rcx
1162: ff ca dec %edx
1164: 75 ea jne 1150 <bitmap_bitremap+0xb0>
1166: 44 89 c8 mov %r9d,%eax
1169: 41 f6 c0 3f test $0x3f,%r8b
116d: 74 1e je 118d <bitmap_bitremap+0xed>
116f: 44 89 c1 mov %r8d,%ecx
1172: f7 d9 neg %ecx
1174: 48 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%rdi
117b: 48 d3 ef shr %cl,%rdi
117e: 48 23 3c c6 and (%rsi,%rax,8),%rdi
1182: e8 00 00 00 00 callq 1187 <bitmap_bitremap+0xe7> 1183: R_X86_64_PC32 __sw_hweight64-0x4
1187: 44 01 d0 add %r10d,%eax
118a: 41 89 c2 mov %eax,%r10d
118d: 85 db test %ebx,%ebx
118f: 74 63 je 11f4 <bitmap_bitremap+0x154>
1191: 45 85 d2 test %r10d,%r10d
1194: 78 5e js 11f4 <bitmap_bitremap+0x154>
1196: 44 89 d0 mov %r10d,%eax
1199: 99 cltd
119a: f7 fb idiv %ebx
119c: 41 89 d4 mov %edx,%r12d
119f: 44 89 fb mov %r15d,%ebx
11a2: 4c 89 f7 mov %r14,%rdi
11a5: 48 89 de mov %rbx,%rsi
11a8: e8 00 00 00 00 callq 11ad <bitmap_bitremap+0x10d> 11a9: R_X86_64_PC32 find_first_bit-0x4
11ad: 44 89 e1 mov %r12d,%ecx
11b0: 49 89 c0 mov %rax,%r8
11b3: 85 c9 test %ecx,%ecx
11b5: 74 3d je 11f4 <bitmap_bitremap+0x154>
11b7: 45 39 f8 cmp %r15d,%r8d
11ba: 73 38 jae 11f4 <bitmap_bitremap+0x154>
11bc: 41 bc 01 00 00 00 mov $0x1,%r12d
11c2: 41 29 cc sub %ecx,%r12d
11c5: 66 66 2e 0f 1f 84 00 00 00 00 00 data32 nopw %cs:0x0(%rax,%rax,1)
11d0: 41 ff c0 inc %r8d
11d3: 4d 21 e8 and %r13,%r8
11d6: 4c 89 f7 mov %r14,%rdi
11d9: 48 89 de mov %rbx,%rsi
11dc: 4c 89 c2 mov %r8,%rdx
11df: e8 00 00 00 00 callq 11e4 <bitmap_bitremap+0x144> 11e0: R_X86_64_PC32 find_next_bit-0x4
11e4: 49 89 c0 mov %rax,%r8
11e7: 45 85 e4 test %r12d,%r12d
11ea: 74 08 je 11f4 <bitmap_bitremap+0x154>
11ec: 41 ff c4 inc %r12d
11ef: 45 39 f8 cmp %r15d,%r8d
11f2: 72 dc jb 11d0 <bitmap_bitremap+0x130>
11f4: 44 89 c0 mov %r8d,%eax
11f7: 48 83 c4 08 add $0x8,%rsp
11fb: 5b pop %rbx
11fc: 41 5c pop %r12
11fe: 41 5d pop %r13
1200: 41 5e pop %r14
1202: 41 5f pop %r15
1204: 5d pop %rbp
1205: c3 retq
1206: 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:0x0(%rax,%rax,1)

0000000000001210 <bitmap_onto>:
1210: 55 push %rbp
1211: 48 89 e5 mov %rsp,%rbp
1214: 41 57 push %r15
1216: 41 56 push %r14
1218: 41 55 push %r13
121a: 41 54 push %r12
121c: 53 push %rbx
121d: 48 83 ec 18 sub $0x18,%rsp
1221: 41 89 cd mov %ecx,%r13d
1224: 48 89 55 d0 mov %rdx,-0x30(%rbp)
1228: 49 89 f7 mov %rsi,%r15
122b: 48 89 7d c8 mov %rdi,-0x38(%rbp)
122f: 4c 39 ff cmp %r15,%rdi
1232: 74 74 je 12a8 <bitmap_onto+0x98>
1234: 44 89 eb mov %r13d,%ebx
1237: 48 8d 53 3f lea 0x3f(%rbx),%rdx
123b: 48 c1 ea 03 shr $0x3,%rdx
123f: 81 e2 f8 ff ff 3f and $0x3ffffff8,%edx
1245: 45 31 e4 xor %r12d,%r12d
1248: 31 f6 xor %esi,%esi
124a: 48 8b 7d c8 mov -0x38(%rbp),%rdi
124e: e8 00 00 00 00 callq 1253 <bitmap_onto+0x43> 124f: R_X86_64_PC32 memset-0x4
1253: 48 8b 7d d0 mov -0x30(%rbp),%rdi
1257: 48 89 de mov %rbx,%rsi
125a: e8 00 00 00 00 callq 125f <bitmap_onto+0x4f> 125b: R_X86_64_PC32 find_first_bit-0x4
125f: 44 39 e8 cmp %r13d,%eax
1262: 73 44 jae 12a8 <bitmap_onto+0x98>
1264: 41 be ff ff ff ff mov $0xffffffff,%r14d
126a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1)
1270: 44 89 e1 mov %r12d,%ecx
1273: 49 0f a3 0f bt %rcx,(%r15)
1277: 19 c9 sbb %ecx,%ecx
1279: 85 c9 test %ecx,%ecx
127b: 74 0f je 128c <bitmap_onto+0x7c>
127d: 48 89 c1 mov %rax,%rcx
1280: 4c 21 f1 and %r14,%rcx
1283: 48 8b 55 c8 mov -0x38(%rbp),%rdx
1287: f0 48 0f ab 0a lock bts %rcx,(%rdx)
128c: 41 ff c4 inc %r12d
128f: ff c0 inc %eax
1291: 4c 21 f0 and %r14,%rax
1294: 48 8b 7d d0 mov -0x30(%rbp),%rdi
1298: 48 89 de mov %rbx,%rsi
129b: 48 89 c2 mov %rax,%rdx
129e: e8 00 00 00 00 callq 12a3 <bitmap_onto+0x93> 129f: R_X86_64_PC32 find_next_bit-0x4
12a3: 44 39 e8 cmp %r13d,%eax
12a6: 72 c8 jb 1270 <bitmap_onto+0x60>
12a8: 48 83 c4 18 add $0x18,%rsp
12ac: 5b pop %rbx
12ad: 41 5c pop %r12
12af: 41 5d pop %r13
12b1: 41 5e pop %r14
12b3: 41 5f pop %r15
12b5: 5d pop %rbp
12b6: c3 retq
12b7: 66 0f 1f 84 00 00 00 00 00 nopw 0x0(%rax,%rax,1)

00000000000012c0 <bitmap_fold>:
12c0: 55 push %rbp
12c1: 48 89 e5 mov %rsp,%rbp
12c4: 41 57 push %r15
12c6: 41 56 push %r14
12c8: 41 55 push %r13
12ca: 41 54 push %r12
12cc: 53 push %rbx
12cd: 50 push %rax
12ce: 41 89 cf mov %ecx,%r15d
12d1: 41 89 d6 mov %edx,%r14d
12d4: 49 89 f4 mov %rsi,%r12
12d7: 49 89 fd mov %rdi,%r13
12da: 4d 39 e5 cmp %r12,%r13
12dd: 74 56 je 1335 <bitmap_fold+0x75>
12df: 44 89 fb mov %r15d,%ebx
12e2: 48 8d 53 3f lea 0x3f(%rbx),%rdx
12e6: 48 c1 ea 03 shr $0x3,%rdx
12ea: 81 e2 f8 ff ff 3f and $0x3ffffff8,%edx
12f0: 31 f6 xor %esi,%esi
12f2: 4c 89 ef mov %r13,%rdi
12f5: e8 00 00 00 00 callq 12fa <bitmap_fold+0x3a> 12f6: R_X86_64_PC32 memset-0x4
12fa: 4c 89 e7 mov %r12,%rdi
12fd: 48 89 de mov %rbx,%rsi
1300: e8 00 00 00 00 callq 1305 <bitmap_fold+0x45> 1301: R_X86_64_PC32 find_first_bit-0x4
1305: eb 26 jmp 132d <bitmap_fold+0x6d>
1307: 66 0f 1f 84 00 00 00 00 00 nopw 0x0(%rax,%rax,1)
1310: 31 d2 xor %edx,%edx
1312: 89 c8 mov %ecx,%eax
1314: 41 f7 f6 div %r14d
1317: f0 49 0f ab 55 00 lock bts %rdx,0x0(%r13)
131d: ff c1 inc %ecx
131f: 4c 89 e7 mov %r12,%rdi
1322: 48 89 de mov %rbx,%rsi
1325: 48 89 ca mov %rcx,%rdx
1328: e8 00 00 00 00 callq 132d <bitmap_fold+0x6d> 1329: R_X86_64_PC32 find_next_bit-0x4
132d: 48 89 c1 mov %rax,%rcx
1330: 44 39 f9 cmp %r15d,%ecx
1333: 72 db jb 1310 <bitmap_fold+0x50>
1335: 48 83 c4 08 add $0x8,%rsp
1339: 5b pop %rbx
133a: 41 5c pop %r12
133c: 41 5d pop %r13
133e: 41 5e pop %r14
1340: 41 5f pop %r15
1342: 5d pop %rbp
1343: c3 retq
1344: 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000001350 <bitmap_find_free_region>:
1350: 55 push %rbp
1351: 41 57 push %r15
1353: 41 56 push %r14
1355: 41 54 push %r12
1357: 53 push %rbx
1358: 41 ba 01 00 00 00 mov $0x1,%r10d
135e: 88 d1 mov %dl,%cl
1360: 41 d3 e2 shl %cl,%r10d
1363: b8 f4 ff ff ff mov $0xfffffff4,%eax
1368: 41 39 f2 cmp %esi,%r10d
136b: 0f 87 cb 00 00 00 ja 143c <bitmap_find_free_region+0xec>
1371: 4d 63 f2 movslq %r10d,%r14
1374: 49 83 c6 3f add $0x3f,%r14
1378: 4d 89 f1 mov %r14,%r9
137b: 49 c1 e9 06 shr $0x6,%r9
137f: 41 83 fa 41 cmp $0x41,%r10d
1383: b9 40 00 00 00 mov $0x40,%ecx
1388: 41 0f 4c ca cmovl %r10d,%ecx
138c: ff c9 dec %ecx
138e: 41 bf 02 00 00 00 mov $0x2,%r15d
1394: 49 d3 e7 shl %cl,%r15
1397: 49 ff cf dec %r15
139a: 4c 89 f3 mov %r14,%rbx
139d: 48 c1 fb 06 sar $0x6,%rbx
13a1: 45 31 c0 xor %r8d,%r8d
13a4: 45 89 d4 mov %r10d,%r12d
13a7: 44 89 c2 mov %r8d,%edx
13aa: c1 ea 06 shr $0x6,%edx
13ad: 89 d5 mov %edx,%ebp
13af: c1 e5 06 shl $0x6,%ebp
13b2: 44 89 c1 mov %r8d,%ecx
13b5: 29 e9 sub %ebp,%ecx
13b7: 4d 89 fb mov %r15,%r11
13ba: 49 d3 e3 shl %cl,%r11
13bd: 45 85 c9 test %r9d,%r9d
13c0: b9 00 00 00 00 mov $0x0,%ecx
13c5: 7e 72 jle 1439 <bitmap_find_free_region+0xe9>
13c7: 66 0f 1f 84 00 00 00 00 00 nopw 0x0(%rax,%rax,1)
13d0: 8d 2c 0a lea (%rdx,%rcx,1),%ebp
13d3: 48 63 ed movslq %ebp,%rbp
13d6: 4c 85 1c ef test %r11,(%rdi,%rbp,8)
13da: 75 14 jne 13f0 <bitmap_find_free_region+0xa0>
13dc: 48 ff c1 inc %rcx
13df: 48 39 d9 cmp %rbx,%rcx
13e2: 7c ec jl 13d0 <bitmap_find_free_region+0x80>
13e4: eb 17 jmp 13fd <bitmap_find_free_region+0xad>
13e6: 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:0x0(%rax,%rax,1)
13f0: 45 01 d4 add %r10d,%r12d
13f3: 45 01 d0 add %r10d,%r8d
13f6: 41 39 f4 cmp %esi,%r12d
13f9: 76 ac jbe 13a7 <bitmap_find_free_region+0x57>
13fb: eb 3f jmp 143c <bitmap_find_free_region+0xec>
13fd: 31 c9 xor %ecx,%ecx
13ff: 49 0f ba e6 06 bt $0x6,%r14
1404: 73 0b jae 1411 <bitmap_find_free_region+0xc1>
1406: 89 d0 mov %edx,%eax
1408: 4c 09 1c c7 or %r11,(%rdi,%rax,8)
140c: b9 01 00 00 00 mov $0x1,%ecx
1411: 41 83 f9 01 cmp $0x1,%r9d
1415: 74 22 je 1439 <bitmap_find_free_region+0xe9>
1417: 41 29 c9 sub %ecx,%r9d
141a: 8d 44 0a 01 lea 0x1(%rdx,%rcx,1),%eax
141e: 01 ca add %ecx,%edx
1420: 48 63 d2 movslq %edx,%rdx
1423: 4c 09 1c d7 or %r11,(%rdi,%rdx,8)
1427: 48 98 cltq
1429: 4c 09 1c c7 or %r11,(%rdi,%rax,8)
142d: 83 c0 02 add $0x2,%eax
1430: 83 c2 02 add $0x2,%edx
1433: 41 83 c1 fe add $0xfffffffe,%r9d
1437: 75 e7 jne 1420 <bitmap_find_free_region+0xd0>
1439: 44 89 c0 mov %r8d,%eax
143c: 5b pop %rbx
143d: 41 5c pop %r12
143f: 41 5e pop %r14
1441: 41 5f pop %r15
1443: 5d pop %rbp
1444: c3 retq
1445: 66 66 2e 0f 1f 84 00 00 00 00 00 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000001450 <bitmap_release_region>:
1450: 41 b8 01 00 00 00 mov $0x1,%r8d
1456: 88 d1 mov %dl,%cl
1458: 41 d3 e0 shl %cl,%r8d
145b: 4d 63 c8 movslq %r8d,%r9
145e: 49 83 c1 3f add $0x3f,%r9
1462: 4c 89 c8 mov %r9,%rax
1465: 48 c1 e8 06 shr $0x6,%rax
1469: 85 c0 test %eax,%eax
146b: 7e 6c jle 14d9 <bitmap_release_region+0x89>
146d: 89 f2 mov %esi,%edx
146f: c1 ea 06 shr $0x6,%edx
1472: 41 83 f8 41 cmp $0x41,%r8d
1476: b9 40 00 00 00 mov $0x40,%ecx
147b: 41 0f 4c c8 cmovl %r8d,%ecx
147f: ff c9 dec %ecx
1481: 41 b8 02 00 00 00 mov $0x2,%r8d
1487: 49 d3 e0 shl %cl,%r8
148a: 49 ff c8 dec %r8
148d: 89 d1 mov %edx,%ecx
148f: c1 e1 06 shl $0x6,%ecx
1492: 29 ce sub %ecx,%esi
1494: 40 88 f1 mov %sil,%cl
1497: 49 d3 e0 shl %cl,%r8
149a: 49 f7 d0 not %r8
149d: 31 f6 xor %esi,%esi
149f: 49 0f ba e1 06 bt $0x6,%r9
14a4: 73 0b jae 14b1 <bitmap_release_region+0x61>
14a6: 89 d1 mov %edx,%ecx
14a8: 4c 21 04 cf and %r8,(%rdi,%rcx,8)
14ac: be 01 00 00 00 mov $0x1,%esi
14b1: 83 f8 01 cmp $0x1,%eax
14b4: 74 23 je 14d9 <bitmap_release_region+0x89>
14b6: 29 f0 sub %esi,%eax
14b8: 8d 4c 32 01 lea 0x1(%rdx,%rsi,1),%ecx
14bc: 01 f2 add %esi,%edx
14be: 66 90 xchg %ax,%ax
14c0: 48 63 d2 movslq %edx,%rdx
14c3: 4c 21 04 d7 and %r8,(%rdi,%rdx,8)
14c7: 48 63 c9 movslq %ecx,%rcx
14ca: 4c 21 04 cf and %r8,(%rdi,%rcx,8)
14ce: 83 c1 02 add $0x2,%ecx
14d1: 83 c2 02 add $0x2,%edx
14d4: 83 c0 fe add $0xfffffffe,%eax
14d7: 75 e7 jne 14c0 <bitmap_release_region+0x70>
14d9: c3 retq
14da: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1)

00000000000014e0 <bitmap_allocate_region>:
14e0: b8 01 00 00 00 mov $0x1,%eax
14e5: 88 d1 mov %dl,%cl
14e7: d3 e0 shl %cl,%eax
14e9: 89 f2 mov %esi,%edx
14eb: c1 ea 06 shr $0x6,%edx
14ee: 89 d1 mov %edx,%ecx
14f0: c1 e1 06 shl $0x6,%ecx
14f3: 29 ce sub %ecx,%esi
14f5: 48 63 c8 movslq %eax,%rcx
14f8: 4c 8d 51 3f lea 0x3f(%rcx),%r10
14fc: 4d 89 d0 mov %r10,%r8
14ff: 49 c1 e8 06 shr $0x6,%r8
1503: 83 f9 41 cmp $0x41,%ecx
1506: b8 40 00 00 00 mov $0x40,%eax
150b: 0f 4d c8 cmovge %eax,%ecx
150e: ff c9 dec %ecx
1510: 41 b9 02 00 00 00 mov $0x2,%r9d
1516: 49 d3 e1 shl %cl,%r9
1519: 49 ff c9 dec %r9
151c: 40 88 f1 mov %sil,%cl
151f: 49 d3 e1 shl %cl,%r9
1522: 31 c0 xor %eax,%eax
1524: 45 85 c0 test %r8d,%r8d
1527: 7e 61 jle 158a <bitmap_allocate_region+0xaa>
1529: 49 63 c8 movslq %r8d,%rcx
152c: 31 f6 xor %esi,%esi
152e: 66 90 xchg %ax,%ax
1530: 8d 04 32 lea (%rdx,%rsi,1),%eax
1533: 48 98 cltq
1535: 4c 85 0c c7 test %r9,(%rdi,%rax,8)
1539: b8 f0 ff ff ff mov $0xfffffff0,%eax
153e: 75 4a jne 158a <bitmap_allocate_region+0xaa>
1540: 48 ff c6 inc %rsi
1543: 48 39 ce cmp %rcx,%rsi
1546: 7c e8 jl 1530 <bitmap_allocate_region+0x50>
1548: 31 c0 xor %eax,%eax
154a: 49 0f ba e2 06 bt $0x6,%r10
154f: be 00 00 00 00 mov $0x0,%esi
1554: 73 0b jae 1561 <bitmap_allocate_region+0x81>
1556: 89 d1 mov %edx,%ecx
1558: 4c 09 0c cf or %r9,(%rdi,%rcx,8)
155c: be 01 00 00 00 mov $0x1,%esi
1561: 41 83 f8 01 cmp $0x1,%r8d
1565: 74 23 je 158a <bitmap_allocate_region+0xaa>
1567: 41 29 f0 sub %esi,%r8d
156a: 8d 4c 32 01 lea 0x1(%rdx,%rsi,1),%ecx
156e: 01 f2 add %esi,%edx
1570: 48 63 d2 movslq %edx,%rdx
1573: 4c 09 0c d7 or %r9,(%rdi,%rdx,8)
1577: 48 63 c9 movslq %ecx,%rcx
157a: 4c 09 0c cf or %r9,(%rdi,%rcx,8)
157e: 83 c1 02 add $0x2,%ecx
1581: 83 c2 02 add $0x2,%edx
1584: 41 83 c0 fe add $0xfffffffe,%r8d
1588: 75 e6 jne 1570 <bitmap_allocate_region+0x90>
158a: c3 retq

Disassembly of section .altinstr_replacement:

0000000000000000 <.altinstr_replacement>:
0: f3 48 0f b8 c7 popcnt %rdi,%rax
5: f3 48 0f b8 c7 popcnt %rdi,%rax
a: 0f 01 (bad)
c: cb lret
d: 0f 01 (bad)
f: ca 0f 01 lret $0x10f
12: cb lret
13: 0f 01 (bad)
15: ca f3 48 lret $0x48f3
18: 0f b8 (bad)
1a: c7 (bad)
1b: f3 48 0f b8 c7 popcnt %rdi,%rax
20: f3 48 0f b8 c7 popcnt %rdi,%rax
25: f3 48 0f b8 c7 popcnt %rdi,%rax
2a: f3 48 0f b8 c7 popcnt %rdi,%rax
2f: f3 48 0f b8 c7 popcnt %rdi,%rax
34: f3 48 0f b8 c7 popcnt %rdi,%rax
39: f3 48 0f b8 c7 popcnt %rdi,%rax

Disassembly of section .fixup:

0000000000000000 <.fixup>:
0: b9 f2 ff ff ff mov $0xfffffff2,%ecx
5: 30 d2 xor %dl,%dl
7: e9 00 00 00 00 jmpq c <.fixup+0xc> 8: R_X86_64_PC32 .text+0xa39
c: be f2 ff ff ff mov $0xfffffff2,%esi
11: 30 c0 xor %al,%al
13: e9 00 00 00 00 jmpq 18 <__kstrtab___bitmap_complement+0x9> 14: R_X86_64_PC32 .text+0xd06

lib/bitmap.o: file format elf64-x86-64

Disassembly of section .text:

0000000000000000 <__bitmap_equal>:
0: 41 89 d2 mov %edx,%r10d
3: 55 push %rbp
4: 41 c1 ea 06 shr $0x6,%r10d
8: 45 85 d2 test %r10d,%r10d
b: 48 89 e5 mov %rsp,%rbp
e: 74 27 je 37 <__bitmap_equal+0x37>
10: 48 8b 06 mov (%rsi),%rax
13: 48 39 07 cmp %rax,(%rdi)
16: 75 4a jne 62 <__bitmap_equal+0x62>
18: 31 c0 xor %eax,%eax
1a: 45 31 c0 xor %r8d,%r8d
1d: eb 0f jmp 2e <__bitmap_equal+0x2e>
1f: 4c 8b 4c 07 08 mov 0x8(%rdi,%rax,1),%r9
24: 48 83 c0 08 add $0x8,%rax
28: 4c 3b 0c 06 cmp (%rsi,%rax,1),%r9
2c: 75 34 jne 62 <__bitmap_equal+0x62>
2e: 41 83 c0 01 add $0x1,%r8d
32: 45 39 d0 cmp %r10d,%r8d
35: 75 e8 jne 1f <__bitmap_equal+0x1f>
37: f6 c2 3f test $0x3f,%dl
3a: b8 01 00 00 00 mov $0x1,%eax
3f: 74 1f je 60 <__bitmap_equal+0x60>
41: 4a 8b 34 d6 mov (%rsi,%r10,8),%rsi
45: 4a 33 34 d7 xor (%rdi,%r10,8),%rsi
49: 89 d1 mov %edx,%ecx
4b: f7 d9 neg %ecx
4d: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax
54: 48 d3 e8 shr %cl,%rax
57: 48 85 c6 test %rax,%rsi
5a: 0f 94 c0 sete %al
5d: 0f b6 c0 movzbl %al,%eax
60: 5d pop %rbp
61: c3 retq
62: 31 c0 xor %eax,%eax
64: 5d pop %rbp
65: c3 retq
66: 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:0x0(%rax,%rax,1)

0000000000000070 <__bitmap_complement>:
70: 41 89 d0 mov %edx,%r8d
73: 55 push %rbp
74: 41 c1 e8 06 shr $0x6,%r8d
78: 45 85 c0 test %r8d,%r8d
7b: 48 89 e5 mov %rsp,%rbp
7e: 74 16 je 96 <__bitmap_complement+0x26>
80: 31 c0 xor %eax,%eax
82: 48 8b 0c c6 mov (%rsi,%rax,8),%rcx
86: 48 f7 d1 not %rcx
89: 48 89 0c c7 mov %rcx,(%rdi,%rax,8)
8d: 48 83 c0 01 add $0x1,%rax
91: 41 39 c0 cmp %eax,%r8d
94: 77 ec ja 82 <__bitmap_complement+0x12>
96: 83 e2 3f and $0x3f,%edx
99: 74 0b je a6 <__bitmap_complement+0x36>
9b: 4a 8b 04 c6 mov (%rsi,%r8,8),%rax
9f: 48 f7 d0 not %rax
a2: 4a 89 04 c7 mov %rax,(%rdi,%r8,8)
a6: 5d pop %rbp
a7: c3 retq
a8: 0f 1f 84 00 00 00 00 00 nopl 0x0(%rax,%rax,1)

00000000000000b0 <__bitmap_and>:
b0: 41 89 ca mov %ecx,%r10d
b3: 55 push %rbp
b4: 41 c1 ea 06 shr $0x6,%r10d
b8: 45 85 d2 test %r10d,%r10d
bb: 48 89 e5 mov %rsp,%rbp
be: 74 4d je 10d <__bitmap_and+0x5d>
c0: 31 c0 xor %eax,%eax
c2: 45 31 c9 xor %r9d,%r9d
c5: 4c 8b 04 c2 mov (%rdx,%rax,8),%r8
c9: 4c 23 04 c6 and (%rsi,%rax,8),%r8
cd: 4c 89 04 c7 mov %r8,(%rdi,%rax,8)
d1: 48 83 c0 01 add $0x1,%rax
d5: 4d 09 c1 or %r8,%r9
d8: 41 39 c2 cmp %eax,%r10d
db: 77 e8 ja c5 <__bitmap_and+0x15>
dd: f6 c1 3f test $0x3f,%cl
e0: 74 21 je 103 <__bitmap_and+0x53>
e2: 4a 8b 04 d6 mov (%rsi,%r10,8),%rax
e6: 4a 23 04 d2 and (%rdx,%r10,8),%rax
ea: f7 d9 neg %ecx
ec: 48 89 c2 mov %rax,%rdx
ef: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax
f6: 48 d3 e8 shr %cl,%rax
f9: 48 21 d0 and %rdx,%rax
fc: 4a 89 04 d7 mov %rax,(%rdi,%r10,8)
100: 49 09 c1 or %rax,%r9
103: 31 c0 xor %eax,%eax
105: 4d 85 c9 test %r9,%r9
108: 0f 95 c0 setne %al
10b: 5d pop %rbp
10c: c3 retq
10d: 45 31 c9 xor %r9d,%r9d
110: eb cb jmp dd <__bitmap_and+0x2d>
112: 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000000120 <__bitmap_or>:
120: 89 c9 mov %ecx,%ecx
122: 55 push %rbp
123: 31 c0 xor %eax,%eax
125: 48 83 c1 3f add $0x3f,%rcx
129: 48 c1 e9 06 shr $0x6,%rcx
12d: 48 89 e5 mov %rsp,%rbp
130: 48 85 c9 test %rcx,%rcx
133: 41 89 c8 mov %ecx,%r8d
136: 74 15 je 14d <__bitmap_or+0x2d>
138: 48 8b 0c c2 mov (%rdx,%rax,8),%rcx
13c: 48 0b 0c c6 or (%rsi,%rax,8),%rcx
140: 48 89 0c c7 mov %rcx,(%rdi,%rax,8)
144: 48 83 c0 01 add $0x1,%rax
148: 41 39 c0 cmp %eax,%r8d
14b: 77 eb ja 138 <__bitmap_or+0x18>
14d: 5d pop %rbp
14e: c3 retq
14f: 90 nop

0000000000000150 <__bitmap_xor>:
150: 89 c9 mov %ecx,%ecx
152: 55 push %rbp
153: 31 c0 xor %eax,%eax
155: 48 83 c1 3f add $0x3f,%rcx
159: 48 c1 e9 06 shr $0x6,%rcx
15d: 48 89 e5 mov %rsp,%rbp
160: 48 85 c9 test %rcx,%rcx
163: 41 89 c8 mov %ecx,%r8d
166: 74 15 je 17d <__bitmap_xor+0x2d>
168: 48 8b 0c c2 mov (%rdx,%rax,8),%rcx
16c: 48 33 0c c6 xor (%rsi,%rax,8),%rcx
170: 48 89 0c c7 mov %rcx,(%rdi,%rax,8)
174: 48 83 c0 01 add $0x1,%rax
178: 41 39 c0 cmp %eax,%r8d
17b: 77 eb ja 168 <__bitmap_xor+0x18>
17d: 5d pop %rbp
17e: c3 retq
17f: 90 nop

0000000000000180 <__bitmap_andnot>:
180: 41 89 ca mov %ecx,%r10d
183: 55 push %rbp
184: 41 c1 ea 06 shr $0x6,%r10d
188: 45 85 d2 test %r10d,%r10d
18b: 48 89 e5 mov %rsp,%rbp
18e: 74 54 je 1e4 <__bitmap_andnot+0x64>
190: 45 31 c0 xor %r8d,%r8d
193: 45 31 c9 xor %r9d,%r9d
196: 4a 8b 04 c2 mov (%rdx,%r8,8),%rax
19a: 48 f7 d0 not %rax
19d: 4a 23 04 c6 and (%rsi,%r8,8),%rax
1a1: 4a 89 04 c7 mov %rax,(%rdi,%r8,8)
1a5: 49 83 c0 01 add $0x1,%r8
1a9: 49 09 c1 or %rax,%r9
1ac: 45 39 c2 cmp %r8d,%r10d
1af: 77 e5 ja 196 <__bitmap_andnot+0x16>
1b1: f6 c1 3f test $0x3f,%cl
1b4: 74 24 je 1da <__bitmap_andnot+0x5a>
1b6: f7 d9 neg %ecx
1b8: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax
1bf: 48 d3 e8 shr %cl,%rax
1c2: 4a 23 04 d6 and (%rsi,%r10,8),%rax
1c6: 48 89 c1 mov %rax,%rcx
1c9: 4a 8b 04 d2 mov (%rdx,%r10,8),%rax
1cd: 48 f7 d0 not %rax
1d0: 48 21 c8 and %rcx,%rax
1d3: 4a 89 04 d7 mov %rax,(%rdi,%r10,8)
1d7: 49 09 c1 or %rax,%r9
1da: 31 c0 xor %eax,%eax
1dc: 4d 85 c9 test %r9,%r9
1df: 0f 95 c0 setne %al
1e2: 5d pop %rbp
1e3: c3 retq
1e4: 45 31 c9 xor %r9d,%r9d
1e7: eb c8 jmp 1b1 <__bitmap_andnot+0x31>
1e9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)

00000000000001f0 <__bitmap_intersects>:
1f0: 41 89 d2 mov %edx,%r10d
1f3: 55 push %rbp
1f4: 41 c1 ea 06 shr $0x6,%r10d
1f8: 45 85 d2 test %r10d,%r10d
1fb: 48 89 e5 mov %rsp,%rbp
1fe: 74 2b je 22b <__bitmap_intersects+0x3b>
200: 48 8b 07 mov (%rdi),%rax
203: 48 85 06 test %rax,(%rsi)
206: 75 4e jne 256 <__bitmap_intersects+0x66>
208: 31 c0 xor %eax,%eax
20a: 45 31 c9 xor %r9d,%r9d
20d: eb 13 jmp 222 <__bitmap_intersects+0x32>
20f: 4c 8b 44 06 08 mov 0x8(%rsi,%rax,1),%r8
214: 4c 23 44 07 08 and 0x8(%rdi,%rax,1),%r8
219: 48 83 c0 08 add $0x8,%rax
21d: 4d 85 c0 test %r8,%r8
220: 75 34 jne 256 <__bitmap_intersects+0x66>
222: 41 83 c1 01 add $0x1,%r9d
226: 45 39 d1 cmp %r10d,%r9d
229: 75 e4 jne 20f <__bitmap_intersects+0x1f>
22b: 31 c0 xor %eax,%eax
22d: f6 c2 3f test $0x3f,%dl
230: 74 22 je 254 <__bitmap_intersects+0x64>
232: 4a 8b 04 d7 mov (%rdi,%r10,8),%rax
236: 4a 23 04 d6 and (%rsi,%r10,8),%rax
23a: 89 d1 mov %edx,%ecx
23c: f7 d9 neg %ecx
23e: 48 89 c6 mov %rax,%rsi
241: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax
248: 48 d3 e8 shr %cl,%rax
24b: 48 85 c6 test %rax,%rsi
24e: 0f 95 c0 setne %al
251: 0f b6 c0 movzbl %al,%eax
254: 5d pop %rbp
255: c3 retq
256: b8 01 00 00 00 mov $0x1,%eax
25b: 5d pop %rbp
25c: c3 retq
25d: 0f 1f 00 nopl (%rax)

0000000000000260 <__bitmap_subset>:
260: 41 89 d2 mov %edx,%r10d
263: 55 push %rbp
264: 41 c1 ea 06 shr $0x6,%r10d
268: 45 85 d2 test %r10d,%r10d
26b: 48 89 e5 mov %rsp,%rbp
26e: 74 32 je 2a2 <__bitmap_subset+0x42>
270: 48 8b 06 mov (%rsi),%rax
273: 48 f7 d0 not %rax
276: 48 85 07 test %rax,(%rdi)
279: 75 55 jne 2d0 <__bitmap_subset+0x70>
27b: 45 31 c0 xor %r8d,%r8d
27e: 45 31 c9 xor %r9d,%r9d
281: eb 16 jmp 299 <__bitmap_subset+0x39>
283: 4a 8b 44 06 08 mov 0x8(%rsi,%r8,1),%rax
288: 48 f7 d0 not %rax
28b: 4a 23 44 07 08 and 0x8(%rdi,%r8,1),%rax
290: 49 83 c0 08 add $0x8,%r8
294: 48 85 c0 test %rax,%rax
297: 75 37 jne 2d0 <__bitmap_subset+0x70>
299: 41 83 c1 01 add $0x1,%r9d
29d: 45 39 d1 cmp %r10d,%r9d
2a0: 75 e1 jne 283 <__bitmap_subset+0x23>
2a2: f6 c2 3f test $0x3f,%dl
2a5: b8 01 00 00 00 mov $0x1,%eax
2aa: 74 22 je 2ce <__bitmap_subset+0x6e>
2ac: 89 d1 mov %edx,%ecx
2ae: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax
2b5: 4a 8b 14 d6 mov (%rsi,%r10,8),%rdx
2b9: f7 d9 neg %ecx
2bb: 48 d3 e8 shr %cl,%rax
2be: 4a 23 04 d7 and (%rdi,%r10,8),%rax
2c2: 48 f7 d2 not %rdx
2c5: 48 85 d0 test %rdx,%rax
2c8: 0f 94 c0 sete %al
2cb: 0f b6 c0 movzbl %al,%eax
2ce: 5d pop %rbp
2cf: c3 retq
2d0: 31 c0 xor %eax,%eax
2d2: 5d pop %rbp
2d3: c3 retq
2d4: 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 nopw %cs:0x0(%rax,%rax,1)

00000000000002e0 <bitmap_set>:
2e0: 89 f0 mov %esi,%eax
2e2: 89 f1 mov %esi,%ecx
2e4: 55 push %rbp
2e5: c1 e8 06 shr $0x6,%eax
2e8: 83 e1 3f and $0x3f,%ecx
2eb: 48 8d 04 c7 lea (%rdi,%rax,8),%rax
2ef: 48 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%rdi
2f6: 48 89 e5 mov %rsp,%rbp
2f9: 48 d3 e7 shl %cl,%rdi
2fc: 8d 4c 0a c0 lea -0x40(%rdx,%rcx,1),%ecx
300: 85 c9 test %ecx,%ecx
302: 78 4a js 34e <bitmap_set+0x6e>
304: 41 89 c9 mov %ecx,%r9d
307: 41 c1 e9 06 shr $0x6,%r9d
30b: 45 89 c8 mov %r9d,%r8d
30e: 4e 8d 04 c5 08 00 00 00 lea 0x8(,%r8,8),%r8
316: 49 01 c0 add %rax,%r8
319: 48 09 38 or %rdi,(%rax)
31c: 48 83 c0 08 add $0x8,%rax
320: 48 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%rdi
327: 4c 39 c0 cmp %r8,%rax
32a: 75 ed jne 319 <bitmap_set+0x39>
32c: 41 c1 e1 06 shl $0x6,%r9d
330: 44 29 c9 sub %r9d,%ecx
333: 85 c9 test %ecx,%ecx
335: 74 15 je 34c <bitmap_set+0x6c>
337: 8d 0c 16 lea (%rsi,%rdx,1),%ecx
33a: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax
341: f7 d9 neg %ecx
343: 48 d3 e8 shr %cl,%rax
346: 48 21 c7 and %rax,%rdi
349: 49 09 38 or %rdi,(%r8)
34c: 5d pop %rbp
34d: c3 retq
34e: 49 89 c0 mov %rax,%r8
351: 89 d1 mov %edx,%ecx
353: eb de jmp 333 <bitmap_set+0x53>
355: 66 66 2e 0f 1f 84 00 00 00 00 00 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000000360 <bitmap_clear>:
360: 89 f0 mov %esi,%eax
362: 89 f1 mov %esi,%ecx
364: 55 push %rbp
365: c1 e8 06 shr $0x6,%eax
368: 83 e1 3f and $0x3f,%ecx
36b: 48 8d 04 c7 lea (%rdi,%rax,8),%rax
36f: 48 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%rdi
376: 48 89 e5 mov %rsp,%rbp
379: 48 d3 e7 shl %cl,%rdi
37c: 8d 4c 0a c0 lea -0x40(%rdx,%rcx,1),%ecx
380: 85 c9 test %ecx,%ecx
382: 78 50 js 3d4 <bitmap_clear+0x74>
384: 41 89 c9 mov %ecx,%r9d
387: 41 c1 e9 06 shr $0x6,%r9d
38b: 45 89 c8 mov %r9d,%r8d
38e: 4e 8d 04 c5 08 00 00 00 lea 0x8(,%r8,8),%r8
396: 49 01 c0 add %rax,%r8
399: 48 f7 d7 not %rdi
39c: 48 21 38 and %rdi,(%rax)
39f: 48 83 c0 08 add $0x8,%rax
3a3: 4c 39 c0 cmp %r8,%rax
3a6: 48 c7 c7 ff ff ff ff mov $0xffffffffffffffff,%rdi
3ad: 75 ea jne 399 <bitmap_clear+0x39>
3af: 41 c1 e1 06 shl $0x6,%r9d
3b3: 44 29 c9 sub %r9d,%ecx
3b6: 85 c9 test %ecx,%ecx
3b8: 74 18 je 3d2 <bitmap_clear+0x72>
3ba: 8d 0c 16 lea (%rsi,%rdx,1),%ecx
3bd: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax
3c4: f7 d9 neg %ecx
3c6: 48 d3 e8 shr %cl,%rax
3c9: 48 21 c7 and %rax,%rdi
3cc: 48 f7 d7 not %rdi
3cf: 49 21 38 and %rdi,(%r8)
3d2: 5d pop %rbp
3d3: c3 retq
3d4: 49 89 c0 mov %rax,%r8
3d7: 89 d1 mov %edx,%ecx
3d9: eb db jmp 3b6 <bitmap_clear+0x56>
3db: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)

00000000000003e0 <__reg_op>:
3e0: 41 89 ca mov %ecx,%r10d
3e3: b8 01 00 00 00 mov $0x1,%eax
3e8: 89 d1 mov %edx,%ecx
3ea: d3 e0 shl %cl,%eax
3ec: 41 b8 40 00 00 00 mov $0x40,%r8d
3f2: 55 push %rbp
3f3: 4c 63 c8 movslq %eax,%r9
3f6: 89 f0 mov %esi,%eax
3f8: 4c 89 ca mov %r9,%rdx
3fb: 49 83 c1 3f add $0x3f,%r9
3ff: 48 89 e5 mov %rsp,%rbp
402: 49 c1 e9 06 shr $0x6,%r9
406: 83 fa 40 cmp $0x40,%edx
409: 41 0f 4f d0 cmovg %r8d,%edx
40d: c1 e8 06 shr $0x6,%eax
410: 8d 4a ff lea -0x1(%rdx),%ecx
413: ba 02 00 00 00 mov $0x2,%edx
418: 48 d3 e2 shl %cl,%rdx
41b: 89 f1 mov %esi,%ecx
41d: 48 83 ea 01 sub $0x1,%rdx
421: 48 d3 e2 shl %cl,%rdx
424: 41 83 fa 01 cmp $0x1,%r10d
428: 74 5a je 484 <__reg_op+0xa4>
42a: 41 83 fa 02 cmp $0x2,%r10d
42e: 74 36 je 466 <__reg_op+0x86>
430: 45 85 d2 test %r10d,%r10d
433: 74 04 je 439 <__reg_op+0x59>
435: 31 c0 xor %eax,%eax
437: 5d pop %rbp
438: c3 retq
439: 45 85 c9 test %r9d,%r9d
43c: 7e 21 jle 45f <__reg_op+0x7f>
43e: 48 63 c8 movslq %eax,%rcx
441: 48 85 14 cf test %rdx,(%rdi,%rcx,8)
445: 75 ee jne 435 <__reg_op+0x55>
447: 8d 48 01 lea 0x1(%rax),%ecx
44a: 44 01 c8 add %r9d,%eax
44d: eb 0c jmp 45b <__reg_op+0x7b>
44f: 48 63 f1 movslq %ecx,%rsi
452: 83 c1 01 add $0x1,%ecx
455: 48 85 14 f7 test %rdx,(%rdi,%rsi,8)
459: 75 da jne 435 <__reg_op+0x55>
45b: 39 c1 cmp %eax,%ecx
45d: 75 f0 jne 44f <__reg_op+0x6f>
45f: b8 01 00 00 00 mov $0x1,%eax
464: 5d pop %rbp
465: c3 retq
466: 45 85 c9 test %r9d,%r9d
469: 48 f7 d2 not %rdx
46c: 42 8d 34 08 lea (%rax,%r9,1),%esi
470: 7e c3 jle 435 <__reg_op+0x55>
472: 48 63 c8 movslq %eax,%rcx
475: 83 c0 01 add $0x1,%eax
478: 48 21 14 cf and %rdx,(%rdi,%rcx,8)
47c: 39 f0 cmp %esi,%eax
47e: 75 f2 jne 472 <__reg_op+0x92>
480: 31 c0 xor %eax,%eax
482: eb b3 jmp 437 <__reg_op+0x57>
484: 45 85 c9 test %r9d,%r9d
487: 42 8d 34 08 lea (%rax,%r9,1),%esi
48b: 7e a8 jle 435 <__reg_op+0x55>
48d: 48 63 c8 movslq %eax,%rcx
490: 83 c0 01 add $0x1,%eax
493: 48 09 14 cf or %rdx,(%rdi,%rcx,8)
497: 39 f0 cmp %esi,%eax
499: 75 f2 jne 48d <__reg_op+0xad>
49b: 31 c0 xor %eax,%eax
49d: eb 98 jmp 437 <__reg_op+0x57>
49f: 90 nop

00000000000004a0 <bitmap_find_free_region>:
4a0: 55 push %rbp
4a1: 89 d1 mov %edx,%ecx
4a3: 48 89 e5 mov %rsp,%rbp
4a6: 41 57 push %r15
4a8: 41 56 push %r14
4aa: 41 55 push %r13
4ac: 41 54 push %r12
4ae: 41 bc 01 00 00 00 mov $0x1,%r12d
4b4: 53 push %rbx
4b5: 41 d3 e4 shl %cl,%r12d
4b8: 31 db xor %ebx,%ebx
4ba: 46 8d 3c 23 lea (%rbx,%r12,1),%r15d
4be: 49 89 fe mov %rdi,%r14
4c1: 41 89 d5 mov %edx,%r13d
4c4: 48 83 ec 08 sub $0x8,%rsp
4c8: 89 75 d4 mov %esi,-0x2c(%rbp)
4cb: 44 3b 7d d4 cmp -0x2c(%rbp),%r15d
4cf: 77 20 ja 4f1 <bitmap_find_free_region+0x51>
4d1: 31 c9 xor %ecx,%ecx
4d3: 44 89 ea mov %r13d,%edx
4d6: 89 de mov %ebx,%esi
4d8: 4c 89 f7 mov %r14,%rdi
4db: e8 00 ff ff ff callq 3e0 <__reg_op>
4e0: 85 c0 test %eax,%eax
4e2: 75 21 jne 505 <bitmap_find_free_region+0x65>
4e4: 44 89 fb mov %r15d,%ebx
4e7: 46 8d 3c 23 lea (%rbx,%r12,1),%r15d
4eb: 44 3b 7d d4 cmp -0x2c(%rbp),%r15d
4ef: 76 e0 jbe 4d1 <bitmap_find_free_region+0x31>
4f1: 48 83 c4 08 add $0x8,%rsp
4f5: b8 f4 ff ff ff mov $0xfffffff4,%eax
4fa: 5b pop %rbx
4fb: 41 5c pop %r12
4fd: 41 5d pop %r13
4ff: 41 5e pop %r14
501: 41 5f pop %r15
503: 5d pop %rbp
504: c3 retq
505: 44 89 ea mov %r13d,%edx
508: 89 de mov %ebx,%esi
50a: 4c 89 f7 mov %r14,%rdi
50d: b9 01 00 00 00 mov $0x1,%ecx
512: e8 c9 fe ff ff callq 3e0 <__reg_op>
517: 48 83 c4 08 add $0x8,%rsp
51b: 89 d8 mov %ebx,%eax
51d: 5b pop %rbx
51e: 41 5c pop %r12
520: 41 5d pop %r13
522: 41 5e pop %r14
524: 41 5f pop %r15
526: 5d pop %rbp
527: c3 retq
528: 0f 1f 84 00 00 00 00 00 nopl 0x0(%rax,%rax,1)

0000000000000530 <bitmap_release_region>:
530: 55 push %rbp
531: b9 02 00 00 00 mov $0x2,%ecx
536: 48 89 e5 mov %rsp,%rbp
539: e8 a2 fe ff ff callq 3e0 <__reg_op>
53e: 5d pop %rbp
53f: c3 retq

0000000000000540 <bitmap_allocate_region>:
540: 55 push %rbp
541: 31 c9 xor %ecx,%ecx
543: 48 89 e5 mov %rsp,%rbp
546: 41 55 push %r13
548: 41 54 push %r12
54a: 53 push %rbx
54b: 41 89 d5 mov %edx,%r13d
54e: 48 89 fb mov %rdi,%rbx
551: 41 89 f4 mov %esi,%r12d
554: e8 87 fe ff ff callq 3e0 <__reg_op>
559: 89 c2 mov %eax,%edx
55b: b8 f0 ff ff ff mov $0xfffffff0,%eax
560: 85 d2 test %edx,%edx
562: 74 13 je 577 <bitmap_allocate_region+0x37>
564: b9 01 00 00 00 mov $0x1,%ecx
569: 44 89 ea mov %r13d,%edx
56c: 44 89 e6 mov %r12d,%esi
56f: 48 89 df mov %rbx,%rdi
572: e8 69 fe ff ff callq 3e0 <__reg_op>
577: 5b pop %rbx
578: 41 5c pop %r12
57a: 41 5d pop %r13
57c: 5d pop %rbp
57d: c3 retq
57e: 66 90 xchg %ax,%ax

0000000000000580 <__bitmap_shift_right>:
580: 55 push %rbp
581: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax
588: 48 89 e5 mov %rsp,%rbp
58b: 41 57 push %r15
58d: 41 56 push %r14
58f: 41 55 push %r13
591: 41 89 cd mov %ecx,%r13d
594: 41 54 push %r12
596: 49 83 c5 3f add $0x3f,%r13
59a: 41 89 d7 mov %edx,%r15d
59d: 53 push %rbx
59e: f7 d9 neg %ecx
5a0: 49 c1 ed 06 shr $0x6,%r13
5a4: 41 c1 ef 06 shr $0x6,%r15d
5a8: 48 83 ec 18 sub $0x18,%rsp
5ac: 48 d3 e8 shr %cl,%rax
5af: 83 e2 3f and $0x3f,%edx
5b2: 45 39 fd cmp %r15d,%r13d
5b5: 48 89 45 c8 mov %rax,-0x38(%rbp)
5b9: 76 60 jbe 61b <__bitmap_shift_right+0x9b>
5bb: 41 be 40 00 00 00 mov $0x40,%r14d
5c1: 45 8d 65 ff lea -0x1(%r13),%r12d
5c5: 45 8d 57 01 lea 0x1(%r15),%r10d
5c9: 44 89 eb mov %r13d,%ebx
5cc: 49 89 fb mov %rdi,%r11
5cf: 45 89 f8 mov %r15d,%r8d
5d2: 41 29 d6 sub %edx,%r14d
5d5: 31 c0 xor %eax,%eax
5d7: 85 d2 test %edx,%edx
5d9: 74 17 je 5f2 <__bitmap_shift_right+0x72>
5db: 44 39 d3 cmp %r10d,%ebx
5de: 76 12 jbe 5f2 <__bitmap_shift_right+0x72>
5e0: 44 89 d0 mov %r10d,%eax
5e3: 45 39 e2 cmp %r12d,%r10d
5e6: 48 8b 04 c6 mov (%rsi,%rax,8),%rax
5ea: 74 5e je 64a <__bitmap_shift_right+0xca>
5ec: 44 89 f1 mov %r14d,%ecx
5ef: 48 d3 e0 shl %cl,%rax
5f2: 44 89 c1 mov %r8d,%ecx
5f5: 45 39 e0 cmp %r12d,%r8d
5f8: 4c 8b 0c ce mov (%rsi,%rcx,8),%r9
5fc: 74 46 je 644 <__bitmap_shift_right+0xc4>
5fe: 89 d1 mov %edx,%ecx
600: 41 83 c0 01 add $0x1,%r8d
604: 41 83 c2 01 add $0x1,%r10d
608: 49 d3 e9 shr %cl,%r9
60b: 49 83 c3 08 add $0x8,%r11
60f: 4c 09 c8 or %r9,%rax
612: 49 89 43 f8 mov %rax,-0x8(%r11)
616: 44 39 c3 cmp %r8d,%ebx
619: 75 ba jne 5d5 <__bitmap_shift_right+0x55>
61b: 45 85 ff test %r15d,%r15d
61e: 74 15 je 635 <__bitmap_shift_right+0xb5>
620: 45 29 fd sub %r15d,%r13d
623: 44 89 fa mov %r15d,%edx
626: 31 f6 xor %esi,%esi
628: 4a 8d 3c ef lea (%rdi,%r13,8),%rdi
62c: 48 c1 e2 03 shl $0x3,%rdx
630: e8 00 00 00 00 callq 635 <__bitmap_shift_right+0xb5> 631: R_X86_64_PC32 memset-0x4
635: 48 83 c4 18 add $0x18,%rsp
639: 5b pop %rbx
63a: 41 5c pop %r12
63c: 41 5d pop %r13
63e: 41 5e pop %r14
640: 41 5f pop %r15
642: 5d pop %rbp
643: c3 retq
644: 4c 23 4d c8 and -0x38(%rbp),%r9
648: eb b4 jmp 5fe <__bitmap_shift_right+0x7e>
64a: 48 23 45 c8 and -0x38(%rbp),%rax
64e: eb 9c jmp 5ec <__bitmap_shift_right+0x6c>

0000000000000650 <__bitmap_shift_left>:
650: 41 89 d2 mov %edx,%r10d
653: 55 push %rbp
654: 89 c8 mov %ecx,%eax
656: 41 c1 ea 06 shr $0x6,%r10d
65a: 48 83 c0 3f add $0x3f,%rax
65e: 45 89 d0 mov %r10d,%r8d
661: 48 89 e5 mov %rsp,%rbp
664: 48 c1 e8 06 shr $0x6,%rax
668: 41 54 push %r12
66a: 83 e2 3f and $0x3f,%edx
66d: 53 push %rbx
66e: 41 f7 d0 not %r8d
671: bb 40 00 00 00 mov $0x40,%ebx
676: 41 0f 95 c3 setne %r11b
67a: 29 d3 sub %edx,%ebx
67c: 44 01 c0 add %r8d,%eax
67f: 79 2d jns 6ae <__bitmap_shift_left+0x5e>
681: eb 3b jmp 6be <__bitmap_shift_left+0x6e>
683: 45 84 db test %r11b,%r11b
686: 74 31 je 6b9 <__bitmap_shift_left+0x69>
688: 4e 8b 44 0e f8 mov -0x8(%rsi,%r9,1),%r8
68d: 89 d9 mov %ebx,%ecx
68f: 49 d3 e8 shr %cl,%r8
692: 4e 8b 0c 0e mov (%rsi,%r9,1),%r9
696: 89 d1 mov %edx,%ecx
698: 46 8d 24 10 lea (%rax,%r10,1),%r12d
69c: 83 e8 01 sub $0x1,%eax
69f: 49 d3 e1 shl %cl,%r9
6a2: 4d 09 c8 or %r9,%r8
6a5: 83 f8 ff cmp $0xffffffff,%eax
6a8: 4e 89 04 e7 mov %r8,(%rdi,%r12,8)
6ac: 74 10 je 6be <__bitmap_shift_left+0x6e>
6ae: 4c 63 c8 movslq %eax,%r9
6b1: 49 c1 e1 03 shl $0x3,%r9
6b5: 85 c0 test %eax,%eax
6b7: 7f ca jg 683 <__bitmap_shift_left+0x33>
6b9: 45 31 c0 xor %r8d,%r8d
6bc: eb d4 jmp 692 <__bitmap_shift_left+0x42>
6be: 45 85 d2 test %r10d,%r10d
6c1: 74 0e je 6d1 <__bitmap_shift_left+0x81>
6c3: 44 89 d2 mov %r10d,%edx
6c6: 31 f6 xor %esi,%esi
6c8: 48 c1 e2 03 shl $0x3,%rdx
6cc: e8 00 00 00 00 callq 6d1 <__bitmap_shift_left+0x81> 6cd: R_X86_64_PC32 memset-0x4
6d1: 5b pop %rbx
6d2: 41 5c pop %r12
6d4: 5d pop %rbp
6d5: c3 retq
6d6: 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:0x0(%rax,%rax,1)

00000000000006e0 <__bitmap_parselist>:
6e0: 55 push %rbp
6e1: 48 89 e5 mov %rsp,%rbp
6e4: 41 57 push %r15
6e6: 41 56 push %r14
6e8: 41 55 push %r13
6ea: 41 54 push %r12
6ec: 41 89 d5 mov %edx,%r13d
6ef: 53 push %rbx
6f0: 44 89 c2 mov %r8d,%edx
6f3: 49 89 fc mov %rdi,%r12
6f6: 89 f3 mov %esi,%ebx
6f8: 48 89 cf mov %rcx,%rdi
6fb: 31 f6 xor %esi,%esi
6fd: 48 83 ec 18 sub $0x18,%rsp
701: 89 55 cc mov %edx,-0x34(%rbp)
704: 48 83 c2 3f add $0x3f,%rdx
708: 48 c1 ea 06 shr $0x6,%rdx
70c: 48 89 4d c0 mov %rcx,-0x40(%rbp)
710: 48 c1 e2 03 shl $0x3,%rdx
714: e8 00 00 00 00 callq 719 <__bitmap_parselist+0x39> 715: R_X86_64_PC32 memset-0x4
719: 4d 89 e0 mov %r12,%r8
71c: 31 ff xor %edi,%edi
71e: 45 31 c9 xor %r9d,%r9d
721: 85 db test %ebx,%ebx
723: 0f 84 43 01 00 00 je 86c <__bitmap_parselist+0x18c>
729: 45 31 f6 xor %r14d,%r14d
72c: 41 bb 01 00 00 00 mov $0x1,%r11d
732: 31 c9 xor %ecx,%ecx
734: 31 f6 xor %esi,%esi
736: 45 31 ff xor %r15d,%r15d
739: e9 89 00 00 00 jmpq 7c7 <__bitmap_parselist+0xe7>
73e: 4d 8d 50 01 lea 0x1(%r8),%r10
742: 44 89 fa mov %r15d,%edx
745: 90 nop
746: 90 nop
747: 90 nop
748: 41 8a 00 mov (%r8),%al
74b: 90 nop
74c: 90 nop
74d: 90 nop
74e: 85 d2 test %edx,%edx
750: 0f be c0 movsbl %al,%eax
753: 0f 85 f7 00 00 00 jne 850 <__bitmap_parselist+0x170>
759: 4d 89 d0 mov %r10,%r8
75c: 0f b6 d0 movzbl %al,%edx
75f: 83 eb 01 sub $0x1,%ebx
762: 0f b6 92 00 00 00 00 movzbl 0x0(%rdx),%edx 765: R_X86_64_32S _ctype
769: f6 c2 20 test $0x20,%dl
76c: 75 6d jne 7db <__bitmap_parselist+0xfb>
76e: 85 c0 test %eax,%eax
770: 74 16 je 788 <__bitmap_parselist+0xa8>
772: 85 ff test %edi,%edi
774: 74 12 je 788 <__bitmap_parselist+0xa8>
776: 45 0f b6 c9 movzbl %r9b,%r9d
77a: 41 f6 81 00 00 00 00 20 testb $0x20,0x0(%r9) 77d: R_X86_64_32S _ctype
782: 0f 85 b4 00 00 00 jne 83c <__bitmap_parselist+0x15c>
788: 83 f8 2c cmp $0x2c,%eax
78b: 0f 84 d3 00 00 00 je 864 <__bitmap_parselist+0x184>
791: 85 c0 test %eax,%eax
793: 0f 84 cb 00 00 00 je 864 <__bitmap_parselist+0x184>
799: 83 f8 2d cmp $0x2d,%eax
79c: 0f 84 82 00 00 00 je 824 <__bitmap_parselist+0x144>
7a2: 83 e2 04 and $0x4,%edx
7a5: 0f 84 91 00 00 00 je 83c <__bitmap_parselist+0x15c>
7ab: 8d 14 89 lea (%rcx,%rcx,4),%edx
7ae: 41 89 c1 mov %eax,%r9d
7b1: 8d 4c 12 d0 lea -0x30(%rdx,%rdx,1),%ecx
7b5: 01 c1 add %eax,%ecx
7b7: 45 85 f6 test %r14d,%r14d
7ba: 0f 44 f1 cmove %ecx,%esi
7bd: 83 c7 01 add $0x1,%edi
7c0: 45 31 db xor %r11d,%r11d
7c3: 85 db test %ebx,%ebx
7c5: 74 1b je 7e2 <__bitmap_parselist+0x102>
7c7: 45 85 ed test %r13d,%r13d
7ca: 0f 85 6e ff ff ff jne 73e <__bitmap_parselist+0x5e>
7d0: 41 0f be 04 24 movsbl (%r12),%eax
7d5: 49 83 c4 01 add $0x1,%r12
7d9: eb 81 jmp 75c <__bitmap_parselist+0x7c>
7db: 85 db test %ebx,%ebx
7dd: 41 89 c1 mov %eax,%r9d
7e0: 75 e5 jne 7c7 <__bitmap_parselist+0xe7>
7e2: 39 f1 cmp %esi,%ecx
7e4: 72 56 jb 83c <__bitmap_parselist+0x15c>
7e6: 39 4d cc cmp %ecx,-0x34(%rbp)
7e9: 0f 86 88 00 00 00 jbe 877 <__bitmap_parselist+0x197>
7ef: 45 85 db test %r11d,%r11d
7f2: 75 12 jne 806 <__bitmap_parselist+0x126>
7f4: 48 8b 45 c0 mov -0x40(%rbp),%rax
7f8: 89 f2 mov %esi,%edx
7fa: f0 48 0f ab 10 lock bts %rdx,(%rax)
7ff: 83 c6 01 add $0x1,%esi
802: 39 ce cmp %ecx,%esi
804: 76 f2 jbe 7f8 <__bitmap_parselist+0x118>
806: 41 83 f9 2c cmp $0x2c,%r9d
80a: 41 b9 2c 00 00 00 mov $0x2c,%r9d
810: 0f 94 c2 sete %dl
813: 85 db test %ebx,%ebx
815: 0f 95 c0 setne %al
818: 84 c2 test %al,%dl
81a: 0f 85 01 ff ff ff jne 721 <__bitmap_parselist+0x41>
820: 31 c0 xor %eax,%eax
822: eb 1d jmp 841 <__bitmap_parselist+0x161>
824: 45 09 de or %r11d,%r14d
827: 75 13 jne 83c <__bitmap_parselist+0x15c>
829: 41 b9 2d 00 00 00 mov $0x2d,%r9d
82f: 41 be 01 00 00 00 mov $0x1,%r14d
835: 45 31 db xor %r11d,%r11d
838: 31 c9 xor %ecx,%ecx
83a: eb 87 jmp 7c3 <__bitmap_parselist+0xe3>
83c: b8 ea ff ff ff mov $0xffffffea,%eax
841: 48 83 c4 18 add $0x18,%rsp
845: 5b pop %rbx
846: 41 5c pop %r12
848: 41 5d pop %r13
84a: 41 5e pop %r14
84c: 41 5f pop %r15
84e: 5d pop %rbp
84f: c3 retq
850: 48 83 c4 18 add $0x18,%rsp
854: b8 f2 ff ff ff mov $0xfffffff2,%eax
859: 5b pop %rbx
85a: 41 5c pop %r12
85c: 41 5d pop %r13
85e: 41 5e pop %r14
860: 41 5f pop %r15
862: 5d pop %rbp
863: c3 retq
864: 41 89 c1 mov %eax,%r9d
867: e9 76 ff ff ff jmpq 7e2 <__bitmap_parselist+0x102>
86c: 83 7d cc 01 cmpl $0x1,-0x34(%rbp)
870: 19 c0 sbb %eax,%eax
872: 83 e0 de and $0xffffffde,%eax
875: eb ca jmp 841 <__bitmap_parselist+0x161>
877: b8 de ff ff ff mov $0xffffffde,%eax
87c: eb c3 jmp 841 <__bitmap_parselist+0x161>
87e: 66 90 xchg %ax,%ax

0000000000000880 <bitmap_find_next_zero_area_off>:
880: 55 push %rbp
881: 4c 89 c0 mov %r8,%rax
884: 4d 01 c8 add %r9,%r8
887: 48 f7 d0 not %rax
88a: 48 89 e5 mov %rsp,%rbp
88d: 41 57 push %r15
88f: 41 56 push %r14
891: 41 55 push %r13
893: 41 54 push %r12
895: 41 89 cd mov %ecx,%r13d
898: 53 push %rbx
899: 49 89 fc mov %rdi,%r12
89c: 48 89 f3 mov %rsi,%rbx
89f: 48 83 ec 28 sub $0x28,%rsp
8a3: 4c 89 4d b8 mov %r9,-0x48(%rbp)
8a7: 48 89 45 c0 mov %rax,-0x40(%rbp)
8ab: 4c 89 45 c8 mov %r8,-0x38(%rbp)
8af: eb 17 jmp 8c8 <bitmap_find_next_zero_area_off+0x48>
8b1: 48 89 ca mov %rcx,%rdx
8b4: 4c 89 f6 mov %r14,%rsi
8b7: 4c 89 e7 mov %r12,%rdi
8ba: e8 00 00 00 00 callq 8bf <bitmap_find_next_zero_area_off+0x3f> 8bb: R_X86_64_PC32 find_next_bit-0x4
8bf: 49 39 c6 cmp %rax,%r14
8c2: 76 3d jbe 901 <bitmap_find_next_zero_area_off+0x81>
8c4: 48 8d 50 01 lea 0x1(%rax),%rdx
8c8: 48 89 de mov %rbx,%rsi
8cb: 4c 89 e7 mov %r12,%rdi
8ce: e8 00 00 00 00 callq 8d3 <bitmap_find_next_zero_area_off+0x53> 8cf: R_X86_64_PC32 find_next_zero_bit-0x4
8d3: 48 8b 75 c8 mov -0x38(%rbp),%rsi
8d7: 48 8d 0c 30 lea (%rax,%rsi,1),%rcx
8db: 48 23 4d c0 and -0x40(%rbp),%rcx
8df: 48 2b 4d b8 sub -0x48(%rbp),%rcx
8e3: 4e 8d 34 29 lea (%rcx,%r13,1),%r14
8e7: 49 89 cf mov %rcx,%r15
8ea: 4c 39 f3 cmp %r14,%rbx
8ed: 73 c2 jae 8b1 <bitmap_find_next_zero_area_off+0x31>
8ef: 48 83 c4 28 add $0x28,%rsp
8f3: 4c 89 f0 mov %r14,%rax
8f6: 5b pop %rbx
8f7: 41 5c pop %r12
8f9: 41 5d pop %r13
8fb: 41 5e pop %r14
8fd: 41 5f pop %r15
8ff: 5d pop %rbp
900: c3 retq
901: 48 83 c4 28 add $0x28,%rsp
905: 4c 89 f8 mov %r15,%rax
908: 5b pop %rbx
909: 41 5c pop %r12
90b: 41 5d pop %r13
90d: 41 5e pop %r14
90f: 41 5f pop %r15
911: 5d pop %rbp
912: c3 retq
913: 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000000920 <bitmap_parselist_user>:
920: 41 89 f1 mov %esi,%r9d
923: 65 48 8b 04 25 00 00 00 00 mov %gs:0x0,%rax 928: R_X86_64_32S cpu_tss+0x4
92c: 49 01 f9 add %rdi,%r9
92f: 4c 8b 80 18 c0 ff ff mov -0x3fe8(%rax),%r8
936: b8 f2 ff ff ff mov $0xfffffff2,%eax
93b: 72 1a jb 957 <bitmap_parselist_user+0x37>
93d: 4d 39 c8 cmp %r9,%r8
940: 72 15 jb 957 <bitmap_parselist_user+0x37>
942: 55 push %rbp
943: 41 89 c8 mov %ecx,%r8d
946: 48 89 d1 mov %rdx,%rcx
949: ba 01 00 00 00 mov $0x1,%edx
94e: 48 89 e5 mov %rsp,%rbp
951: e8 8a fd ff ff callq 6e0 <__bitmap_parselist>
956: 5d pop %rbp
957: f3 c3 repz retq
959: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)

0000000000000960 <bitmap_print_to_pagebuf>:
960: 48 8d 86 fe 1f 00 00 lea 0x1ffe(%rsi),%rax
967: 49 89 f1 mov %rsi,%r9
96a: 48 25 00 f0 ff ff and $0xfffffffffffff000,%rax
970: 48 29 f0 sub %rsi,%rax
973: 48 83 f8 01 cmp $0x1,%rax
977: 48 89 c6 mov %rax,%rsi
97a: 7e 32 jle 9ae <bitmap_print_to_pagebuf+0x4e>
97c: 55 push %rbp
97d: 40 84 ff test %dil,%dil
980: 49 89 d0 mov %rdx,%r8
983: 48 89 e5 mov %rsp,%rbp
986: 74 13 je 99b <bitmap_print_to_pagebuf+0x3b>
988: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 98b: R_X86_64_32S .rodata.str1.1
98f: 4c 89 cf mov %r9,%rdi
992: 31 c0 xor %eax,%eax
994: e8 00 00 00 00 callq 999 <bitmap_print_to_pagebuf+0x39> 995: R_X86_64_PC32 scnprintf-0x4
999: 5d pop %rbp
99a: c3 retq
99b: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 99e: R_X86_64_32S .rodata.str1.1+0x7
9a2: 4c 89 cf mov %r9,%rdi
9a5: 31 c0 xor %eax,%eax
9a7: e8 00 00 00 00 callq 9ac <bitmap_print_to_pagebuf+0x4c> 9a8: R_X86_64_PC32 scnprintf-0x4
9ac: 5d pop %rbp
9ad: c3 retq
9ae: 31 c0 xor %eax,%eax
9b0: c3 retq
9b1: 66 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)

00000000000009c0 <bitmap_parselist>:
9c0: 55 push %rbp
9c1: 48 89 e5 mov %rsp,%rbp
9c4: 41 55 push %r13
9c6: 41 54 push %r12
9c8: 53 push %rbx
9c9: 49 89 f4 mov %rsi,%r12
9cc: 48 89 fb mov %rdi,%rbx
9cf: be 0a 00 00 00 mov $0xa,%esi
9d4: 41 89 d5 mov %edx,%r13d
9d7: 48 83 ec 08 sub $0x8,%rsp
9db: e8 00 00 00 00 callq 9e0 <bitmap_parselist+0x20> 9dc: R_X86_64_PC32 strchrnul-0x4
9e0: 48 29 d8 sub %rbx,%rax
9e3: 45 89 e8 mov %r13d,%r8d
9e6: 4c 89 e1 mov %r12,%rcx
9e9: 48 89 df mov %rbx,%rdi
9ec: 48 89 c6 mov %rax,%rsi
9ef: 31 d2 xor %edx,%edx
9f1: e8 ea fc ff ff callq 6e0 <__bitmap_parselist>
9f6: 48 83 c4 08 add $0x8,%rsp
9fa: 5b pop %rbx
9fb: 41 5c pop %r12
9fd: 41 5d pop %r13
9ff: 5d pop %rbp
a00: c3 retq
a01: 66 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000000a10 <bitmap_onto>:
a10: 48 39 f7 cmp %rsi,%rdi
a13: 0f 84 87 00 00 00 je aa0 <bitmap_onto+0x90>
a19: 55 push %rbp
a1a: 48 89 e5 mov %rsp,%rbp
a1d: 41 57 push %r15
a1f: 41 56 push %r14
a21: 41 55 push %r13
a23: 41 54 push %r12
a25: 41 89 cf mov %ecx,%r15d
a28: 53 push %rbx
a29: 49 89 f5 mov %rsi,%r13
a2c: 31 f6 xor %esi,%esi
a2e: 48 89 fb mov %rdi,%rbx
a31: 4d 89 fc mov %r15,%r12
a34: 48 83 ec 18 sub $0x18,%rsp
a38: 48 89 55 c8 mov %rdx,-0x38(%rbp)
a3c: 49 8d 57 3f lea 0x3f(%r15),%rdx
a40: 48 c1 ea 06 shr $0x6,%rdx
a44: 48 c1 e2 03 shl $0x3,%rdx
a48: e8 00 00 00 00 callq a4d <bitmap_onto+0x3d> a49: R_X86_64_PC32 memset-0x4
a4d: 48 8b 7d c8 mov -0x38(%rbp),%rdi
a51: 4c 89 fe mov %r15,%rsi
a54: e8 00 00 00 00 callq a59 <bitmap_onto+0x49> a55: R_X86_64_PC32 find_first_bit-0x4
a59: 41 39 c7 cmp %eax,%r15d
a5c: 89 c2 mov %eax,%edx
a5e: 76 32 jbe a92 <bitmap_onto+0x82>
a60: 45 31 f6 xor %r14d,%r14d
a63: 44 89 f0 mov %r14d,%eax
a66: 49 0f a3 45 00 bt %rax,0x0(%r13)
a6b: 19 c0 sbb %eax,%eax
a6d: 85 c0 test %eax,%eax
a6f: 74 07 je a78 <bitmap_onto+0x68>
a71: 89 d0 mov %edx,%eax
a73: f0 48 0f ab 03 lock bts %rax,(%rbx)
a78: 48 8b 7d c8 mov -0x38(%rbp),%rdi
a7c: 83 c2 01 add $0x1,%edx
a7f: 4c 89 fe mov %r15,%rsi
a82: 41 83 c6 01 add $0x1,%r14d
a86: e8 00 00 00 00 callq a8b <bitmap_onto+0x7b> a87: R_X86_64_PC32 find_next_bit-0x4
a8b: 41 39 c4 cmp %eax,%r12d
a8e: 89 c2 mov %eax,%edx
a90: 77 d1 ja a63 <bitmap_onto+0x53>
a92: 48 83 c4 18 add $0x18,%rsp
a96: 5b pop %rbx
a97: 41 5c pop %r12
a99: 41 5d pop %r13
a9b: 41 5e pop %r14
a9d: 41 5f pop %r15
a9f: 5d pop %rbp
aa0: f3 c3 repz retq
aa2: 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000000ab0 <bitmap_fold>:
ab0: 48 39 f7 cmp %rsi,%rdi
ab3: 74 76 je b2b <bitmap_fold+0x7b>
ab5: 55 push %rbp
ab6: 48 89 e5 mov %rsp,%rbp
ab9: 41 57 push %r15
abb: 41 89 cf mov %ecx,%r15d
abe: 41 56 push %r14
ac0: 41 55 push %r13
ac2: 49 89 f5 mov %rsi,%r13
ac5: 41 54 push %r12
ac7: 41 89 d4 mov %edx,%r12d
aca: 49 8d 57 3f lea 0x3f(%r15),%rdx
ace: 53 push %rbx
acf: 31 f6 xor %esi,%esi
ad1: 48 89 fb mov %rdi,%rbx
ad4: 48 c1 ea 06 shr $0x6,%rdx
ad8: 4d 89 fe mov %r15,%r14
adb: 48 83 ec 08 sub $0x8,%rsp
adf: 48 c1 e2 03 shl $0x3,%rdx
ae3: e8 00 00 00 00 callq ae8 <bitmap_fold+0x38> ae4: R_X86_64_PC32 memset-0x4
ae8: 4c 89 fe mov %r15,%rsi
aeb: 4c 89 ef mov %r13,%rdi
aee: e8 00 00 00 00 callq af3 <bitmap_fold+0x43> aef: R_X86_64_PC32 find_first_bit-0x4
af3: 41 39 c7 cmp %eax,%r15d
af6: 89 c1 mov %eax,%ecx
af8: 76 23 jbe b1d <bitmap_fold+0x6d>
afa: 89 c8 mov %ecx,%eax
afc: 31 d2 xor %edx,%edx
afe: 41 f7 f4 div %r12d
b01: 89 d2 mov %edx,%edx
b03: f0 48 0f ab 13 lock bts %rdx,(%rbx)
b08: 8d 51 01 lea 0x1(%rcx),%edx
b0b: 4c 89 fe mov %r15,%rsi
b0e: 4c 89 ef mov %r13,%rdi
b11: e8 00 00 00 00 callq b16 <bitmap_fold+0x66> b12: R_X86_64_PC32 find_next_bit-0x4
b16: 41 39 c6 cmp %eax,%r14d
b19: 89 c1 mov %eax,%ecx
b1b: 77 dd ja afa <bitmap_fold+0x4a>
b1d: 48 83 c4 08 add $0x8,%rsp
b21: 5b pop %rbx
b22: 41 5c pop %r12
b24: 41 5d pop %r13
b26: 41 5e pop %r14
b28: 41 5f pop %r15
b2a: 5d pop %rbp
b2b: f3 c3 repz retq
b2d: 0f 1f 00 nopl (%rax)

0000000000000b30 <__bitmap_parse>:
b30: 55 push %rbp
b31: 48 89 e5 mov %rsp,%rbp
b34: 41 57 push %r15
b36: 41 56 push %r14
b38: 41 55 push %r13
b3a: 41 54 push %r12
b3c: 41 89 f5 mov %esi,%r13d
b3f: 53 push %rbx
b40: 31 f6 xor %esi,%esi
b42: 45 31 ff xor %r15d,%r15d
b45: 48 83 ec 38 sub $0x38,%rsp
b49: 89 55 c8 mov %edx,-0x38(%rbp)
b4c: 44 89 c2 mov %r8d,%edx
b4f: 89 55 b0 mov %edx,-0x50(%rbp)
b52: 48 83 c2 3f add $0x3f,%rdx
b56: 48 89 7d c0 mov %rdi,-0x40(%rbp)
b5a: 48 c1 ea 06 shr $0x6,%rdx
b5e: 48 89 cf mov %rcx,%rdi
b61: 48 89 4d a8 mov %rcx,-0x58(%rbp)
b65: 48 c1 e2 03 shl $0x3,%rdx
b69: e8 00 00 00 00 callq b6e <__bitmap_parse+0x3e> b6a: R_X86_64_PC32 memset-0x4
b6e: 4c 8b 4d c0 mov -0x40(%rbp),%r9
b72: 44 8b 55 c8 mov -0x38(%rbp),%r10d
b76: 44 89 f8 mov %r15d,%eax
b79: c7 45 b4 00 00 00 00 movl $0x0,-0x4c(%rbp)
b80: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%rbp)
b87: 31 d2 xor %edx,%edx
b89: 41 89 c6 mov %eax,%r14d
b8c: 4d 89 cf mov %r9,%r15
b8f: 45 85 ed test %r13d,%r13d
b92: 0f 84 e8 00 00 00 je c80 <__bitmap_parse+0x150>
b98: 45 31 e4 xor %r12d,%r12d
b9b: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%rbp)
ba2: 44 89 e0 mov %r12d,%eax
ba5: 4d 89 cc mov %r9,%r12
ba8: e9 89 00 00 00 jmpq c36 <__bitmap_parse+0x106>
bad: 49 8d 7f 01 lea 0x1(%r15),%rdi
bb1: 31 c9 xor %ecx,%ecx
bb3: 90 nop
bb4: 90 nop
bb5: 90 nop
bb6: 41 8a 1f mov (%r15),%bl
bb9: 90 nop
bba: 90 nop
bbb: 90 nop
bbc: 85 c9 test %ecx,%ecx
bbe: 0f be db movsbl %bl,%ebx
bc1: 0f 85 cd 00 00 00 jne c94 <__bitmap_parse+0x164>
bc7: 49 89 ff mov %rdi,%r15
bca: 0f b6 cb movzbl %bl,%ecx
bcd: 41 83 ed 01 sub $0x1,%r13d
bd1: 0f b6 89 00 00 00 00 movzbl 0x0(%rcx),%ecx bd4: R_X86_64_32S _ctype
bd8: f6 c1 20 test $0x20,%cl
bdb: 75 52 jne c2f <__bitmap_parse+0xff>
bdd: 85 db test %ebx,%ebx
bdf: 74 15 je bf6 <__bitmap_parse+0xc6>
be1: 45 85 f6 test %r14d,%r14d
be4: 74 10 je bf6 <__bitmap_parse+0xc6>
be6: 0f b6 d2 movzbl %dl,%edx
be9: f6 82 00 00 00 00 20 testb $0x20,0x0(%rdx) beb: R_X86_64_32S _ctype
bf0: 0f 85 8a 00 00 00 jne c80 <__bitmap_parse+0x150>
bf6: 83 fb 2c cmp $0x2c,%ebx
bf9: 74 4f je c4a <__bitmap_parse+0x11a>
bfb: 85 db test %ebx,%ebx
bfd: 74 4b je c4a <__bitmap_parse+0x11a>
bff: 83 e1 44 and $0x44,%ecx
c02: 74 7c je c80 <__bitmap_parse+0x150>
c04: a9 00 00 00 f0 test $0xf0000000,%eax
c09: 0f 85 f3 00 00 00 jne d02 <__bitmap_parse+0x1d2>
c0f: c1 e0 04 shl $0x4,%eax
c12: 89 df mov %ebx,%edi
c14: 44 89 55 c0 mov %r10d,-0x40(%rbp)
c18: 89 45 c8 mov %eax,-0x38(%rbp)
c1b: 41 83 c6 01 add $0x1,%r14d
c1f: e8 00 00 00 00 callq c24 <__bitmap_parse+0xf4> c20: R_X86_64_PC32 hex_to_bin-0x4
c24: 83 45 bc 01 addl $0x1,-0x44(%rbp)
c28: 0b 45 c8 or -0x38(%rbp),%eax
c2b: 44 8b 55 c0 mov -0x40(%rbp),%r10d
c2f: 45 85 ed test %r13d,%r13d
c32: 74 16 je c4a <__bitmap_parse+0x11a>
c34: 89 da mov %ebx,%edx
c36: 45 85 d2 test %r10d,%r10d
c39: 0f 85 6e ff ff ff jne bad <__bitmap_parse+0x7d>
c3f: 41 0f be 1c 24 movsbl (%r12),%ebx
c44: 49 83 c4 01 add $0x1,%r12
c48: eb 80 jmp bca <__bitmap_parse+0x9a>
c4a: 8b 55 bc mov -0x44(%rbp),%edx
c4d: 4d 89 e1 mov %r12,%r9
c50: 41 89 c4 mov %eax,%r12d
c53: 85 d2 test %edx,%edx
c55: 74 29 je c80 <__bitmap_parse+0x150>
c57: 85 c0 test %eax,%eax
c59: 75 4d jne ca8 <__bitmap_parse+0x178>
c5b: 8b 45 b8 mov -0x48(%rbp),%eax
c5e: 85 c0 test %eax,%eax
c60: 75 46 jne ca8 <__bitmap_parse+0x178>
c62: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%rbp)
c69: 83 fb 2c cmp $0x2c,%ebx
c6c: ba 2c 00 00 00 mov $0x2c,%edx
c71: 75 09 jne c7c <__bitmap_parse+0x14c>
c73: 45 85 ed test %r13d,%r13d
c76: 0f 85 13 ff ff ff jne b8f <__bitmap_parse+0x5f>
c7c: 31 c0 xor %eax,%eax
c7e: eb 05 jmp c85 <__bitmap_parse+0x155>
c80: b8 ea ff ff ff mov $0xffffffea,%eax
c85: 48 83 c4 38 add $0x38,%rsp
c89: 5b pop %rbx
c8a: 41 5c pop %r12
c8c: 41 5d pop %r13
c8e: 41 5e pop %r14
c90: 41 5f pop %r15
c92: 5d pop %rbp
c93: c3 retq
c94: 48 83 c4 38 add $0x38,%rsp
c98: b8 f2 ff ff ff mov $0xfffffff2,%eax
c9d: 5b pop %rbx
c9e: 41 5c pop %r12
ca0: 41 5d pop %r13
ca2: 41 5e pop %r14
ca4: 41 5f pop %r15
ca6: 5d pop %rbp
ca7: c3 retq
ca8: 48 8b 7d a8 mov -0x58(%rbp),%rdi
cac: 8b 4d b0 mov -0x50(%rbp),%ecx
caf: ba 20 00 00 00 mov $0x20,%edx
cb4: 44 89 55 c0 mov %r10d,-0x40(%rbp)
cb8: 4c 89 4d c8 mov %r9,-0x38(%rbp)
cbc: 48 89 fe mov %rdi,%rsi
cbf: e8 00 00 00 00 callq cc4 <__bitmap_parse+0x194> cc0: R_X86_64_PC32 __bitmap_shift_left-0x4
cc4: 48 8b 7d a8 mov -0x58(%rbp),%rdi
cc8: 83 45 b8 01 addl $0x1,-0x48(%rbp)
ccc: 44 89 e0 mov %r12d,%eax
ccf: 4c 8b 4d c8 mov -0x38(%rbp),%r9
cd3: 44 8b 55 c0 mov -0x40(%rbp),%r10d
cd7: 48 09 07 or %rax,(%rdi)
cda: b8 20 00 00 00 mov $0x20,%eax
cdf: 8b 7d b8 mov -0x48(%rbp),%edi
ce2: 83 ff 01 cmp $0x1,%edi
ce5: 75 0c jne cf3 <__bitmap_parse+0x1c3>
ce7: b8 ff ff ff ff mov $0xffffffff,%eax
cec: 41 0f bd c4 bsr %r12d,%eax
cf0: 83 c0 01 add $0x1,%eax
cf3: 01 45 b4 add %eax,-0x4c(%rbp)
cf6: 8b 7d b4 mov -0x4c(%rbp),%edi
cf9: 39 7d b0 cmp %edi,-0x50(%rbp)
cfc: 0f 8d 67 ff ff ff jge c69 <__bitmap_parse+0x139>
d02: 48 83 c4 38 add $0x38,%rsp
d06: b8 b5 ff ff ff mov $0xffffffb5,%eax
d0b: 5b pop %rbx
d0c: 41 5c pop %r12
d0e: 41 5d pop %r13
d10: 41 5e pop %r14
d12: 41 5f pop %r15
d14: 5d pop %rbp
d15: c3 retq
d16: 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:0x0(%rax,%rax,1)

0000000000000d20 <bitmap_parse_user>:
d20: 41 89 f1 mov %esi,%r9d
d23: 65 48 8b 04 25 00 00 00 00 mov %gs:0x0,%rax d28: R_X86_64_32S cpu_tss+0x4
d2c: 49 01 f9 add %rdi,%r9
d2f: 4c 8b 80 18 c0 ff ff mov -0x3fe8(%rax),%r8
d36: b8 f2 ff ff ff mov $0xfffffff2,%eax
d3b: 72 1a jb d57 <bitmap_parse_user+0x37>
d3d: 4d 39 c8 cmp %r9,%r8
d40: 72 15 jb d57 <bitmap_parse_user+0x37>
d42: 55 push %rbp
d43: 41 89 c8 mov %ecx,%r8d
d46: 48 89 d1 mov %rdx,%rcx
d49: ba 01 00 00 00 mov $0x1,%edx
d4e: 48 89 e5 mov %rsp,%rbp
d51: e8 00 00 00 00 callq d56 <bitmap_parse_user+0x36> d52: R_X86_64_PC32 __bitmap_parse-0x4
d56: 5d pop %rbp
d57: f3 c3 repz retq
d59: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)

0000000000000d60 <__bitmap_weight>:
d60: 89 f1 mov %esi,%ecx
d62: 55 push %rbp
d63: 49 89 fa mov %rdi,%r10
d66: c1 e9 06 shr $0x6,%ecx
d69: 85 c9 test %ecx,%ecx
d6b: 48 89 e5 mov %rsp,%rbp
d6e: 74 52 je dc2 <__bitmap_weight+0x62>
d70: 8d 41 ff lea -0x1(%rcx),%eax
d73: 48 89 fa mov %rdi,%rdx
d76: 45 31 c0 xor %r8d,%r8d
d79: 4c 8d 0c c5 08 00 00 00 lea 0x8(,%rax,8),%r9
d81: 49 01 f9 add %rdi,%r9
d84: 48 8b 3a mov (%rdx),%rdi
d87: 48 83 c2 08 add $0x8,%rdx
d8b: e8 00 00 00 00 callq d90 <__bitmap_weight+0x30> d8c: R_X86_64_PC32 __sw_hweight64-0x4
d90: 41 01 c0 add %eax,%r8d
d93: 4c 39 ca cmp %r9,%rdx
d96: 75 ec jne d84 <__bitmap_weight+0x24>
d98: 40 f6 c6 3f test $0x3f,%sil
d9c: 44 89 c0 mov %r8d,%eax
d9f: 74 1f je dc0 <__bitmap_weight+0x60>
da1: f7 de neg %esi
da3: 89 ca mov %ecx,%edx
da5: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax
dac: 89 f1 mov %esi,%ecx
dae: 48 d3 e8 shr %cl,%rax
db1: 49 23 04 d2 and (%r10,%rdx,8),%rax
db5: 48 89 c7 mov %rax,%rdi
db8: e8 00 00 00 00 callq dbd <__bitmap_weight+0x5d> db9: R_X86_64_PC32 __sw_hweight64-0x4
dbd: 44 01 c0 add %r8d,%eax
dc0: 5d pop %rbp
dc1: c3 retq
dc2: 85 f6 test %esi,%esi
dc4: 74 19 je ddf <__bitmap_weight+0x7f>
dc6: f7 de neg %esi
dc8: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax
dcf: 45 31 c0 xor %r8d,%r8d
dd2: 89 f1 mov %esi,%ecx
dd4: 48 d3 e8 shr %cl,%rax
dd7: 49 23 02 and (%r10),%rax
dda: 48 89 c7 mov %rax,%rdi
ddd: eb d9 jmp db8 <__bitmap_weight+0x58>
ddf: 31 c0 xor %eax,%eax
de1: 5d pop %rbp
de2: c3 retq
de3: 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000000df0 <bitmap_pos_to_ord>:
df0: 39 d6 cmp %edx,%esi
df2: 73 17 jae e0b <bitmap_pos_to_ord+0x1b>
df4: 89 f0 mov %esi,%eax
df6: 48 0f a3 07 bt %rax,(%rdi)
dfa: 19 c0 sbb %eax,%eax
dfc: 85 c0 test %eax,%eax
dfe: 74 0b je e0b <bitmap_pos_to_ord+0x1b>
e00: 55 push %rbp
e01: 48 89 e5 mov %rsp,%rbp
e04: e8 00 00 00 00 callq e09 <bitmap_pos_to_ord+0x19> e05: R_X86_64_PC32 __bitmap_weight-0x4
e09: 5d pop %rbp
e0a: c3 retq
e0b: b8 ff ff ff ff mov $0xffffffff,%eax
e10: c3 retq
e11: 66 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 data32 data32 data32 data32 data32 nopw %cs:0x0(%rax,%rax,1)

0000000000000e20 <bitmap_ord_to_pos>:
e20: 55 push %rbp
e21: 48 89 e5 mov %rsp,%rbp
e24: 41 56 push %r14
e26: 41 55 push %r13
e28: 41 54 push %r12
e2a: 41 89 d4 mov %edx,%r12d
e2d: 53 push %rbx
e2e: 41 89 f6 mov %esi,%r14d
e31: 4c 89 e6 mov %r12,%rsi
e34: 49 89 fd mov %rdi,%r13
e37: e8 00 00 00 00 callq e3c <bitmap_ord_to_pos+0x1c> e38: R_X86_64_PC32 find_first_bit-0x4
e3c: 41 39 c4 cmp %eax,%r12d
e3f: 4c 89 e3 mov %r12,%rbx
e42: 89 c1 mov %eax,%ecx
e44: 77 1a ja e60 <bitmap_ord_to_pos+0x40>
e46: eb 1d jmp e65 <bitmap_ord_to_pos+0x45>
e48: 8d 51 01 lea 0x1(%rcx),%edx
e4b: 4c 89 e6 mov %r12,%rsi
e4e: 4c 89 ef mov %r13,%rdi
e51: 41 83 ee 01 sub $0x1,%r14d
e55: e8 00 00 00 00 callq e5a <bitmap_ord_to_pos+0x3a> e56: R_X86_64_PC32 find_next_bit-0x4
e5a: 39 c3 cmp %eax,%ebx
e5c: 89 c1 mov %eax,%ecx
e5e: 76 05 jbe e65 <bitmap_ord_to_pos+0x45>
e60: 45 85 f6 test %r14d,%r14d
e63: 75 e3 jne e48 <bitmap_ord_to_pos+0x28>
e65: 5b pop %rbx
e66: 89 c8 mov %ecx,%eax
e68: 41 5c pop %r12
e6a: 41 5d pop %r13
e6c: 41 5e pop %r14
e6e: 5d pop %rbp
e6f: c3 retq

0000000000000e70 <bitmap_remap>:
e70: 48 39 f7 cmp %rsi,%rdi
e73: 0f 84 cd 00 00 00 je f46 <bitmap_remap+0xd6>
e79: 55 push %rbp
e7a: 48 89 e5 mov %rsp,%rbp
e7d: 41 57 push %r15
e7f: 41 56 push %r14
e81: 41 55 push %r13
e83: 41 54 push %r12
e85: 45 89 c7 mov %r8d,%r15d
e88: 53 push %rbx
e89: 49 89 ce mov %rcx,%r14
e8c: 49 89 f5 mov %rsi,%r13
e8f: 31 f6 xor %esi,%esi
e91: 49 89 fc mov %rdi,%r12
e94: 4c 89 fb mov %r15,%rbx
e97: 48 83 ec 28 sub $0x28,%rsp
e9b: 48 89 55 c8 mov %rdx,-0x38(%rbp)
e9f: 49 8d 57 3f lea 0x3f(%r15),%rdx
ea3: 48 89 4d b8 mov %rcx,-0x48(%rbp)
ea7: 48 c1 ea 06 shr $0x6,%rdx
eab: 48 c1 e2 03 shl $0x3,%rdx
eaf: e8 00 00 00 00 callq eb4 <bitmap_remap+0x44> eb0: R_X86_64_PC32 memset-0x4
eb4: 4c 89 f7 mov %r14,%rdi
eb7: 44 89 fe mov %r15d,%esi
eba: e8 00 00 00 00 callq ebf <bitmap_remap+0x4f> ebb: R_X86_64_PC32 __bitmap_weight-0x4
ebf: 4c 89 fe mov %r15,%rsi
ec2: 4c 89 ef mov %r13,%rdi
ec5: 89 45 c0 mov %eax,-0x40(%rbp)
ec8: e8 00 00 00 00 callq ecd <bitmap_remap+0x5d> ec9: R_X86_64_PC32 find_first_bit-0x4
ecd: 41 39 c7 cmp %eax,%r15d
ed0: 41 89 c6 mov %eax,%r14d
ed3: 76 63 jbe f38 <bitmap_remap+0xc8>
ed5: 8b 45 c0 mov -0x40(%rbp),%eax
ed8: 85 c0 test %eax,%eax
eda: 0f 94 45 c7 sete -0x39(%rbp)
ede: eb 1f jmp eff <bitmap_remap+0x8f>
ee0: 44 89 f0 mov %r14d,%eax
ee3: f0 49 0f ab 04 24 lock bts %rax,(%r12)
ee9: 41 8d 56 01 lea 0x1(%r14),%edx
eed: 4c 89 fe mov %r15,%rsi
ef0: 4c 89 ef mov %r13,%rdi
ef3: e8 00 00 00 00 callq ef8 <bitmap_remap+0x88> ef4: R_X86_64_PC32 find_next_bit-0x4
ef8: 39 c3 cmp %eax,%ebx
efa: 41 89 c6 mov %eax,%r14d
efd: 76 39 jbe f38 <bitmap_remap+0xc8>
eff: 48 8b 7d c8 mov -0x38(%rbp),%rdi
f03: 89 da mov %ebx,%edx
f05: 44 89 f6 mov %r14d,%esi
f08: e8 e3 fe ff ff callq df0 <bitmap_pos_to_ord>
f0d: 89 c2 mov %eax,%edx
f0f: c1 ea 1f shr $0x1f,%edx
f12: 84 d2 test %dl,%dl
f14: 75 ca jne ee0 <bitmap_remap+0x70>
f16: 80 7d c7 00 cmpb $0x0,-0x39(%rbp)
f1a: 75 c4 jne ee0 <bitmap_remap+0x70>
f1c: 31 d2 xor %edx,%edx
f1e: 48 8b 7d b8 mov -0x48(%rbp),%rdi
f22: f7 75 c0 divl -0x40(%rbp)
f25: 89 d6 mov %edx,%esi
f27: 89 da mov %ebx,%edx
f29: e8 00 00 00 00 callq f2e <bitmap_remap+0xbe> f2a: R_X86_64_PC32 bitmap_ord_to_pos-0x4
f2e: 89 c0 mov %eax,%eax
f30: f0 49 0f ab 04 24 lock bts %rax,(%r12)
f36: eb b1 jmp ee9 <bitmap_remap+0x79>
f38: 48 83 c4 28 add $0x28,%rsp
f3c: 5b pop %rbx
f3d: 41 5c pop %r12
f3f: 41 5d pop %r13
f41: 41 5e pop %r14
f43: 41 5f pop %r15
f45: 5d pop %rbp
f46: f3 c3 repz retq
f48: 0f 1f 84 00 00 00 00 00 nopl 0x0(%rax,%rax,1)

0000000000000f50 <bitmap_bitremap>:
f50: 55 push %rbp
f51: 48 89 e5 mov %rsp,%rbp
f54: 41 57 push %r15
f56: 41 56 push %r14
f58: 41 55 push %r13
f5a: 41 54 push %r12
f5c: 49 89 f7 mov %rsi,%r15
f5f: 53 push %rbx
f60: 41 89 cc mov %ecx,%r12d
f63: 89 ce mov %ecx,%esi
f65: 89 fb mov %edi,%ebx
f67: 48 89 d7 mov %rdx,%rdi
f6a: 49 89 d6 mov %rdx,%r14
f6d: 48 83 ec 08 sub $0x8,%rsp
f71: e8 00 00 00 00 callq f76 <bitmap_bitremap+0x26> f72: R_X86_64_PC32 __bitmap_weight-0x4
f76: 44 89 e2 mov %r12d,%edx
f79: 41 89 c5 mov %eax,%r13d
f7c: 89 de mov %ebx,%esi
f7e: 4c 89 ff mov %r15,%rdi
f81: e8 6a fe ff ff callq df0 <bitmap_pos_to_ord>
f86: 45 85 ed test %r13d,%r13d
f89: 74 2b je fb6 <bitmap_bitremap+0x66>
f8b: 89 c6 mov %eax,%esi
f8d: c1 e8 1f shr $0x1f,%eax
f90: 84 c0 test %al,%al
f92: 75 22 jne fb6 <bitmap_bitremap+0x66>
f94: 89 f0 mov %esi,%eax
f96: 4c 89 f7 mov %r14,%rdi
f99: 99 cltd
f9a: 41 f7 fd idiv %r13d
f9d: 89 d6 mov %edx,%esi
f9f: 44 89 e2 mov %r12d,%edx
fa2: e8 00 00 00 00 callq fa7 <bitmap_bitremap+0x57> fa3: R_X86_64_PC32 bitmap_ord_to_pos-0x4
fa7: 48 83 c4 08 add $0x8,%rsp
fab: 5b pop %rbx
fac: 41 5c pop %r12
fae: 41 5d pop %r13
fb0: 41 5e pop %r14
fb2: 41 5f pop %r15
fb4: 5d pop %rbp
fb5: c3 retq
fb6: 48 83 c4 08 add $0x8,%rsp
fba: 89 d8 mov %ebx,%eax
fbc: 5b pop %rbx
fbd: 41 5c pop %r12
fbf: 41 5d pop %r13
fc1: 41 5e pop %r14
fc3: 41 5f pop %r15
fc5: 5d pop %rbp
fc6: c3 retq

Disassembly of section .altinstr_replacement:

0000000000000000 <.altinstr_replacement>:
0: 0f 01 (bad)
2: cb lret
3: 0f 01 (bad)
5: ca 0f 01 lret $0x10f
8: cb lret
9: 0f 01 (bad)
b: ca f3 48 lret $0x48f3
e: 0f b8 (bad)
10: c7 (bad)
11: f3 48 0f b8 c7 popcnt %rdi,%rax

Disassembly of section .fixup:

0000000000000000 <.fixup>:
0: ba f2 ff ff ff mov $0xfffffff2,%edx
5: 30 c0 xor %al,%al
7: e9 00 00 00 00 jmpq c <.fixup+0xc> 8: R_X86_64_PC32 .text+0x747
c: b9 f2 ff ff ff mov $0xfffffff2,%ecx
11: 30 db xor %bl,%bl
13: e9 00 00 00 00 jmpq 18 <__kstrtab_bitmap_release_region+0x1> 14: R_X86_64_PC32 .text+0xbb5
Behan Webster (19):
kbuild-clang-detect
kbuild, LLVMLinux: Add better clang cross build support
kbuild, LLVMLinux: Add more compiler options for clang
kbuild, LLVMLinux: Fix asm-offset generation to work with clang
mpi, LLVMLinux: Fix ASM for clang in mpi
mpi, LLVMLinux: Remove use of extern inline from lib/mpi
mpi, LLVMLinux: Don't use __attribute__ ((mode(QI))) for lib/mpi
mpi, LLVMLinux: Remove unused headers from mpi-internal.h
md, sysfs, LLVMLinux: Remove nested function from bcache sysfs
scsi, megaraid, sas, LLVMLinux: Remove inline
DO-NOT-UPSTREAM scsi, osd, LLVMLinux: Remove __weak attribute
exofs, LLVMLinux: Remove VLAIS from exofs
md, raid10, LLVMLinux: Remove VLAIS from raid10 driver
fs, nfs, LLVMLinux: Remove VLAIS from nfs
net, wimax, i2400, LLVMLinux: Remove VLAIS from wimax i2400m driver
Mark inline functions as __maybe_unused
LLVMLinux: use -Oz instead of -Os when using clang
makefile-print
kbuild: LLVMLinux: Clang doesn't support the gcc flags set by CONFIG_ARCH_HWEIGHT_CFLAGS

Jan-Simon MÃller (3):
x86: LLVMLinux: Add option for clang in export of memcpy.
WORKAROUND DO-NOT-UPSTREAM x86, boot: Work around clang PR18415.
Revert "x86: Align jump targets to 1-byte boundaries"

Mark Charlebois (3):
Kbuild: LLVMLinux: Disable the use of the Integrated Assembler when compiling with Clang
fs, LLVMLinux: Remove warning from COMPATIBLE_IOCTL
kbuild, LLVMLinux: Add -Werror to cc-option to support clang

Sedat Dilek (2):
Revert "ppp: fix device unregistration upon netns deletion"
Merge branch 'for-4.2/net-fixes' into 4.2.0-2-llvmlinux-small

VinÃcius Tinti (3):
kbuild: LLVMLinux: Add support to generate LLVM bitcode files
apparmor: LLVMLinux: Remove VLAIS
DO-NOT-UPSTREAM xen, LLVMLinux: Remove VLAIS from xen mmu

.gitignore | 1 +
Kbuild | 8 ++--
Makefile | 59 +++++++++++++++++------
arch/x86/Makefile | 6 ---
arch/x86/boot/memory.c | 7 ++-
arch/x86/boot/string.h | 2 +
arch/x86/um/ksyms.c | 2 +-
arch/x86/xen/mmu.c | 35 +++++++-------
drivers/md/bcache/sysfs.c | 10 ++--
drivers/md/raid10.c | 16 +++----
drivers/net/ppp/ppp_generic.c | 78 ++++++++++++++-----------------
drivers/net/wimax/i2400m/fw.c | 2 +-
drivers/scsi/megaraid/megaraid_sas_base.c | 2 +-
fs/compat_ioctl.c | 2 +-
fs/exofs/Kconfig | 2 +-
fs/exofs/super.c | 22 ++++-----
fs/nfs/Kconfig | 2 +-
fs/nfs/objlayout/objio_osd.c | 5 +-
include/linux/compiler-gcc.h | 10 ++--
include/linux/kbuild.h | 6 +--
include/scsi/osd_types.h | 2 +-
lib/Makefile | 2 +
lib/mpi/Makefile | 2 +
lib/mpi/longlong.h | 9 ++--
lib/mpi/mpi-inline.h | 2 +-
lib/mpi/mpi-internal.h | 10 +---
scripts/Kbuild.include | 6 +--
scripts/Makefile.build | 14 ++++++
scripts/mod/Makefile | 8 ++--
security/apparmor/crypto.c | 17 +++----
30 files changed, 188 insertions(+), 161 deletions(-)

diff --git a/.gitignore b/.gitignore
index 4ad4a98b884b..bbd5f34bd5c5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -33,6 +33,7 @@
*.lzo
*.patch
*.gcno
+*.ll
modules.builtin
Module.symvers
*.dwo
diff --git a/Kbuild b/Kbuild
index f55cefd9bf29..0bbb86358942 100644
--- a/Kbuild
+++ b/Kbuild
@@ -8,10 +8,10 @@

# Default sed regexp - multiline due to syntax constraints
define sed-y
- "/^->/{s:->#$.*$:/* \1 */:; \
- s:^->$[^ ]*$ [\$$#]*$[-0-9]*$ $.*$:#define \1 \2 /* \3 */:; \
- s:^->$[^ ]*$ [\$$#]*$[^ ]*$ $.*$:#define \1 \2 /* \3 */:; \
- s:->::; p;}"
+ "/^@->/{s:@->#$.*$:/* \1 */:; \
+ s:^@->$[^ ]*$ [\$$#]*$[-0-9]*$ $.*$:#define \1 \2 /* \3 */:; \
+ s:^@->$[^ ]*$ [\$$#]*$[^ ]*$ $.*$:#define \1 \2 /* \3 */:; \
+ s:@->::; p;}"
endef

# Use filechk to avoid rebuilds when a header changes, but the resulting file
diff --git a/Makefile b/Makefile
index c3615937df38..0e333fd142a1 100644
--- a/Makefile
+++ b/Makefile
@@ -302,7 +302,7 @@ HOSTCXXFLAGS = -O2

ifeq ($(shell $(HOSTCC) -v 2>&1 | grep -c "clang version"), 1)
HOSTCFLAGS += -Wno-unused-value -Wno-unused-parameter \
- -Wno-missing-field-initializers -fno-delete-null-pointer-checks
+ -Wno-missing-field-initializers
endif

# Decide whether to build built-in, modular, or both.
@@ -366,6 +366,26 @@ CFLAGS_KERNEL =
AFLAGS_KERNEL =
CFLAGS_GCOV = -fprofile-arcs -ftest-coverage

+ifeq ($(shell $(CC) -v 2>&1 | grep -c "clang version"), 1)
+COMPILER := clang
+else
+COMPILER := gcc
+endif
+export COMPILER
+
+ifeq ($(COMPILER),clang)
+ifneq ($(CROSS_COMPILE),)
+CLANG_TARGET := -target $(notdir $(CROSS_COMPILE:%-=%))
+GCC_TOOLCHAIN := $(dir $(CROSS_COMPILE))
+endif
+ifneq ($(GCC_TOOLCHAIN),)
+CLANG_GCC_TC := -gcc-toolchain $(GCC_TOOLCHAIN)
+endif
+ifneq ($(CLANG_ENABLE_IA),1)
+CLANG_IA_FLAG = -no-integrated-as
+endif
+CLANG_FLAGS := $(CLANG_TARGET) $(CLANG_GCC_TC) $(CLANG_IA_FLAG)
+endif

# Use USERINCLUDE when you must reference the UAPI directories only.
USERINCLUDE := \
@@ -391,11 +411,11 @@ KBUILD_CFLAGS := -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs \
-fno-strict-aliasing -fno-common \
-Werror-implicit-function-declaration \
-Wno-format-security \
- -std=gnu89
+ -std=gnu89 $(CLANG_FLAGS)

KBUILD_AFLAGS_KERNEL :=
KBUILD_CFLAGS_KERNEL :=
-KBUILD_AFLAGS := -D__ASSEMBLY__
+KBUILD_AFLAGS := -D__ASSEMBLY__ $(CLANG_FLAGS)
KBUILD_AFLAGS_MODULE := -DMODULE
KBUILD_CFLAGS_MODULE := -DMODULE
KBUILD_LDFLAGS_MODULE := -T $(srctree)/scripts/module-common.lds
@@ -604,10 +624,9 @@ ARCH_AFLAGS :=
ARCH_CFLAGS :=
include arch/$(SRCARCH)/Makefile

-KBUILD_CFLAGS += $(call cc-option,-fno-delete-null-pointer-checks,)
-
ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE
-KBUILD_CFLAGS += -Os $(call cc-disable-warning,maybe-uninitialized,)
+KBUILD_CFLAGS += $(call cc-option,-Oz,-Os)
+KBUILD_CFLAGS += $(call cc-disable-warning,maybe-uninitialized,)
else
KBUILD_CFLAGS += -O2
endif
@@ -666,28 +685,26 @@ endif
endif
KBUILD_CFLAGS += $(stackp-flag)

-ifeq ($(shell $(CC) -v 2>&1 | grep -c "clang version"), 1)
-COMPILER := clang
-else
-COMPILER := gcc
-endif
-export COMPILER
-
ifeq ($(COMPILER),clang)
KBUILD_CPPFLAGS += $(call cc-option,-Qunused-arguments,)
-KBUILD_CPPFLAGS += $(call cc-option,-Wno-unknown-warning-option,)
KBUILD_CFLAGS += $(call cc-disable-warning, unused-variable)
KBUILD_CFLAGS += $(call cc-disable-warning, format-invalid-specifier)
KBUILD_CFLAGS += $(call cc-disable-warning, gnu)
+KBUILD_CFLAGS += -Wno-asm-operand-widths
+KBUILD_CFLAGS += -Wno-initializer-overrides
+KBUILD_CFLAGS += -fno-builtin
+
# Quiet clang warning: comparison of unsigned expression < 0 is always false
KBUILD_CFLAGS += $(call cc-disable-warning, tautological-compare)
+
# CLANG uses a _MergedGlobals as optimization, but this breaks modpost, as the
# source of a reference will be _MergedGlobals and not on of the whitelisted names.
# See modpost pattern 2
KBUILD_CFLAGS += $(call cc-option, -mno-global-merge,)
-KBUILD_CFLAGS += $(call cc-option, -fcatch-undefined-behavior)
+
else

+KBUILD_CFLAGS += $(call cc-option,-fno-delete-null-pointer-checks,)
# This warning generated too much noise in a regular build.
# Use make W=1 to enable this warning (see scripts/Makefile.build)
KBUILD_CFLAGS += $(call cc-disable-warning, unused-but-set-variable)
@@ -1263,6 +1280,8 @@ help:
@echo ' (default: $$(INSTALL_MOD_PATH)/lib/firmware)'
@echo ' dir/ - Build all files in dir and below'
@echo ' dir/file.[oisS] - Build specified target only'
+ @echo ' dir/file.ll - Build the LLVM bitcode file'
+ @echo ' (requires compiler support for LLVM bitcode generation)'
@echo ' dir/file.lst - Build specified mixed source/assembly target only'
@echo ' (requires a recent binutils and recent build (System.map))'
@echo ' dir/file.ko - Build module including final link'
@@ -1539,6 +1558,10 @@ endif
$(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@)
%.symtypes: %.c prepare scripts FORCE
$(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@)
+%.ll: %.c prepare scripts FORCE
+ $(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@)
+%.ll: %.S prepare scripts FORCE
+ $(Q)$(MAKE) $(build)=$(build-dir) $(target-dir)$(notdir $@)

# Modules
/: prepare scripts FORCE
@@ -1594,3 +1617,9 @@ FORCE:
# Declare the contents of the .PHONY variable as phony. We keep that
# information in a variable so we can use it in if_changed and friends.
.PHONY: $(PHONY)
+
+print-%:
+ @echo '$*=$($*)'
+ @echo ' origin = $(origin $*)'
+ @echo ' flavor = $(flavor $*)'
+ @echo ' value = $(value $*)'
diff --git a/arch/x86/Makefile b/arch/x86/Makefile
index 118e6debc483..4fea5e90c941 100644
--- a/arch/x86/Makefile
+++ b/arch/x86/Makefile
@@ -77,12 +77,6 @@ else
KBUILD_AFLAGS += -m64
KBUILD_CFLAGS += -m64

- # Align jump targets to 1 byte, not the default 16 bytes:
- KBUILD_CFLAGS += -falign-jumps=1
-
- # Pack loops tightly as well:
- KBUILD_CFLAGS += -falign-loops=1
-
# Don't autogenerate traditional x87 instructions
KBUILD_CFLAGS += $(call cc-option,-mno-80387)
KBUILD_CFLAGS += $(call cc-option,-mno-fp-ret-in-387)
diff --git a/arch/x86/boot/memory.c b/arch/x86/boot/memory.c
index db75d07c3645..7af65046dfad 100644
--- a/arch/x86/boot/memory.c
+++ b/arch/x86/boot/memory.c
@@ -63,8 +63,13 @@ static int detect_memory_e820(void)
count = 0;
break;
}
-
+#ifdef __clang__
+ /* PR18415 */
+ memcpy(desc, &buf, sizeof(*desc));
+ desc++;
+#else
*desc++ = buf;
+#endif
count++;
} while (ireg.ebx && count < ARRAY_SIZE(boot_params.e820_map));

diff --git a/arch/x86/boot/string.h b/arch/x86/boot/string.h
index 725e820602b1..3e07af1d80e3 100644
--- a/arch/x86/boot/string.h
+++ b/arch/x86/boot/string.h
@@ -14,8 +14,10 @@ int memcmp(const void *s1, const void *s2, size_t len);
* Access builtin version by default. If one needs to use optimized version,
* do "undef memcpy" in .c file and link against right string.c
*/
+#ifndef __clang__ /* PR18415 */
#define memcpy(d,s,l) __builtin_memcpy(d,s,l)
#define memset(d,c,l) __builtin_memset(d,c,l)
#define memcmp __builtin_memcmp
+#endif

#endif /* BOOT_STRING_H */
diff --git a/arch/x86/um/ksyms.c b/arch/x86/um/ksyms.c
index 2e8f43ec6214..04aedcecd887 100644
--- a/arch/x86/um/ksyms.c
+++ b/arch/x86/um/ksyms.c
@@ -4,7 +4,7 @@

#ifndef CONFIG_X86_32
/*XXX: we need them because they would be exported by x86_64 */
-#if (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) || __GNUC__ > 4
+#if (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) || __GNUC__ > 4 || defined(__clang__)
EXPORT_SYMBOL(memcpy);
#else
EXPORT_SYMBOL(__memcpy);
diff --git a/arch/x86/xen/mmu.c b/arch/x86/xen/mmu.c
index dd151b2045b0..0c12e370860e 100644
--- a/arch/x86/xen/mmu.c
+++ b/arch/x86/xen/mmu.c
@@ -1271,36 +1271,37 @@ static void xen_flush_tlb_others(const struct cpumask *cpus,
struct mm_struct *mm, unsigned long start,
unsigned long end)
{
- struct {
- struct mmuext_op op;
-#ifdef CONFIG_SMP
- DECLARE_BITMAP(mask, num_processors);
-#else
- DECLARE_BITMAP(mask, NR_CPUS);
-#endif
- } *args;
struct multicall_space mcs;
+ struct mmuext_op *op;
+ struct cpumask *mask;

trace_xen_mmu_flush_tlb_others(cpus, mm, start, end);

if (cpumask_empty(cpus))
return; /* nothing to do */

- mcs = xen_mc_entry(sizeof(*args));
- args = mcs.args;
- args->op.arg2.vcpumask = to_cpumask(args->mask);
+#ifdef CONFIG_SMP
+ mcs = xen_mc_entry(sizeof(struct mmuext_op) + BITS_TO_LONGS(num_processors)*sizeof(unsigned long));
+#else
+ mcs = xen_mc_entry(sizeof(struct mmuext_op) + BITS_TO_LONGS(NR_CPUS)*sizeof(unsigned long));
+#endif
+ /* Extract fields */
+ op = mcs.args;
+ mask = to_cpumask(mcs.args + sizeof(struct mmuext_op));
+
+ op->arg2.vcpumask = mask;

/* Remove us, and any offline CPUS. */
- cpumask_and(to_cpumask(args->mask), cpus, cpu_online_mask);
- cpumask_clear_cpu(smp_processor_id(), to_cpumask(args->mask));
+ cpumask_and(mask, cpus, cpu_online_mask);
+ cpumask_clear_cpu(smp_processor_id(), mask);

- args->op.cmd = MMUEXT_TLB_FLUSH_MULTI;
+ op->cmd = MMUEXT_TLB_FLUSH_MULTI;
if (end != TLB_FLUSH_ALL && (end - start) <= PAGE_SIZE) {
- args->op.cmd = MMUEXT_INVLPG_MULTI;
- args->op.arg1.linear_addr = start;
+ op->cmd = MMUEXT_INVLPG_MULTI;
+ op->arg1.linear_addr = start;
}

- MULTI_mmuext_op(mcs.mc, &args->op, 1, NULL, DOMID_SELF);
+ MULTI_mmuext_op(mcs.mc, op, 1, NULL, DOMID_SELF);

xen_mc_issue(PARAVIRT_LAZY_MMU);
}
diff --git a/drivers/md/bcache/sysfs.c b/drivers/md/bcache/sysfs.c
index b3ff57d61dde..53d8baa741fb 100644
--- a/drivers/md/bcache/sysfs.c
+++ b/drivers/md/bcache/sysfs.c
@@ -731,6 +731,11 @@ static struct attribute *bch_cache_set_internal_files[] = {
};
KTYPE(bch_cache_set_internal);

+static int __bch_cache_cmp(const void *l, const void *r)
+{
+ return *((uint16_t *) r) - *((uint16_t *) l);
+}
+
SHOW(__bch_cache)
{
struct cache *ca = container_of(kobj, struct cache, kobj);
@@ -755,9 +760,6 @@ SHOW(__bch_cache)
CACHE_REPLACEMENT(&ca->sb));

if (attr == &sysfs_priority_stats) {
- int cmp(const void *l, const void *r)
- { return *((uint16_t *) r) - *((uint16_t *) l); }
-
struct bucket *b;
size_t n = ca->sb.nbuckets, i;
size_t unused = 0, available = 0, dirty = 0, meta = 0;
@@ -786,7 +788,7 @@ SHOW(__bch_cache)
p[i] = ca->buckets[i].prio;
mutex_unlock(&ca->set->bucket_lock);

- sort(p, n, sizeof(uint16_t), cmp, NULL);
+ sort(p, n, sizeof(uint16_t), __bch_cache_cmp, NULL);

while (n &&
!cached[n - 1])
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 38c58e19cfce..f3d0859c07da 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -711,11 +711,9 @@ static int raid10_mergeable_bvec(struct mddev *mddev,
max = biovec->bv_len;

if (mddev->merge_check_needed) {
- struct {
- struct r10bio r10_bio;
- struct r10dev devs[conf->copies];
- } on_stack;
- struct r10bio *r10_bio = &on_stack.r10_bio;
+ /* Allocate space for r10bio on stack */
+ u8 r10bio_on_stack[sizeof(struct r10bio) + conf->copies * sizeof(struct r10dev)];
+ struct r10bio *r10_bio = (struct r10bio*) r10bio_on_stack;
int s;
if (conf->reshape_progress != MaxSector) {
/* Cannot give any guidance during reshape */
@@ -4548,11 +4546,9 @@ static int handle_reshape_read_error(struct mddev *mddev,
/* Use sync reads to get the blocks from somewhere else */
int sectors = r10_bio->sectors;
struct r10conf *conf = mddev->private;
- struct {
- struct r10bio r10_bio;
- struct r10dev devs[conf->copies];
- } on_stack;
- struct r10bio *r10b = &on_stack.r10_bio;
+ /* Allocate space for r10bio on stack */
+ u8 r10bio_on_stack[sizeof(struct r10bio) + conf->copies * sizeof(struct r10dev)];
+ struct r10bio *r10b = (struct r10bio *) r10bio_on_stack;
int slot = 0;
int idx = 0;
struct bio_vec *bvec = r10_bio->master_bio->bi_io_vec;
diff --git a/drivers/net/ppp/ppp_generic.c b/drivers/net/ppp/ppp_generic.c
index fa8f5046afe9..9d15566521a7 100644
--- a/drivers/net/ppp/ppp_generic.c
+++ b/drivers/net/ppp/ppp_generic.c
@@ -269,9 +269,9 @@ static void ppp_ccp_peek(struct ppp *ppp, struct sk_buff *skb, int inbound);
static void ppp_ccp_closed(struct ppp *ppp);
static struct compressor *find_compressor(int type);
static void ppp_get_stats(struct ppp *ppp, struct ppp_stats *st);
-static struct ppp *ppp_create_interface(struct net *net, int unit,
- struct file *file, int *retp);
+static struct ppp *ppp_create_interface(struct net *net, int unit, int *retp);
static void init_ppp_file(struct ppp_file *pf, int kind);
+static void ppp_shutdown_interface(struct ppp *ppp);
static void ppp_destroy_interface(struct ppp *ppp);
static struct ppp *ppp_find_unit(struct ppp_net *pn, int unit);
static struct channel *ppp_find_channel(struct ppp_net *pn, int unit);
@@ -392,10 +392,8 @@ static int ppp_release(struct inode *unused, struct file *file)
file->private_data = NULL;
if (pf->kind == INTERFACE) {
ppp = PF_TO_PPP(pf);
- rtnl_lock();
if (file == ppp->owner)
- unregister_netdevice(ppp->dev);
- rtnl_unlock();
+ ppp_shutdown_interface(ppp);
}
if (atomic_dec_and_test(&pf->refcnt)) {
switch (pf->kind) {
@@ -595,10 +593,8 @@ static long ppp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
mutex_lock(&ppp_mutex);
if (pf->kind == INTERFACE) {
ppp = PF_TO_PPP(pf);
- rtnl_lock();
if (file == ppp->owner)
- unregister_netdevice(ppp->dev);
- rtnl_unlock();
+ ppp_shutdown_interface(ppp);
}
if (atomic_long_read(&file->f_count) < 2) {
ppp_release(NULL, file);
@@ -842,10 +838,11 @@ static int ppp_unattached_ioctl(struct net *net, struct ppp_file *pf,
/* Create a new ppp unit */
if (get_user(unit, p))
break;
- ppp = ppp_create_interface(net, unit, file, &err);
+ ppp = ppp_create_interface(net, unit, &err);
if (!ppp)
break;
file->private_data = &ppp->file;
+ ppp->owner = file;
err = -EFAULT;
if (put_user(ppp->file.index, p))
break;
@@ -919,16 +916,6 @@ static __net_init int ppp_init_net(struct net *net)
static __net_exit void ppp_exit_net(struct net *net)
{
struct ppp_net *pn = net_generic(net, ppp_net_id);
- struct ppp *ppp;
- LIST_HEAD(list);
- int id;
-
- rtnl_lock();
- idr_for_each_entry(&pn->units_idr, ppp, id)
- unregister_netdevice_queue(ppp->dev, &list);
-
- unregister_netdevice_many(&list);
- rtnl_unlock();

idr_destroy(&pn->units_idr);
}
@@ -1101,28 +1088,8 @@ static int ppp_dev_init(struct net_device *dev)
return 0;
}

-static void ppp_dev_uninit(struct net_device *dev)
-{
- struct ppp *ppp = netdev_priv(dev);
- struct ppp_net *pn = ppp_pernet(ppp->ppp_net);
-
- ppp_lock(ppp);
- ppp->closing = 1;
- ppp_unlock(ppp);
-
- mutex_lock(&pn->all_ppp_mutex);
- unit_put(&pn->units_idr, ppp->file.index);
- mutex_unlock(&pn->all_ppp_mutex);
-
- ppp->owner = NULL;
-
- ppp->file.dead = 1;
- wake_up_interruptible(&ppp->file.rwait);
-}
-
static const struct net_device_ops ppp_netdev_ops = {
.ndo_init = ppp_dev_init,
- .ndo_uninit = ppp_dev_uninit,
.ndo_start_xmit = ppp_start_xmit,
.ndo_do_ioctl = ppp_net_ioctl,
.ndo_get_stats64 = ppp_get_stats64,
@@ -2700,8 +2667,8 @@ ppp_get_stats(struct ppp *ppp, struct ppp_stats *st)
* or if there is already a unit with the requested number.
* unit == -1 means allocate a new number.
*/
-static struct ppp *ppp_create_interface(struct net *net, int unit,
- struct file *file, int *retp)
+static struct ppp *
+ppp_create_interface(struct net *net, int unit, int *retp)
{
struct ppp *ppp;
struct ppp_net *pn;
@@ -2721,7 +2688,6 @@ static struct ppp *ppp_create_interface(struct net *net, int unit,
ppp->mru = PPP_MRU;
init_ppp_file(&ppp->file, INTERFACE);
ppp->file.hdrlen = PPP_HDRLEN - 2; /* don't count proto bytes */
- ppp->owner = file;
for (i = 0; i < NUM_NP; ++i)
ppp->npmode[i] = NPMODE_PASS;
INIT_LIST_HEAD(&ppp->channels);
@@ -2810,6 +2776,34 @@ init_ppp_file(struct ppp_file *pf, int kind)
}

/*
+ * Take down a ppp interface unit - called when the owning file
+ * (the one that created the unit) is closed or detached.
+ */
+static void ppp_shutdown_interface(struct ppp *ppp)
+{
+ struct ppp_net *pn;
+
+ pn = ppp_pernet(ppp->ppp_net);
+ mutex_lock(&pn->all_ppp_mutex);
+
+ /* This will call dev_close() for us. */
+ ppp_lock(ppp);
+ if (!ppp->closing) {
+ ppp->closing = 1;
+ ppp_unlock(ppp);
+ unregister_netdev(ppp->dev);
+ unit_put(&pn->units_idr, ppp->file.index);
+ } else
+ ppp_unlock(ppp);
+
+ ppp->file.dead = 1;
+ ppp->owner = NULL;
+ wake_up_interruptible(&ppp->file.rwait);
+
+ mutex_unlock(&pn->all_ppp_mutex);
+}
+
+/*
* Free the memory used by a ppp unit. This is only called once
* there are no channels connected to the unit and no file structs
* that reference the unit.
diff --git a/drivers/net/wimax/i2400m/fw.c b/drivers/net/wimax/i2400m/fw.c
index c9c711dcd0e6..a89b5685e68b 100644
--- a/drivers/net/wimax/i2400m/fw.c
+++ b/drivers/net/wimax/i2400m/fw.c
@@ -652,7 +652,7 @@ static int i2400m_download_chunk(struct i2400m *i2400m, const void *chunk,
struct device *dev = i2400m_dev(i2400m);
struct {
struct i2400m_bootrom_header cmd;
- u8 cmd_payload[chunk_len];
+ u8 cmd_payload[];
} __packed *buf;
struct i2400m_bootrom_header ack;

diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 71b884dae27c..8aeb7c72aab8 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -228,7 +228,7 @@ struct megasas_cmd *megasas_get_cmd(struct megasas_instance
* @instance: Adapter soft state
* @cmd: Command packet to be returned to free command pool
*/
-inline void
+void
megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
{
unsigned long flags;
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index 48851f6ea6ec..67ffab2d33b9 100644
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -811,7 +811,7 @@ static int compat_ioctl_preallocate(struct file *file,
*/
#define XFORM(i) (((i) ^ ((i) << 27) ^ ((i) << 17)) & 0xffffffff)

-#define COMPATIBLE_IOCTL(cmd) XFORM(cmd),
+#define COMPATIBLE_IOCTL(cmd) XFORM((u32)cmd),
/* ioctl should not be warned about even if it's not implemented.
Valid reasons to use this:
- It is implemented with ->compat_ioctl on some device, but programs
diff --git a/fs/exofs/Kconfig b/fs/exofs/Kconfig
index 86194b2f799d..492746f9e61b 100644
--- a/fs/exofs/Kconfig
+++ b/fs/exofs/Kconfig
@@ -1,6 +1,6 @@
config EXOFS_FS
tristate "exofs: OSD based file system support"
- depends on SCSI_OSD_ULD
+ depends on SCSI_OSD_ULD && BROKEN
help
EXOFS is a file system that uses an OSD storage device,
as its backing storage.
diff --git a/fs/exofs/super.c b/fs/exofs/super.c
index b795c567b5e1..2357dc538bb7 100644
--- a/fs/exofs/super.c
+++ b/fs/exofs/super.c
@@ -546,27 +546,25 @@ static int exofs_devs_2_odi(struct exofs_dt_device_info *dt_dev,
static int __alloc_dev_table(struct exofs_sb_info *sbi, unsigned numdevs,
struct exofs_dev **peds)
{
- struct __alloc_ore_devs_and_exofs_devs {
- /* Twice bigger table: See exofs_init_comps() and comment at
- * exofs_read_lookup_dev_table()
- */
- struct ore_dev *oreds[numdevs * 2 - 1];
- struct exofs_dev eds[numdevs];
- } *aoded;
+ size_t numoreds = numdevs * 2 - 1;
struct exofs_dev *eds;
unsigned i;

- aoded = kzalloc(sizeof(*aoded), GFP_KERNEL);
- if (unlikely(!aoded)) {
+ /* Twice bigger table: See exofs_init_comps() and comment at
+ * exofs_read_lookup_dev_table()
+ * XXX: why -1?
+ */
+ sbi->oc.ods = kzalloc(numoreds * sizeof(struct ore_dev) +
+ numdevs * sizeof(struct exofs_dev), GFP_KERNEL);
+ if (unlikely(!sbi->oc.ods)) {
EXOFS_ERR("ERROR: failed allocating Device array[%d]\n",
numdevs);
return -ENOMEM;
}

- sbi->oc.ods = aoded->oreds;
- *peds = eds = aoded->eds;
+ *peds = eds = (void *)sbi->oc.ods[numoreds];
for (i = 0; i < numdevs; ++i)
- aoded->oreds[i] = &eds[i].ored;
+ sbi->oc.ods[i] = &eds[i].ored;
return 0;
}

diff --git a/fs/nfs/Kconfig b/fs/nfs/Kconfig
index f31fd0dd92c6..e6ef7b3725db 100644
--- a/fs/nfs/Kconfig
+++ b/fs/nfs/Kconfig
@@ -125,7 +125,7 @@ config PNFS_BLOCK

config PNFS_OBJLAYOUT
tristate
- depends on NFS_V4_1 && SCSI_OSD_ULD
+ depends on NFS_V4_1 && SCSI_OSD_ULD && BROKEN
default NFS_V4

config PNFS_FLEXFILE_LAYOUT
diff --git a/fs/nfs/objlayout/objio_osd.c b/fs/nfs/objlayout/objio_osd.c
index 5aaed363556a..9259037f1cec 100644
--- a/fs/nfs/objlayout/objio_osd.c
+++ b/fs/nfs/objlayout/objio_osd.c
@@ -301,10 +301,11 @@ objio_alloc_io_state(struct pnfs_layout_hdr *pnfs_layout_type, bool is_reading,
int ret;
struct __alloc_objio_state {
struct objio_state objios;
- struct pnfs_osd_ioerr ioerrs[objio_seg->oc.numdevs];
+ struct pnfs_osd_ioerr ioerrs[];
} *aos;

- aos = kzalloc(sizeof(*aos), gfp_flags);
+ aos = kzalloc(sizeof(*aos) + objio_seg->oc.numdevs *
+ sizeof(struct pnfs_osd_ioerr), gfp_flags);
if (unlikely(!aos))
return -ENOMEM;

diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index dfaa7b3e9ae9..929a3f0d2b08 100644
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -70,14 +70,14 @@
*/
#if !defined(CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING) || \
!defined(CONFIG_OPTIMIZE_INLINING) || (__GNUC__ < 4)
-#define inline inline __attribute__((always_inline)) notrace
-#define __inline__ __inline__ __attribute__((always_inline)) notrace
+#define inline inline __attribute__((always_inline)) notrace __maybe_unused
+#define __inline__ __inline__ __attribute__((always_inline)) notrace __maybe_unused
#define __inline __inline __attribute__((always_inline)) notrace
#else
/* A lot of inline functions can cause havoc with function tracing */
-#define inline inline notrace
-#define __inline__ __inline__ notrace
-#define __inline __inline notrace
+#define inline inline notrace __maybe_unused
+#define __inline__ __inline__ notrace __maybe_unused
+#define __inline __inline notrace __maybe_unused
#endif

#define __always_inline inline __attribute__((always_inline))
diff --git a/include/linux/kbuild.h b/include/linux/kbuild.h
index 22a72198c14b..75fa2c3e0e1d 100644
--- a/include/linux/kbuild.h
+++ b/include/linux/kbuild.h
@@ -2,14 +2,14 @@
#define __LINUX_KBUILD_H

#define DEFINE(sym, val) \
- asm volatile("\n->" #sym " %0 " #val : : "i" (val))
+ asm volatile("\n@->" #sym " %0 " #val : : "i" (val))

-#define BLANK() asm volatile("\n->" : : )
+#define BLANK() asm volatile("\n@->" : : )

#define OFFSET(sym, str, mem) \
DEFINE(sym, offsetof(struct str, mem))

#define COMMENT(x) \
- asm volatile("\n->#" x)
+ asm volatile("\n@->#" x)

#endif
diff --git a/include/scsi/osd_types.h b/include/scsi/osd_types.h
index 48e8a165e136..c7ae7211d15d 100644
--- a/include/scsi/osd_types.h
+++ b/include/scsi/osd_types.h
@@ -28,7 +28,7 @@ struct osd_obj_id {
osd_id id;
};

-static const struct __weak osd_obj_id osd_root_object = {0, 0};
+static const struct osd_obj_id osd_root_object __maybe_unused = {0, 0};

struct osd_attr {
u32 attr_page;
diff --git a/lib/Makefile b/lib/Makefile
index 6897b527581a..068188564a6a 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -55,7 +55,9 @@ obj-$(CONFIG_CHECK_SIGNATURE) += check_signature.o
obj-$(CONFIG_DEBUG_LOCKING_API_SELFTESTS) += locking-selftest.o

GCOV_PROFILE_hweight.o := n
+ifneq ($(COMPILER),clang)
CFLAGS_hweight.o = $(subst $(quote),,$(CONFIG_ARCH_HWEIGHT_CFLAGS))
+endif
obj-$(CONFIG_GENERIC_HWEIGHT) += hweight.o

obj-$(CONFIG_BTREE) += btree.o
diff --git a/lib/mpi/Makefile b/lib/mpi/Makefile
index 019a68c90144..d5553f6b9f09 100644
--- a/lib/mpi/Makefile
+++ b/lib/mpi/Makefile
@@ -4,6 +4,8 @@

obj-$(CONFIG_MPILIB) = mpi.o

+CFLAGS_KERNEL += $(call cc-option,-fheinous-gnu-extensions)
+
mpi-y = \
generic_mpih-lshift.o \
generic_mpih-mul1.o \
diff --git a/lib/mpi/longlong.h b/lib/mpi/longlong.h
index a89d041592c8..d4477621f1eb 100644
--- a/lib/mpi/longlong.h
+++ b/lib/mpi/longlong.h
@@ -193,8 +193,7 @@ extern UDItype __udiv_qrnnd(UDItype *, UDItype, UDItype, UDItype);
"rI" ((USItype)(bl)))
#if defined __ARM_ARCH_2__ || defined __ARM_ARCH_3__
#define umul_ppmm(xh, xl, a, b) \
- __asm__ ("%@ Inlined umul_ppmm\n" \
- "mov %|r0, %2, lsr #16 @ AAAA\n" \
+ __asm__ ("mov %|r0, %2, lsr #16 @ AAAA\n" \
"mov %|r2, %3, lsr #16 @ BBBB\n" \
"bic %|r1, %2, %|r0, lsl #16 @ aaaa\n" \
"bic %0, %3, %|r2, lsl #16 @ bbbb\n" \
@@ -213,10 +212,8 @@ extern UDItype __udiv_qrnnd(UDItype *, UDItype, UDItype, UDItype);
: "r0", "r1", "r2")
#else
#define umul_ppmm(xh, xl, a, b) \
- __asm__ ("%@ Inlined umul_ppmm\n" \
- "umull %r1, %r0, %r2, %r3" \
- : "=&r" ((USItype)(xh)), \
- "=r" ((USItype)(xl)) \
+ __asm__ ("umull %1, %0, %2, %3" \
+ : "=&r" ((xh)), "=r" ((xl)) \
: "r" ((USItype)(a)), \
"r" ((USItype)(b)) \
: "r0", "r1")
diff --git a/lib/mpi/mpi-inline.h b/lib/mpi/mpi-inline.h
index e2b39852b30a..c245ea31f785 100644
--- a/lib/mpi/mpi-inline.h
+++ b/lib/mpi/mpi-inline.h
@@ -30,7 +30,7 @@
#define G10_MPI_INLINE_H

#ifndef G10_MPI_INLINE_DECL
-#define G10_MPI_INLINE_DECL extern inline
+#define G10_MPI_INLINE_DECL static inline
#endif

G10_MPI_INLINE_DECL mpi_limb_t
diff --git a/lib/mpi/mpi-internal.h b/lib/mpi/mpi-internal.h
index c65dd1bff45a..09e9f13c5ba0 100644
--- a/lib/mpi/mpi-internal.h
+++ b/lib/mpi/mpi-internal.h
@@ -168,20 +168,12 @@ void mpi_rshift_limbs(MPI a, unsigned int count);
int mpi_lshift_limbs(MPI a, unsigned int count);

/*-- mpihelp-add.c --*/
-mpi_limb_t mpihelp_add_1(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr,
- mpi_size_t s1_size, mpi_limb_t s2_limb);
mpi_limb_t mpihelp_add_n(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr,
mpi_ptr_t s2_ptr, mpi_size_t size);
-mpi_limb_t mpihelp_add(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr, mpi_size_t s1_size,
- mpi_ptr_t s2_ptr, mpi_size_t s2_size);

/*-- mpihelp-sub.c --*/
-mpi_limb_t mpihelp_sub_1(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr,
- mpi_size_t s1_size, mpi_limb_t s2_limb);
mpi_limb_t mpihelp_sub_n(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr,
mpi_ptr_t s2_ptr, mpi_size_t size);
-mpi_limb_t mpihelp_sub(mpi_ptr_t res_ptr, mpi_ptr_t s1_ptr, mpi_size_t s1_size,
- mpi_ptr_t s2_ptr, mpi_size_t s2_size);

/*-- mpihelp-cmp.c --*/
int mpihelp_cmp(mpi_ptr_t op1_ptr, mpi_ptr_t op2_ptr, mpi_size_t size);
@@ -238,7 +230,7 @@ mpi_limb_t mpihelp_rshift(mpi_ptr_t wp, mpi_ptr_t up, mpi_size_t usize,
#define W_TYPE_SIZE BITS_PER_MPI_LIMB
typedef mpi_limb_t UWtype;
typedef unsigned int UHWtype;
-#if defined(__GNUC__)
+#if defined(__GNUC__) && !defined(__clang__)
typedef unsigned int UQItype __attribute__ ((mode(QI)));
typedef int SItype __attribute__ ((mode(SI)));
typedef unsigned int USItype __attribute__ ((mode(SI)));
diff --git a/scripts/Kbuild.include b/scripts/Kbuild.include
index d3437b82ac25..bd5a3e26a277 100644
--- a/scripts/Kbuild.include
+++ b/scripts/Kbuild.include
@@ -111,12 +111,12 @@ as-instr = $(call try-run,\
# Usage: cflags-y += $(call cc-option,-march=winchip-c6,-march=i586)

cc-option = $(call try-run,\
- $(CC) $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS) $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2))
+ $(CC) -Werror $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS) $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2))

# cc-option-yn
# Usage: flag := $(call cc-option-yn,-march=winchip-c6)
cc-option-yn = $(call try-run,\
- $(CC) $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS) $(1) -c -x c /dev/null -o "$$TMP",y,n)
+ $(CC) -Werror $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS) $(1) -c -x c /dev/null -o "$$TMP",y,n)

# cc-option-align
# Prefix align with either -falign or -malign
@@ -126,7 +126,7 @@ cc-option-align = $(subst -functions=0,,\
# cc-disable-warning
# Usage: cflags-y += $(call cc-disable-warning,unused-but-set-variable)
cc-disable-warning = $(call try-run,\
- $(CC) $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS) -W$(strip $(1)) -c -x c /dev/null -o "$$TMP",-Wno-$(strip $(1)))
+ $(CC) -Werror $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS) -W$(strip $(1)) -c -x c /dev/null -o "$$TMP",-Wno-$(strip $(1)))

# cc-version
cc-version = $(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-version.sh $(CC))
diff --git a/scripts/Makefile.build b/scripts/Makefile.build
index 01df30af4d4a..6ff524dac82b 100644
--- a/scripts/Makefile.build
+++ b/scripts/Makefile.build
@@ -174,6 +174,20 @@ cmd_cc_symtypes_c = \
$(obj)/%.symtypes : $(src)/%.c FORCE
$(call cmd,cc_symtypes_c)

+# LLVM bitcode
+# Generate .ll files from .s and .c
+quiet_cmd_cc_ll_c = CC $(quiet_modtag) $@
+ cmd_cc_ll_c = $(CC) $(c_flags) -emit-llvm -S -o $@ $<
+
+$(obj)/%.ll: $(src)/%.c FORCE
+ $(call if_changed_dep,cc_ll_c)
+
+quiet_cmd_as_ll_S = CPP $(quiet_modtag) $@
+ cmd_as_ll_S = $(CPP) $(a_flags) -o $@ $<
+
+$(obj)/%.ll: $(src)/%.S FORCE
+ $(call if_changed_dep,as_ll_S)
+
# C (.c) files
# The C file is compiled and updated dependency information is generated.
# (See cmd_cc_o_c + relevant part of rule_cc_o_c)
diff --git a/scripts/mod/Makefile b/scripts/mod/Makefile
index c11212ff3510..86f6b852cd93 100644
--- a/scripts/mod/Makefile
+++ b/scripts/mod/Makefile
@@ -6,10 +6,10 @@ modpost-objs := modpost.o file2alias.o sumversion.o
devicetable-offsets-file := devicetable-offsets.h

define sed-y
- "/^->/{s:->#$.*$:/* \1 */:; \
- s:^->$[^ ]*$ [\$$#]*$[-0-9]*$ $.*$:#define \1 \2 /* \3 */:; \
- s:^->$[^ ]*$ [\$$#]*$[^ ]*$ $.*$:#define \1 \2 /* \3 */:; \
- s:->::; p;}"
+ "/^@->/{s:@->#$.*$:/* \1 */:; \
+ s:^@->$[^ ]*$ [\$$#]*$[-0-9]*$ $.*$:#define \1 \2 /* \3 */:; \
+ s:^@->$[^ ]*$ [\$$#]*$[^ ]*$ $.*$:#define \1 \2 /* \3 */:; \
+ s:@->::; p;}"
endef

quiet_cmd_offsets = GEN $@
diff --git a/security/apparmor/crypto.c b/security/apparmor/crypto.c
index 532471d0b3a0..c948247e90c2 100644
--- a/security/apparmor/crypto.c
+++ b/security/apparmor/crypto.c
@@ -32,10 +32,7 @@ unsigned int aa_hash_size(void)
int aa_calc_profile_hash(struct aa_profile *profile, u32 version, void *start,
size_t len)
{
- struct {
- struct shash_desc shash;
- char ctx[crypto_shash_descsize(apparmor_tfm)];
- } desc;
+ SHASH_DESC_ON_STACK(shash, apparmor_tfm);
int error = -ENOMEM;
u32 le32_version = cpu_to_le32(version);

@@ -46,19 +43,19 @@ int aa_calc_profile_hash(struct aa_profile *profile, u32 version, void *start,
if (!profile->hash)
goto fail;

- desc.shash.tfm = apparmor_tfm;
- desc.shash.flags = 0;
+ shash->tfm = apparmor_tfm;
+ shash->flags = 0;

- error = crypto_shash_init(&desc.shash);
+ error = crypto_shash_init(shash);
if (error)
goto fail;
- error = crypto_shash_update(&desc.shash, (u8 *) &le32_version, 4);
+ error = crypto_shash_update(shash, (u8 *) &le32_version, 4);
if (error)
goto fail;
- error = crypto_shash_update(&desc.shash, (u8 *) start, len);
+ error = crypto_shash_update(shash, (u8 *) start, len);
if (error)
goto fail;
- error = crypto_shash_final(&desc.shash, profile->hash);
+ error = crypto_shash_final(shash, profile->hash);
if (error)
goto fail;

Next message: J O'Neill & Co Solicitors: "Private Message"
Previous message: Fabio Estevam: "Re: [PATCH] power: bq24261_charger: Add support for TI BQ24261 charger"
In reply to: Sedat Dilek: "Re: [llvmlinux] percpu | bitmap issue? (Cannot boot on bare metal due to a kernel NULL pointer dereference)"
Next in thread: Sedat Dilek: "Re: [llvmlinux] percpu | bitmap issue? (Cannot boot on bare metal due to a kernel NULL pointer dereference)"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]