Attachment 260371 Details for Bug 384861 – revised disassembly of dlm_astd

revised disassembly of dlm_astd

dis-dlm_astd.annotated (text/plain), 38.11 KB, created by Bryn M. Reeves on 2007-11-15 20:29:15 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Bryn M. Reeves

Created: 2007-11-15 20:29:15 UTC

Size: 38.11 KB

patch

obsolete

>0xffffffffa01f1909 <dlm_astd>:	push   %r15                                                                        save %r15
>0xffffffffa01f190b <dlm_astd+2>:	mov    $0xdead4ead00000001,%rdi                                            load spinlock_magic into %rdi, %r9, %r8
>0xffffffffa01f1915 <dlm_astd+12>:	mov    $0xdead4ead00000001,%r9
>0xffffffffa01f191f <dlm_astd+22>:	mov    $0xdead4ead00000001,%r8
>0xffffffffa01f1929 <dlm_astd+32>:	push   %r14                                                                save %r14, %r13, %r12, %rbp, %rbx
>0xffffffffa01f192b <dlm_astd+34>:	push   %r13
>0xffffffffa01f192d <dlm_astd+36>:	push   %r12
>0xffffffffa01f192f <dlm_astd+38>:	push   %rbp
>0xffffffffa01f1930 <dlm_astd+39>:	push   %rbx
>0xffffffffa01f1931 <dlm_astd+40>:	sub    $0x18,%rsp                                                          %rsp -= 24
>0xffffffffa01f1935 <dlm_astd+44>:	mov    127785(%rip),%eax        # 0xffffffffa0210c64                       load dlm_config.lock_timeout into %eax
>0xffffffffa01f193b <dlm_astd+50>:	movl   $0x1,130971(%rip)        # 0xffffffffa02118e0                       store 0x1 into _lockqueue_lock (init_MUTEX())
>0xffffffffa01f1945 <dlm_astd+60>:	movl   $0x1,130897(%rip)        # 0xffffffffa02118a0                       store 0x1 into _deadlockqueue_lock (init_MUTEX())
>0xffffffffa01f194f <dlm_astd+70>:	mov    -533731222(%rip),%rsi        # 0xffffffff804f01c0                   load jiffies into %rsi
>0xffffffffa01f1956 <dlm_astd+77>:	mov    %rdi,131003(%rip)        # 0xffffffffa0211918                       store SPINLOCK_MAGIC into _lockqueue_timer+24 (timer_init()->spin_lock_init())
>0xffffffffa01f195d <dlm_astd+84>:	mov    $0xffffffffa0211900,%rdi                                            load &_lockqueue_timer into %rdi
>0xffffffffa01f1964 <dlm_astd+91>:	mov    %r9,130941(%rip)        # 0xffffffffa02118e8                        store SPINLOCK_MAGIC into _lockqueue_lock+8
>																		(init_MUTEX->init_waitqueue_head(&sem->wait))
>0xffffffffa01f196b <dlm_astd+98>:	sar    %eax                                                                shift arithmetic right %eax 1 bit (dlm_config.lock_timeout)
>0xffffffffa01f196d <dlm_astd+100>:	mov    %r8,130868(%rip)        # 0xffffffffa02118a8                        store SPINLOCK_MAGIC into _deadlockqueue_lock+8
>                                                                                                                                                (init_MUTEX->init_waitqueue_head(&sem->wait))
>0xffffffffa01f1974 <dlm_astd+107>:	movq   $0xffffffffa02118c0,130881(%rip)        # 0xffffffffa02118c0        INIT_LIST_HEAD(&_lockqueue)
>0xffffffffa01f197f <dlm_astd+118>:	imul   $0x3e8,%eax,%eax                                                    %eax *= 1000 (dlm_config.lock_timeout * HZ)
>0xffffffffa01f1985 <dlm_astd+124>:	movq   $0xffffffffa02118c0,130872(%rip)        # 0xffffffffa02118c8        INIT_LIST_HEAD(&_lockqueue)
>0xffffffffa01f1990 <dlm_astd+135>:	movl   $0x0,130890(%rip)        # 0xffffffffa02118e4                       store 0x0 into _lockqueue_lock.sleepers (init_MUTEX(&_lockqueue_lock))
>0xffffffffa01f199a <dlm_astd+145>:	movq   $0xffffffffa02118f0,130891(%rip)        # 0xffffffffa02118f0        INIT_LIST_HEAD(&_lockqueue_lock->wait->task_list) (init_MUTEX->init_wait_queu())
>0xffffffffa01f19a5 <dlm_astd+156>:	movq   $0xffffffffa02118f0,130888(%rip)        # 0xffffffffa02118f8        INIT_LIST_HEAD(&_lockqueue_lock->wait->task_list) (init_MUTEX->init_wait_queu())
>0xffffffffa01f19b0 <dlm_astd+167>:	movq   $0xffffffffa0211880,130757(%rip)        # 0xffffffffa0211880        INIT_LIST_HEAD(&_deadlockqueue)
>0xffffffffa01f19bb <dlm_astd+178>:	movq   $0xffffffffa0211880,130754(%rip)        # 0xffffffffa0211888        INIT_LIST_HEAD(&_deadlockqueue)
>														   579         INIT_LIST_HEAD(&_lockqueue);
>														   580         init_MUTEX(&_lockqueue_lock);
>														   581         INIT_LIST_HEAD(&_deadlockqueue);
>														   583         init_timer(&_lockqueue_timer);
>0xffffffffa01f19c6 <dlm_astd+189>:	cltq                                                                       sign extend %eax into %rax
>0xffffffffa01f19c8 <dlm_astd+191>:	movl   $0x0,130770(%rip)        # 0xffffffffa02118a4                       store 0x0 into _deadlockqueue_lock.sleepers (init_MUTEX(&_deadlockqueue_lock))
>														   582         init_MUTEX(&_deadlockqueue_lock);
>0xffffffffa01f19d2 <dlm_astd+201>:	movq   $0xffffffffa02118b0,130771(%rip)        # 0xffffffffa02118b0        INIT_LIST_HEAD(&_deadlockqueue_lock->wait->task_list)
>0xffffffffa01f19dd <dlm_astd+212>:	add    %rax,%rsi							   %rax += %rsi (dlm_config.lock_timeout += jiffies)
>0xffffffffa01f19e0 <dlm_astd+215>:	movq   $0xffffffffa02118b0,130765(%rip)        # 0xffffffffa02118b8        INIT_LIST_HEAD(&_deadlockqueue_lock->wait->task_list)
>0xffffffffa01f19eb <dlm_astd+226>:	movq   $0x0,130882(%rip)        # 0xffffffffa0211938                       _lockqueue_timer->base = NULL
>0xffffffffa01f19f6 <dlm_astd+237>:	movq   $0x4b87ad6e,130847(%rip)        # 0xffffffffa0211920                _lockqueue_timer->magic = TIMER_MAGIC
>0xffffffffa01f1a01 <dlm_astd+248>:	movq   $0xffffffffa01f18f0,130844(%rip)        # 0xffffffffa0211928        _lockqueue_timer->function = lockqueue_timer_fn
>0xffffffffa01f1a0c <dlm_astd+259>:	movq   $0x0,130841(%rip)        # 0xffffffffa0211930                       _lockqueue_timer->data = NULL
>														   584         _lockqueue_timer.function = lockqueue_timer_fn;
>														   585         _lockqueue_timer.data = 0;
>0xffffffffa01f1a17 <dlm_astd+270>:	callq  0xffffffff801400b0 <mod_timer>                                      mod_timer(&_lockqueue_timer)
>														   586         mod_timer(&_lockqueue_timer,
>														   587                   jiffies + ((dlm_config.lock_timeout >> 1) * HZ));
>0xffffffffa01f1a1c <dlm_astd+275>:	jmpq   0xffffffffa01f1f16                                                  goto dlm_astd+1549 /* jump to outer loop condition test & repeat */ ---------+
>																      /* start of outer loop in dlm_astd */			|
>0xffffffffa01f1a21 <dlm_astd+280>:	mov    $0x1,%eax                                                           load 0x1 into %eax /* #define TASK_INTERRUPTIBLE      1 */			|
>0xffffffffa01f1a26 <dlm_astd+285>:	mov    %gs:0x0,%rdx                                                        load current into %rdx 							|	
>                                                                                                                   set_current_state(TASK_INTERRUPTIBLE);					|
>0xffffffffa01f1a2f <dlm_astd+294>:	xchg   %rax,(%rdx)                                                         xchg %rax current->state							|
>0xffffffffa01f1a32 <dlm_astd+297>:	mov    130576(%rip),%eax        # 0xffffffffa0211848                       load astd_wakeflags into %eax						|
>0xffffffffa01f1a38 <dlm_astd+303>:	xor    %ebx,%ebx                                                           zero %ebx									|
>0xffffffffa01f1a3a <dlm_astd+305>:	test   $0x2,%al                                                            test WAKE_TIMER, astd_wakeflags						|
>0xffffffffa01f1a3c <dlm_astd+307>:	jne    0xffffffffa01f1a43			-------------------------- goto dlm_astd+314 ---------------------------+				|
>0xffffffffa01f1a3e <dlm_astd+309>:	callq  0xffffffff8030b966 <schedule>                                       schedule()					|				|
>0xffffffffa01f1a43 <dlm_astd+314>:	mov    %gs:0x0,%rax                                                        load current into %rax	<---------------+				|
>0xffffffffa01f1a4c <dlm_astd+323>:	xchg   %rbx,(%rax)                                                         xchg %rbx current->state							|
>                                                                                                                   set_current_state(TASK_RUNNING);						|
>0xffffffffa01f1a4f <dlm_astd+326>:	xor    %edx,%edx                                                           zero %edx                                 atomic_count?			|
>0xffffffffa01f1a51 <dlm_astd+328>:	mov    $0x6c,%esi                                                          load 0x6c (108) into %esi                 /* __LINE__ */			|
>0xffffffffa01f1a56 <dlm_astd+333>:	mov    $0xffffffffa0203820,%rdi                                            load &"include/asm/semaphore.h" into %rdi /* __FILE__ */			|
>0xffffffffa01f1a5d <dlm_astd+340>:	callq  0xffffffff80132f74 <__might_sleep>				   call __might_sleep								|
>0xffffffffa01f1a62 <dlm_astd+345>:	mov    $0xffffffffa0211860,%rdi						   load &astd_running into %rdi							|
>0xffffffffa01f1a69 <dlm_astd+352>:	lock decl 130544(%rip)        # 0xffffffffa0211860                         down(&astd_running)								|
>0xffffffffa01f1a70 <dlm_astd+359>:	js     0xffffffffa01f212b                                                  js .text.lock.ast+180q						       	|
>0xffffffffa01f1a76 <dlm_astd+365>:	lock btrl $0x1,130505(%rip)        # 0xffffffffa0211848                    bit test and reset 0x1 astd_wakeflags					|
>0xffffffffa01f1a7f <dlm_astd+374>:	sbb    %eax,%eax							   %eax -= %eax with carry from bit 0x1 of astd_wakeflags			|
>0xffffffffa01f1a81 <dlm_astd+376>:	test   %eax,%eax                                                           test %eax									|
>0xffffffffa01f1a83 <dlm_astd+378>:	je     0xffffffffa01f1c97                                                  if (!test_and_clear_bit(WAKE_ASTS, &astd_wakeflags)) goto dlm_astd+910 (599) --------+
>0xffffffffa01f1a89 <dlm_astd+384>:	xor    %r15d,%r15d							   zero %r15d									|	|
>0xffffffffa01f1a8c <dlm_astd+387>:	movq   $0x0,0x8(%rsp)                                                      store 0x0 into 0x8(%rsp) (ls)						|	|
>														        struct dlm_rsb *rsb = NULL;						|	|
>0xffffffffa01f1a95 <dlm_astd+396>:	movw   $0x0,0x6(%rsp)							   store 0x0 into 0x6(%rsp) (rsb)						|	|
>														        struct dlm_ls *ls = NULL;						|	|
>0xffffffffa01f1a9c <dlm_astd+403>:	mov    $0xffffffffa0211820,%rbp						   load &ast_queue_lock into %rbp /* process_asts(): for(;;) {...} */		|	|
>0xffffffffa01f1aa3 <dlm_astd+410>:	xor    %edx,%edx							   zero %edx									|	|
>0xffffffffa01f1aa5 <dlm_astd+412>:	mov    $0x6c,%esi							   load 0x6c (108) into %esi                 /* __LINE__ */			|	|
>0xffffffffa01f1aaa <dlm_astd+417>:	mov    $0xffffffffa0203820,%rdi                                            load &"include/asm/semaphore.h" into %rdi /* __FILE__ */			|	|
>0xffffffffa01f1ab1 <dlm_astd+424>:	xor    %r12d,%r12d                                                         zero %r12d									|	|
>0xffffffffa01f1ab4 <dlm_astd+427>:	callq  0xffffffff80132f74 <__might_sleep>                                  call __might_sleep								|	|
>0xffffffffa01f1ab9 <dlm_astd+432>:	mov    %rbp,%rdi                                                           load %rbp into %rdi (&ast_queue_lock)					|	|
>0xffffffffa01f1abc <dlm_astd+435>:	lock decl 130397(%rip)        # 0xffffffffa0211820			   down(&ast_queue_lock)							|	|
>														   204                 down(&ast_queue_lock);					|	|
>0xffffffffa01f1ac3 <dlm_astd+442>:	js     0xffffffffa01f2135						   js .text.lock.ast+190							|	|
>0xffffffffa01f1ac9 <dlm_astd+448>:	mov    130352(%rip),%rdx        # 0xffffffffa0211800			   load &ast_queue into %rdx							|	|
>0xffffffffa01f1ad0 <dlm_astd+455>:	lea    0xffffffffffffff60(%rdx),%rbx					   load &((struct dlm_lkb *)containerof(ast_queue)) into %rbx			|	|
>0xffffffffa01f1ad7 <dlm_astd+462>:	mov    0xa0(%rbx),%rax    						   load lkb->lkb_astqueue.prev into %rax					|	|
>0xffffffffa01f1ade <dlm_astd+469>:	prefetcht0 (%rax)                                                          prefetch (*lkb->lkb_astqueue->prev)						|	|
>0xffffffffa01f1ae1 <dlm_astd+472>:	cmp    $0xffffffffa0211800,%rdx						   cmp &ast_queue %rdx								|	|
>														   205                 list_for_each_entry(lkb, &ast_queue, lkb_astqueue) {	|	|
>														   206                         rsb = lkb->lkb_resource;				|	|
>														   207                         ls = rsb->res_ls;				|	|
>0xffffffffa01f1ae8 <dlm_astd+479>:	je     0xffffffffa01f1b24                               ------------------ if %rdx == ast_queue goto dlm_astd+539 (loop exit) ----------+  <----+	|	|
>0xffffffffa01f1aea <dlm_astd+481>:	mov    0x38(%rbx),%rax							   load lkb->lkb_resource into %eax                            	|       |	|      	|
>0xffffffffa01f1aee <dlm_astd+485>:	mov    %rax,0x8(%rsp)							   rsb = lkb->lkb_resource                                     	|       |	|      	|
>0xffffffffa01f1af3 <dlm_astd+490>:	mov    0x18(%rax),%r15							   load rsb->res_ls into %r15				       	|	|	|      	|
>0xffffffffa01f1af7 <dlm_astd+494>:	mov    0xa0(%rbx),%rcx							   load lkb->lkb_astqueue->next into %rcx		       	|	|	|      	|
>0xffffffffa01f1afe <dlm_astd+501>:	mov    0x20(%r15),%eax							   load rsb->res_ls->ls_flags into %eax				|	|	|      	|
>0xffffffffa01f1b02 <dlm_astd+505>:	test   $0x2,%al								   test AST_BAST in flags					|	|	|      	|
>0xffffffffa01f1b04 <dlm_astd+507>:	jne    0xffffffffa01f1bcf				------------------ dlm_astd+710	-----------------------------------+		|	|	|      	|
>0xffffffffa01f1b0a <dlm_astd+513>:	lea    0xffffffffffffff60(%rcx),%rbx											   |		|	|	|      	|
>0xffffffffa01f1b11 <dlm_astd+520>:	mov    0xa0(%rbx),%rax													   |		|	|	|      	|
>0xffffffffa01f1b18 <dlm_astd+527>:	prefetcht0 (%rax)													   |		|	|	|      	|
>0xffffffffa01f1b1b <dlm_astd+530>:	cmp    $0xffffffffa0211800,%rcx						   &ast_queue                                      |            |       |	|      	|
>0xffffffffa01f1b22 <dlm_astd+537>:	jmp    0xffffffffa01f1ae8				------------------ goto dlm_astd+479 -------------------------------------------|-------+	|	|      	
>0xffffffffa01f1b24 <dlm_astd+539>:	mov    %rbp,%rdi					<------------------------------------------------------------------|------------+		|	|
>0xffffffffa01f1b27 <dlm_astd+542>:	lock incl 130290(%rip)        # 0xffffffffa0211820			   up(&ast_queue_lock)                             |            |		|	|
>0xffffffffa01f1b2e <dlm_astd+549>:	jle    0xffffffffa01f213f						   .text.lock.ast+200                              |		|		|	|
>0xffffffffa01f1b34 <dlm_astd+555>:	test   %r12w,%r12w							                                                   |		|		|	|
>0xffffffffa01f1b38 <dlm_astd+559>:	je     0xffffffffa01f1c97				------------------ if !%r12 goto dlm_astd+910 ---------------------|------------|-----------------------+
>0xffffffffa01f1b3e <dlm_astd+565>:	movzwl 0x6(%rsp),%ebp													   |		|		|	|
>0xffffffffa01f1b43 <dlm_astd+570>:	mov    0x88(%rbx),%r12													   |		|		|	|
>0xffffffffa01f1b4a <dlm_astd+577>:	mov    0x90(%rbx),%r14													   |		|		|	|
>0xffffffffa01f1b51 <dlm_astd+584>:	mov    0x98(%rbx),%r13													   |		|		|	V
>0xffffffffa01f1b58 <dlm_astd+591>:	test   $0x1,%bpl													   |		|		|      ...
>0xffffffffa01f1b5c <dlm_astd+595>:	je     0xffffffffa01f1c3a						   dlm_astd+817	------------------------+	   |		|		|
>0xffffffffa01f1b62 <dlm_astd+601>:	test   $0x4,%bpl												|	   |		|		|
>0xffffffffa01f1b66 <dlm_astd+605>:	je     0xffffffffa01f1c29						   dlm_astd+800	----------------+	|	   |		|		|
>0xffffffffa01f1b6c <dlm_astd+611>:	cmpw   $0x0,0xb0(%rbx)											|	|	   |		|		|
>0xffffffffa01f1b74 <dlm_astd+619>:	je     0xffffffffa01f1c14						   dlm_astd+779	--------+	|	|	   |		|		|
>0xffffffffa01f1b7a <dlm_astd+625>:	callq  0xffffffffa01fcb3e <dlm_debug_dump>							|	|	|	   |		|		|
>0xffffffffa01f1b7f <dlm_astd+630>:	mov    -533731782(%rip),%r8        # 0xffffffff804f01c0			   &jiffies		|	|	|	   |		|		|
>0xffffffffa01f1b86 <dlm_astd+637>:	mov    $0xffffffffa0203a47,%rcx						   &"lkb->lkb_astflags == 0"	|	|	   |		|		|
>0xffffffffa01f1b8d <dlm_astd+644>:	mov    $0xffffffffa020387c,%rdx						   &"/builddir/build/BUILD/dlm-kernel-2.6.9-46/smp/src/ast.c"   |		|
>0xffffffffa01f1b94 <dlm_astd+651>:	mov    $0xe9,%esi										|	|	|	   |		|		|
>0xffffffffa01f1b99 <dlm_astd+656>:	mov    $0xffffffffa02038b4,%rdi						   &"DLM:  Assertion failed on line %d of file %s  |		|		|
>														     DLM:  assertion:  "%s"	|	|	   |		|		|
>														     DLM:  time = %lu\n"|	|	|	   |		|		|
>0xffffffffa01f1ba0 <dlm_astd+663>:	xor    %eax,%eax							   zero %eax		|	|	|	   |		|		|
>0xffffffffa01f1ba2 <dlm_astd+665>:	callq  0xffffffff801388c9 <printk>								|	|	|	   |		|		|
>0xffffffffa01f1ba7 <dlm_astd+670>:	mov    $0xffffffffa020390b,%rdi						   &"\n"		|	|	|	   |		|		|
>0xffffffffa01f1bae <dlm_astd+677>:	xor    %eax,%eax										|	|	|	   |		|		|
>0xffffffffa01f1bb0 <dlm_astd+679>:	callq  0xffffffff801388c9 <printk>								|	|	|	   |		|		|
>0xffffffffa01f1bb5 <dlm_astd+684>:	ud2a   									   BUG()		|	|	|	   |		|		|
>0xffffffffa01f1bb7 <dlm_astd+686>:	or     $0xffa02039,%eax										|	|	|	   |		|		|
>0xffffffffa01f1bbc <dlm_astd+691>:	(bad)  												|	|	|	   |		|		|
>0xffffffffa01f1bbd <dlm_astd+692>:	(bad)  												|	|	|	   |		|		|
>0xffffffffa01f1bbe <dlm_astd+693>:	ljmpq  *%ecx											|	|	|	   |		|		|
>0xffffffffa01f1bc0 <dlm_astd+695>:	add    %cl,0xffffffffffffffc7(%rax)								|	|	|	   |		|		V
>0xffffffffa01f1bc3 <dlm_astd+698>:	movl   $0x60b0e8c0,0x31a02039(%rbx)								|	|	|	   |		|	       ...
>0xffffffffa01f1bcd <dlm_astd+708>:	hlt    												|	|	|	   |		|
>0xffffffffa01f1bce <dlm_astd+709>:	fisttp 0xffffffffffffff8d(%rax) 								|	|	|	   |		|
>0xffffffffa01f1bd1 <dlm_astd+712>:	xchg   %eax,%ebx										|	|	|	<--+		|
>0xffffffffa01f1bd2 <dlm_astd+713>:	mov    0x1bc41000000,%al									|	|	|			|
>0xffffffffa01f1bdb <dlm_astd+722>:	add    %cl,0xffffffffffffff8b(%rax)								|	|	|			|
>0xffffffffa01f1bde <dlm_astd+725>:	rexY or     %cl,0xffffffffffffff89(%rax)							|	|	|			|
>0xffffffffa01f1be2 <dlm_astd+729>:	or     %cl,0xffffffffffffff89(%r8)								|	|	|			|
>0xffffffffa01f1be6 <dlm_astd+733>:	or     %cl,0xffffffffffffffc7(%rax)								|	|	|			|
>0xffffffffa01f1be9 <dlm_astd+736>:	rexY or     %al,(%rax)										|	|	|			|
>0xffffffffa01f1bec <dlm_astd+739>:	add    (%rax),%ah										|	|	|			|
>0xffffffffa01f1bee <dlm_astd+741>:	add    %cl,(%rdi)										|	|	|			|
>0xffffffffa01f1bf0 <dlm_astd+743>:	mov    $0x83,%bh										|	|	|			|
>0xffffffffa01f1bf2 <dlm_astd+745>:	mov    $0x0,%al											|	|	|			|
>0xffffffffa01f1bf4 <dlm_astd+747>:	add    %al,(%rax)										|	|	|			|
>0xffffffffa01f1bf6 <dlm_astd+749>:	movq   $0x100100,0xa0(%rbx)									|	|	|			|
>0xffffffffa01f1c01 <dlm_astd+760>:	mov    %ax,0x6(%rsp)										|	|	|			|
>0xffffffffa01f1c06 <dlm_astd+765>:	movw   $0x0,0xb0(%rbx)										|	|	|			|
>0xffffffffa01f1c0f <dlm_astd+774>:	jmpq   0xffffffffa01f1b24			-------------------------- dlm_astd+539	----------------|-------|-----------------------+
>0xffffffffa01f1c14 <dlm_astd+779>:	mov    %r15,%rdi				<-----------------------------------------------+	|	|
>0xffffffffa01f1c17 <dlm_astd+782>:	mov    %rbx,%rsi											|	|
>0xffffffffa01f1c1a <dlm_astd+785>:	callq  0xffffffffa01f4931 <release_lkb>									|	|
>0xffffffffa01f1c1f <dlm_astd+790>:	mov    0x8(%rsp),%rdi											|	|
>0xffffffffa01f1c24 <dlm_astd+795>:	callq  0xffffffffa02027bb <release_rsb>									|	|
>0xffffffffa01f1c29 <dlm_astd+800>:	test   %r12,%r12				<-------------------------------------------------------+	|
>0xffffffffa01f1c2c <dlm_astd+803>:	je     0xffffffffa01f1c3a			-------------------------- dlm_astd+817	------------------------+
>0xffffffffa01f1c2e <dlm_astd+805>:	incl   131116(%rip)        # 0xffffffffa0211c60				   &dlm_stats				|
>0xffffffffa01f1c34 <dlm_astd+811>:	mov    %r13,%rdi									 	 process_asts(): for(;;) {...}
>0xffffffffa01f1c37 <dlm_astd+814>:	callq  *%r12d                                                                                    ^		|
>0xffffffffa01f1c3a <dlm_astd+817>:	test   $0x2,%bpl                                <------------------------------------------------|--------------+
>0xffffffffa01f1c3e <dlm_astd+821>:	je     0xffffffffa01f1c8d						   dlm_astd+900 ----+    |
>0xffffffffa01f1c40 <dlm_astd+823>:	and    $0x4,%bpl 									    |    |
>0xffffffffa01f1c44 <dlm_astd+827>:	jne    0xffffffffa01f1c8d			-------------------------- dlm_astd+900 ----+    |
>0xffffffffa01f1c46 <dlm_astd+829>:	test   %r14,%r14									    |    |
>0xffffffffa01f1c49 <dlm_astd+832>:	movzbl 0xb2(%rbx),%ebp									    |    | 
>0xffffffffa01f1c50 <dlm_astd+839>:	je     0xffffffffa01f1a9c			-------------------------- dlm_astd+403 ---------+							       ...
>0xffffffffa01f1c56 <dlm_astd+845>:	movsbl 0x7(%rbx),%edi 									    |    |								^
>0xffffffffa01f1c5a <dlm_astd+849>:	mov    %ebp,%esi									    |    |								|
>0xffffffffa01f1c5c <dlm_astd+851>:	callq  0xffffffffa01f4af4 <dlm_modes_compat>						    |    |								|
>0xffffffffa01f1c61 <dlm_astd+856>:	test   %eax,%eax									    |    |								|
>0xffffffffa01f1c63 <dlm_astd+858>:	jne    0xffffffffa01f1a9c			-------------------------- dlm_astd+403 ---------+								|
>0xffffffffa01f1c69 <dlm_astd+864>:	movzbl 0x6(%rbx),%eax         								    |    |								|
>0xffffffffa01f1c6d <dlm_astd+868>:	cmp    $0xff,%al 									    |    |								|
>0xffffffffa01f1c6f <dlm_astd+870>:	je     0xffffffffa01f1c7f			-------------------------- dlm_astd+886	--------------+								|
>0xffffffffa01f1c71 <dlm_astd+872>:	movsbl %al,%edi										    |    |    |								|
>0xffffffffa01f1c74 <dlm_astd+875>:	mov    %ebp,%esi									    |    |    |								|
>0xffffffffa01f1c76 <dlm_astd+877>:	callq  0xffffffffa01f4af4 <dlm_modes_compat>						    |    |    |								|
>0xffffffffa01f1c7b <dlm_astd+882>:	test   %eax,%eax 									    |    |    |  							|
>0xffffffffa01f1c7d <dlm_astd+884>:	jne    0xffffffffa01f1c8d			-------------------------- dlm_astd+900 ----+    |    |								|
>0xffffffffa01f1c7f <dlm_astd+886>:	mov    %ebp,%esi                                                                            |    |  <-+								|
>0xffffffffa01f1c81 <dlm_astd+888>:	mov    %r13,%rdi									    |    |								|
>0xffffffffa01f1c84 <dlm_astd+891>:	callq  *%r14d 										    |    |								|
>0xffffffffa01f1c87 <dlm_astd+894>:	incl   131031(%rip)        # 0xffffffffa0211c64				   &dlm_stats+4     |    |								|
>0xffffffffa01f1c8d <dlm_astd+900>:	callq  0xffffffff8030b966 <schedule>            <-------------------------------------------+    |								|
>														   262                 } |								|
>														   263                   |						       ...	|
>														   264                 schedule();					       	^	|
>0xffffffffa01f1c92 <dlm_astd+905>:	jmpq   0xffffffffa01f1a9c						   goto dlm_astd+403 ----+							|	|
>														   265         }								|	|
>0xffffffffa01f1c97 <dlm_astd+910>:	lock btrl $0x2,129960(%rip)        # 0xffffffffa0211848			   &astd_wakeflags	<-------------------------------------------------------|-------+
>0xffffffffa01f1ca0 <dlm_astd+919>:	sbb    %eax,%eax																	|
>0xffffffffa01f1ca2 <dlm_astd+921>:	test   %eax,%eax																	V
>0xffffffffa01f1ca4 <dlm_astd+923>:	je     0xffffffffa01f1f02			-------------------------- dlm_astd+1529 ---------------------------------------------------------------+
>0xffffffffa01f1caa <dlm_astd+929>:	mov    $0xffffffffa02118e0,%rbx						   &_lockqueue_lock								|
>0xffffffffa01f1cb1 <dlm_astd+936>:	xor    %edx,%edx																	|
>0xffffffffa01f1cb3 <dlm_astd+938>:	mov    $0x6c,%esi																	|
>0xffffffffa01f1cb8 <dlm_astd+943>:	mov    $0xffffffffa0203820,%rdi						   &"include/asm/semaphore.h"							|
>0xffffffffa01f1cbf <dlm_astd+950>:	xor    %r12d,%r12d																	|
>0xffffffffa01f1cc2 <dlm_astd+953>:	callq  0xffffffff80132f74 <__might_sleep>														|
>0xffffffffa01f1cc7 <dlm_astd+958>:	mov    %rbx,%rdi																	|
>0xffffffffa01f1cca <dlm_astd+961>:	lock decl 130063(%rip)        # 0xffffffffa02118e0			   &_lockqueue_lock								|
>0xffffffffa01f1cd1 <dlm_astd+968>:	js     0xffffffffa01f2149						   .text.lock.ast+210								|
>0xffffffffa01f1cd7 <dlm_astd+974>:	mov    130018(%rip),%rax        # 0xffffffffa02118c0			   &_lockqueue									|
>0xffffffffa01f1cde <dlm_astd+981>:	lea    0xffffffffffffffb0(%rax),%r8															|
>0xffffffffa01f1ce2 <dlm_astd+985>:	mov    0x50(%r8),%rbp																	|
>0xffffffffa01f1ce6 <dlm_astd+989>:	sub    $0x50,%rbp																	|
>0xffffffffa01f1cea <dlm_astd+993>:	cmp    $0xffffffffa02118c0,%rax						   &_lockqueue									|
>0xffffffffa01f1cf0 <dlm_astd+999>:	je     0xffffffffa01f1daa			-------------------------- dlm_astd+1185 -----------------------+					|
>0xffffffffa01f1cf6 <dlm_astd+1005>:	mov    0x38(%r8),%rax												|					|
>0xffffffffa01f1cfa <dlm_astd+1009>:	mov    0x18(%rax),%rdx												|					|
>0xffffffffa01f1cfe <dlm_astd+1013>:	mov    0x20(%rdx),%eax												|					|
>0xffffffffa01f1d01 <dlm_astd+1016>:	test   $0x40,%al												|					V
>0xffffffffa01f1d03 <dlm_astd+1018>:	jne    0xffffffffa01f1d96			-------------------------- dlm_astd+1165 ---------------+	|				       ...
>0xffffffffa01f1d09 <dlm_astd+1024>:	mov    0x20(%rdx),%eax											|	|
>0xffffffffa01f1d0c <dlm_astd+1027>:	test   $0x2,%al												|	|
>0xffffffffa01f1d0e <dlm_astd+1029>:	je     0xffffffffa01f1d96						   dlm_astd+1165 ---------------+	|
>0xffffffffa01f1d14 <dlm_astd+1035>:	imul   $0x3e8,126790(%rip),%eax        # 0xffffffffa0210c64		   &dlm_config->lock_timeout	|	|
>0xffffffffa01f1d1e <dlm_astd+1045>:	mov    -533732197(%rip),%rdx        # 0xffffffff804f01c0		   &jiffies			|	|
>0xffffffffa01f1d25 <dlm_astd+1052>:	mov    %eax,%eax											|	|
>0xffffffffa01f1d27 <dlm_astd+1054>:	add    0x70(%r8),%rax											|	|
>0xffffffffa01f1d2b <dlm_astd+1058>:	cmp    %rdx,%rax											|	|
>0xffffffffa01f1d2e <dlm_astd+1061>:	jns    0xffffffffa01f1d96						   dlm_astd+1165 ---------------+	|
>0xffffffffa01f1d30 <dlm_astd+1063>:	lea    0x50(%r8),%rcx											|	|
>0xffffffffa01f1d34 <dlm_astd+1067>:	mov    0x50(%r8),%rax											|	|
>0xffffffffa01f1d38 <dlm_astd+1071>:	inc    %r12d												|	|
>0xffffffffa01f1d3b <dlm_astd+1074>:	mov    %rbx,%rdi											|	|
>0xffffffffa01f1d3e <dlm_astd+1077>:	mov    0x8(%rcx),%rdx											|	|
>0xffffffffa01f1d42 <dlm_astd+1081>:	mov    %rdx,0x8(%rax)											|	|
>0xffffffffa01f1d46 <dlm_astd+1085>:	mov    %rax,(%rdx)											|	|
>0xffffffffa01f1d49 <dlm_astd+1088>:	movq   $0x200200,0x8(%rcx)										|	|
>0xffffffffa01f1d51 <dlm_astd+1096>:	movq   $0x100100,0x50(%r8)										|	|
>0xffffffffa01f1d59 <dlm_astd+1104>:	lock incl 129920(%rip)        # 0xffffffffa02118e0			   &_lockqueue_lock		|	|
>0xffffffffa01f1d60 <dlm_astd+1111>:	jle    0xffffffffa01f2153						   .text.lock.ast+220		|	|
>0xffffffffa01f1d66 <dlm_astd+1117>:	mov    $0xffffff92,%esi											|	|
>0xffffffffa01f1d6b <dlm_astd+1122>:	mov    %r8,%rdi												|	|
>0xffffffffa01f1d6e <dlm_astd+1125>:	callq  0xffffffffa01f64be <cancel_lockop>								|	|
>0xffffffffa01f1d73 <dlm_astd+1130>:	xor    %edx,%edx											|	|
>0xffffffffa01f1d75 <dlm_astd+1132>:	mov    $0x6c,%esi											|	|
>0xffffffffa01f1d7a <dlm_astd+1137>:	mov    $0xffffffffa0203820,%rdi						   &"include/asm/semaphore.h"	|	|
>0xffffffffa01f1d81 <dlm_astd+1144>:	callq  0xffffffff80132f74 <__might_sleep>								|	|
>0xffffffffa01f1d86 <dlm_astd+1149>:	mov    %rbx,%rdi											|	|
>0xffffffffa01f1d89 <dlm_astd+1152>:	lock decl 129872(%rip)        # 0xffffffffa02118e0			   &_lockqueue_lock		|	|
>0xffffffffa01f1d90 <dlm_astd+1159>:	js     0xffffffffa01f215d						   .text.lock.ast+230		|	|
>0xffffffffa01f1d96 <dlm_astd+1165>:	mov    %rbp,%r8					<-------------------------------------------------------+	|
>0xffffffffa01f1d99 <dlm_astd+1168>:	mov    0x50(%rbp),%rbp												|
>0xffffffffa01f1d9d <dlm_astd+1172>:	lea    0x50(%r8),%rax												|
>0xffffffffa01f1da1 <dlm_astd+1176>:	sub    $0x50,%rbp												|
>0xffffffffa01f1da5 <dlm_astd+1180>:	jmpq   0xffffffffa01f1cea						   dlm_astd+993				|
>0xffffffffa01f1daa <dlm_astd+1185>:	mov    $0xffffffffa02118e0,%rdi			<------------------------- &_lockqueue_lock --------------------+
>0xffffffffa01f1db1 <dlm_astd+1192>:	lock incl 129832(%rip)        # 0xffffffffa02118e0			   &_lockqueue_lock
>0xffffffffa01f1db8 <dlm_astd+1199>:	jle    0xffffffffa01f2167						   .text.lock.ast+240 
>0xffffffffa01f1dbe <dlm_astd+1205>:	test   %r12d,%r12d
>0xffffffffa01f1dc1 <dlm_astd+1208>:	je     0xffffffffa01f1dc8			-------------------------- dlm_astd+1215 -----------------------+
>0xffffffffa01f1dc3 <dlm_astd+1210>:	callq  0xffffffffa01f188c <wake_astd>										|
>0xffffffffa01f1dc8 <dlm_astd+1215>:	mov    126614(%rip),%eax        # 0xffffffffa0210c64			   &dlm_config->lock_timeout   	   <----+
>0xffffffffa01f1dce <dlm_astd+1221>:	mov    -533732373(%rip),%rsi        # 0xffffffff804f01c0		   &jiffies
>0xffffffffa01f1dd5 <dlm_astd+1228>:	mov    $0xffffffffa0211900,%rdi						   &_lockqueue_timer
>0xffffffffa01f1ddc <dlm_astd+1235>:	sar    %eax
>0xffffffffa01f1dde <dlm_astd+1237>:	imul   $0x3e8,%eax,%eax																       ...
>0xffffffffa01f1de4 <dlm_astd+1243>:	cltq   																			|
>0xffffffffa01f1de6 <dlm_astd+1245>:	add    %rax,%rsi																	|
>0xffffffffa01f1de9 <dlm_astd+1248>:	callq  0xffffffff801400b0 <mod_timer>															|
>0xffffffffa01f1dee <dlm_astd+1253>:	cmpl   $0x0,126599(%rip)        # 0xffffffffa0210c7c			   &dlm_config+28								V
>0xffffffffa01f1df5 <dlm_astd+1260>:	je     0xffffffffa01f1f02			-------------------------- dlm_astd+1529 ---------------------------------------------------------------+
>0xffffffffa01f1dfb <dlm_astd+1266>:	mov    $0xffffffffa02118a0,%rbx						   &_deadlockqueue_lock								|
>0xffffffffa01f1e02 <dlm_astd+1273>:	xor    %edx,%edx																	|
>0xffffffffa01f1e04 <dlm_astd+1275>:	mov    $0x6c,%esi																	|
>0xffffffffa01f1e09 <dlm_astd+1280>:	mov    $0xffffffffa0203820,%rdi						   &"include/asm/semaphore.h"							|
>0xffffffffa01f1e10 <dlm_astd+1287>:	callq  0xffffffff80132f74 <__might_sleep>														|
>0xffffffffa01f1e15 <dlm_astd+1292>:	mov    %rbx,%rdi																	|
>0xffffffffa01f1e18 <dlm_astd+1295>:	lock decl 129665(%rip)        # 0xffffffffa02118a0			   down(&_deadlockqueue_lock)							|
>0xffffffffa01f1e1f <dlm_astd+1302>:	js     0xffffffffa01f2171						   .text.lock.ast+250								|
>														   530         list_for_each_entry_safe(lkb, safe, &_deadlockqueue, lkb_deadlockq) {
>0xffffffffa01f1e25 <dlm_astd+1308>:	mov    129620(%rip),%rax        # 0xffffffffa0211880			   load _deadlockqueue->next into %rax		list_entry(...)			|
>0xffffffffa01f1e2c <dlm_astd+1315>:	lea    0xffffffffffffff40(%rax),%rcx					   load &containerof(_deadlockqueue->next) into %rcx				|
>														   # %rcx - lkb, %r12 - safe 							|
>0xffffffffa01f1e33 <dlm_astd+1322>:	mov    0xc0(%rcx),%r12							   load containerof(_deadlockqueue->next)->lkb_deadlockqueue->next into %r12	|
>0xffffffffa01f1e3a <dlm_astd+1329>:	sub    $0xc0,%r12							   %r12 = containerof(%r12) (%r12 -= 192)					| 
>														   # i.e. %r12 is a saved pointer to the next lkb.
>0xffffffffa01f1e41 <dlm_astd+1336>:	cmp    $0xffffffffa0211880,%rax						   if (lkb == _deadlockqueue)				<-------------------+	|
>0xffffffffa01f1e47 <dlm_astd+1342>:	je     0xffffffffa01f1eee						           goto dlm_astd+1509 exit list_for_each_entry_safe loop	    |	|
>														   533                 /* Only look at "due" locks */
>0xffffffffa01f1e4d <dlm_astd+1348>:	imul   $0x3e8,126501(%rip),%eax        # 0xffffffffa0210c7c		   %eax = &dlm_config->deadlocktime * HZ				    |	|
>0xffffffffa01f1e57 <dlm_astd+1358>:	mov    -533732510(%rip),%rdx        # 0xffffffff804f01c0		   load jiffies into %rdx						    |	|
>0xffffffffa01f1e5e <dlm_astd+1365>:	mov    %eax,%eax							   ?									    |	|
>0xffffffffa01f1e60 <dlm_astd+1367>:	add    0x78(%rcx),%rax							   %rax += lkb->lkb_duetime						    |	|
>0xffffffffa01f1e64 <dlm_astd+1371>:	cmp    %rdx,%rax 							   cmp jiffies, (deadlocktime * HZ + lkb->duetime)			    |	|
>														   534                 if (!check_timeout(lkb->lkb_duetime, dlm_config.deadlocktime))
>0xffffffffa01f1e67 <dlm_astd+1374>:	jns    0xffffffffa01f1eee						   dlm_astd+1509 -------------------------------------------------------+   |	|
>														   535                         break;					|   |	|
>0xffffffffa01f1e6d <dlm_astd+1380>:	mov    0x38(%rcx),%rax							   load lkb->lkb_resource into %rax				        |   |	|
>0xffffffffa01f1e71 <dlm_astd+1384>:	mov    0x18(%rax),%rax							   load lkb->lkb_resource->res_ls into %rax			        |   |	|
>0xffffffffa01f1e75 <dlm_astd+1388>:	mov    0x20(%rax),%eax							   load lkb->lkb_resource->res_ls->ls_flags into %rax		        |   |	|
>														   537                 /* Don't look at locks that are in transition */ |   |   |
>0xffffffffa01f1e78 <dlm_astd+1391>:	test   $0x2,%al								   test_bit(LSFL_LS_RUN, &lkb->lkb_resource->res_ls->ls_flags)	        |   |	|
>														   538                 if (!test_bit(LSFL_LS_RUN,                       |   |   |
>														   539                               &lkb->lkb_resource->res_ls->ls_flags)) |   |
>0xffffffffa01f1e7a <dlm_astd+1393>:	je     0xffffffffa01f1ed0			-------------------------- dlm_astd+1479 -----------------------+			        |   |	|
>														   540                         continue;|                               |   |   |
>0xffffffffa01f1e7c <dlm_astd+1395>:	mov    $0xffffffffa02118a0,%rbp						   &_deadlockqueue_lock			|			        |   |	|
>0xffffffffa01f1e83 <dlm_astd+1402>:	mov    %rbx,%rdi							   (regparm for wakeup call)		|			        |   |	|
>0xffffffffa01f1e86 <dlm_astd+1405>:	lock incl 129555(%rip)        # 0xffffffffa02118a0			   &_deadlockqueue_lock			|			        |   |	|
>														   542                 up(&_deadlockqueue_lock);		        |   |	|
>0xffffffffa01f1e8d <dlm_astd+1412>:	jle    0xffffffffa01f217b						   .text.lock.ast+260			|			        |   |	|
>0xffffffffa01f1e93 <dlm_astd+1418>:	mov    %rcx,%rdi							   load &lkb into %rdi (regparm)	|			        |   |	|
>0xffffffffa01f1e96 <dlm_astd+1421>:	callq  0xffffffffa01f652d <conversion_deadlock_check>								|			        |   |	|
>														   544                 /* Lock has hit due time, check for conversion deadlock */
>														   545                 kill_lkb = conversion_deadlock_check(lkb);	|   |	|
>0xffffffffa01f1e9b <dlm_astd+1426>:	test   %rax,%rax												|				|   |	|
>														   546                 if (kill_lkb)	|				|   |   |
>0xffffffffa01f1e9e <dlm_astd+1429>:	mov    %rax,%rdi												|				|   |	|
>0xffffffffa01f1ea1 <dlm_astd+1432>:	je     0xffffffffa01f1ead			-------------------------- dlm_astd+1444 -------+		|				|   |	|	
>														   if (!kill_lkb), re-acquire _deadlockqueue_lock & continue		|   |   |
>0xffffffffa01f1ea3 <dlm_astd+1434>:	mov    $0xffffffdd,%esi										|		|				|   |	|
>0xffffffffa01f1ea8 <dlm_astd+1439>:	callq  0xffffffffa01f65f5 <cancel_conversion>				   goto dlm_astd+1444 --+		|			  	|   |	|
>                                   										   547                  |      cancel_conversion(kill_lkb, -EDEADLOCK); |   |	|
>0xffffffffa01f1ead <dlm_astd+1444>:	xor    %edx,%edx							   zero %edx	<-------+		|				|   |	|
>0xffffffffa01f1eaf <dlm_astd+1446>:	mov    $0x6c,%esi							   load 0x6c (108) into %esi /* __LINE__ */				|   |	|
>0xffffffffa01f1eb4 <dlm_astd+1451>:	mov    $0xffffffffa0203820,%rdi						   load &include/asm/semaphore.h into %rdi				|   |	|
>0xffffffffa01f1ebb <dlm_astd+1458>:	callq  0xffffffff80132f74 <__might_sleep>									|				|   |	|
>0xffffffffa01f1ec0 <dlm_astd+1463>:	mov    %rbp,%rdi												|				|   |	|
>0xffffffffa01f1ec3 <dlm_astd+1466>:	lock decl 129494(%rip)        # 0xffffffffa02118a0                                        			|				|   |	|
>														   549                 down(&_deadlockqueue_lock);                      |   |	|
>0xffffffffa01f1eca <dlm_astd+1473>:	js     0xffffffffa01f2185						   .text.lock.ast+270                   |                               |   |	|
>0xffffffffa01f1ed0 <dlm_astd+1479>:	mov    %r12,%rcx                           	<-------------------------- load "safe" into %rcx --------------+                               |   |	|
>														   lkb = safe;
>0xffffffffa01f1ed3 <dlm_astd+1482>:	mov    0xc0(%r12),%r12                                                     load safe->lkb_deadlockqueue->next into %r12                         |   |	|
>0xffffffffa01f1edb <dlm_astd+1490>:	lea    0xc0(%rcx),%rax                                                     load &safe->lkb_deadlockqueue->next into %rax                        |   |	|
>0xffffffffa01f1ee2 <dlm_astd+1497>:	sub    $0xc0,%r12                                                          %r12 = containerof(%r12) (%r12 -= 192) ("new" safe)                  |   |	|
>0xffffffffa01f1ee9 <dlm_astd+1504>:	jmpq   0xffffffffa01f1e41 			 			   goto dlm_astd+1336 ------------------------------------------------------+	|
>														   550         }                                                        |	|
>0xffffffffa01f1eee <dlm_astd+1509>:	mov    $0xffffffffa02118a0,%rdi														<-------+	|
>0xffffffffa01f1ef5 <dlm_astd+1516>:	lock incl 129444(%rip)        # 0xffffffffa02118a0			   up(&_deadlockqueue_lock)							|
>														   551         up(&_deadlockqueue_lock);					|
>0xffffffffa01f1efc <dlm_astd+1523>:	jle    0xffffffffa01f218f						   goto .text.lock.ast+280							|
>0xffffffffa01f1f02 <dlm_astd+1529>:	mov    $0xffffffffa0211860,%rdi						   load &astd_running into %rdi							|
>0xffffffffa01f1f09 <dlm_astd+1536>:	lock incl 129360(%rip)        # 0xffffffffa0211860			   up(&astd_running)								|
>0xffffffffa01f1f10 <dlm_astd+1543>:	jle    0xffffffffa01f2199 						   goto .text.lock.ast+290							|
>0xffffffffa01f1f16 <dlm_astd+1549>:	callq  0xffffffff8014b828 <kthread_should_stop>		<-----------------------------------------------------------------------------------------------+
>0xffffffffa01f1f1b <dlm_astd+1554>:	test   %eax,%eax
>														   589         while (!kthread_should_stop()) {
>0xffffffffa01f1f1d <dlm_astd+1556>:	je     0xffffffffa01f1a21						   if !kthread_should_stop() goto dlm_astd+280
>														   605         }
>0xffffffffa01f1f23 <dlm_astd+1562>:	cmpq   $0x0,129549(%rip)        # 0xffffffffa0211938			   cmpq 0x0, _lockqueue_timer->base
>0xffffffffa01f1f2b <dlm_astd+1570>:	je     0xffffffffa01f1f39						   if !_lockqueue_timer->base goto dlm_astd+1584
>0xffffffffa01f1f2d <dlm_astd+1572>:	mov    $0xffffffffa0211900,%rdi						   load &_lockqueue_timer into %edi
>0xffffffffa01f1f34 <dlm_astd+1579>:	callq  0xffffffff80140104 <del_timer>					   del_timer(&_lockqueue_timer)
>0xffffffffa01f1f39 <dlm_astd+1584>:	add    $0x18,%rsp							   %rsp += 24
>0xffffffffa01f1f3d <dlm_astd+1588>:	xor    %eax,%eax							   zero %eax
>0xffffffffa01f1f3f <dlm_astd+1590>:	pop    %rbx								   restore %rbx, %rbp, %r12, %r13, %r14, %r15
>0xffffffffa01f1f40 <dlm_astd+1591>:	pop    %rbp
>0xffffffffa01f1f41 <dlm_astd+1592>:	pop    %r12
>0xffffffffa01f1f43 <dlm_astd+1594>:	pop    %r13
>0xffffffffa01f1f45 <dlm_astd+1596>:	pop    %r14
>0xffffffffa01f1f47 <dlm_astd+1598>:	pop    %r15
>0xffffffffa01f1f49 <dlm_astd+1600>:	retq   									   return

Actions: View

Attachments on bug 384861: 259951 | 260371 | 260381