analyzing i386 assembled function... line by line

Question

hi i'm such newb in assemble and OS world. and yes this is my homework which i'm in stuck in deep dark of i386 manual. please help me or give me some hint.. here's code i have to analyze ine by line. this function is part of EOS(educational OS), doing about interrupt request in hal(hardware abstraction layer). i did "objdump -d interrupt.o" and got this assemble code. of course in i386.

00000000 <eos_ack_irq>:
   0:   55                      push   %ebp  ; push %ebp to stack to save stack before
   1:   b8 fe ff ff ff          mov    $0xfffffffe,%eax  ; what is this??
   6:   89 e5                   mov    %esp,%ebp   ; couple with "push %ebp". known as prolog assembly function.   
   8:   8b 4d 08                mov    0x8(%ebp),%ecx ; set %ecx as value of (%ebp+8)...and what is this do??
   b:   5d                      pop    %ebp ; pop the top of stack to %ebp. i know this is for getting back to callee..
   c:   d3 c0                   rol    %cl,%eax  ; ????? what is this for???
   e:   21 05 00 00 00 00       and    %eax,0x0  ; make %eax as 0. for what??
  14:   c3                      ret    ; return what register??

00000015 <eos_get_irq>:
  15:   8b 15 00 00 00 00       mov    0x0,%edx
  1b:   b8 1f 00 00 00          mov    $0x1f,%eax
  20:   55                      push   %ebp
  21:   89 e5                   mov    %esp,%ebp
  23:   56                      push   %esi
  24:   53                      push   %ebx
  25:   bb 01 00 00 00          mov    $0x1,%ebx
  2a:   89 de                   mov    %ebx,%esi
  2c:   88 c1                   mov    %al,%cl
  2e:   d3 e6                   shl    %cl,%esi
  30:   85 d6                   test   %edx,%esi
  32:   75 06                   jne    3a <eos_get_irq+0x25>
  34:   48                      dec    %eax
  35:   83 f8 ff                cmp    $0xffffffff,%eax
  38:   75 f0                   jne    2a <eos_get_irq+0x15>
  3a:   5b                      pop    %ebx
  3b:   5e                      pop    %esi
  3c:   5d                      pop    %ebp
  3d:   c3                      ret    

0000003e <eos_disable_irq_line>:
  3e:   55                      push   %ebp
  3f:   b8 01 00 00 00          mov    $0x1,%eax
  44:   89 e5                   mov    %esp,%ebp
  46:   8b 4d 08                mov    0x8(%ebp),%ecx
  49:   5d                      pop    %ebp
  4a:   d3 e0                   shl    %cl,%eax
  4c:   09 05 00 00 00 00       or     %eax,0x0
  52:   c3                      ret    

00000053 <eos_enable_irq_line>:
  53:   55                      push   %ebp
  54:   b8 fe ff ff ff          mov    $0xfffffffe,%eax
  59:   89 e5                   mov    %esp,%ebp
  5b:   8b 4d 08                mov    0x8(%ebp),%ecx
  5e:   5d                      pop    %ebp
  5f:   d3 c0                   rol    %cl,%eax
  61:   21 05 00 00 00 00       and    %eax,0x0
  67:   c3                      ret

and here's pre-assembled C code

/* ack the specified irq */
void eos_ack_irq(int32u_t irq) {
    /* clear the corresponding bit in _irq_pending register */
    _irq_pending &= ~(0x1<<irq);
}

/* get the irq number */
int32s_t eos_get_irq() {
    /* get the highest bit position in the _irq_pending register */
    int i = 31;
    for(; i>=0; i--) {
        if (_irq_pending & (0x1<<i)) {
            return i;
        }
    }
    return -1;
}

/* mask an irq */
void eos_disable_irq_line(int32u_t irq) {
    /* turn on the corresponding bit */
    _irq_mask |= (0x1<<irq);
}

/* unmask an irq */
void eos_enable_irq_line(int32u_t irq) {
    /* turn off the corresponding bit */
    _irq_mask &= ~(0x1<<irq);
}

so these functions do ack and get and mask and unmask an interrupt request. and i'm stuck at the first one. so if you are mercy enough, would you please get me some hint or answer to analyze the first function? i'll try to get the others... and i'm very sorry for another homework.. (my TA doesn't look email)

I think you should pick up a assembly book and read :P. About the EBP+8, you can read more here: http://stackoverflow.com/questions/579262/what-is-the-purpose-of-the-frame-pointer — Erti-Chris Eelmaa, Apr 14 '13 at 07:58

score 3 · Accepted Answer · answered Apr 14 '13 at 07:55

21 05 00 00 00 00 (that and) is actually an and with a memory operand (namely and [0], eax) which the AT&T syntax obscures (but technically it does say that, note the absence of a $ sign). It makes more sense that way (the offset of 0 suggests you didn't link the code before disassembling).

mov $0xfffffffe, %eax is doing exactly what it looks like it's doing (note that 0xfffffffe is all ones except the lowest bit), and that means the function has been implemented like this:

_irq_pending &= rotate_left(0xFFFFFFFE, irq);

Saving a not operation. It has to be a rotate there instead of a shift in order to make the low bits 1 if necessary.

and so that _irq_pending &= ~(0x1< – YHG Apr 14 '13 at 08:06 — YHG, Apr 14 '13 at 08:06

analyzing i386 assembled function... line by line

1 Answers1