OSDev.org

Code: Select all

int printint(int i);

struct test{
    int i;
};

void f(struct test *t)
{
    printint(t->i);
}

void f2(struct test t)
{
    printint(t.i);
}

struct test t1;

int main()
{
    struct test t2;
    t1.i = 9;
    t2.i = 5;
    f(&t1);
    f(&t2);
    f2(t1);
    printint(t2.i);
    __asm__("jmp .");
}

Code: Select all

.code16
.text
.globl _start
_start:
    ...
    /*some code to enable a20 line and to detect the memory*/
    ...
    xor     %ax,%ax
    movw    %ax,%es
    movw    %ax,%si
    mov     %ax,%ss
    mov     %ax,%ds
    mov     %ax,%gs
    jmp     switsching_to_protected

/* base address of code and data segment is 0x0
   limit for code and data segment is 0xfffff
   code segment access byte: 0b10011010
   data segment access byte: 0b10010010
   stack base: 0xAC00
   stack limit: 0x05
   stack segment access byte: 0b10010110
   the granuality and size flag is set for all the segments*/

.equ STACK_BASE, 0xAC00
.equ STACK_LIMIT, 0x05
StartOfGDT:
    zerodescriptor:
        .quad   0
    OScode:
        .quad   0x00cf9a000000ffff
    OSdata:
        .quad   0x00cf92000000ffff
    OSstack:
        .quad   0x00C09600AC000005
    GDTend:

GDTdescriptor:
    .word   0x1f
    .int    StartOfGDT



switsching_to_protected:
    cli
    lgdt    (GDTdescriptor)
    mov     %cr0,%eax
    or      $0x1,%ax
    mov     %eax,%cr0
    jmp     $8,$init_protected
    ret


.code32

init_protected:
    mov     $0x10,%ax
    mov     %ax,%ds
    mov     %ax,%es
    mov     %ax,%fs
    mov     %ax,%gs
    mov     $0x18,%ax
    mov     %ax,%ss
    mov     $STACK_BASE,%ebx
    movl    $STACK_LIMIT,%ecx
    movl    $4096, %eax
    mull    %ecx
    addl    %ebx,%eax
    sub     $16,%eax
    mov     %eax,%esp
    call    main
    jmp .

Code: Select all

./Kernel/main.o:     file format elf32-i386


Disassembly of section .text:

00000000 <f>:
   0:	55                   	push   %ebp
   1:	89 e5                	mov    %esp,%ebp
   3:	83 ec 18             	sub    $0x18,%esp
   6:	8b 45 08             	mov    0x8(%ebp),%eax
   9:	8b 00                	mov    (%eax),%eax
   b:	89 04 24             	mov    %eax,(%esp)
   e:	e8 fc ff ff ff       	call   f <f+0xf>
  13:	c9                   	leave  
  14:	c3                   	ret    

00000015 <f2>:
  15:	55                   	push   %ebp
  16:	89 e5                	mov    %esp,%ebp
  18:	83 ec 18             	sub    $0x18,%esp
  1b:	8b 45 08             	mov    0x8(%ebp),%eax
  1e:	89 04 24             	mov    %eax,(%esp)
  21:	e8 fc ff ff ff       	call   22 <f2+0xd>
  26:	c9                   	leave  
  27:	c3                   	ret    

00000028 <main>:
  28:	55                   	push   %ebp
  29:	89 e5                	mov    %esp,%ebp
  2b:	83 e4 f0             	and    $0xfffffff0,%esp
  2e:	83 ec 20             	sub    $0x20,%esp
  31:	c7 05 00 00 00 00 09 	movl   $0x9,0x0
  38:	00 00 00 
  3b:	c7 44 24 1c 05 00 00 	movl   $0x5,0x1c(%esp)
  42:	00 
  43:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
  4a:	e8 fc ff ff ff       	call   4b <main+0x23>
  4f:	8d 44 24 1c          	lea    0x1c(%esp),%eax
  53:	89 04 24             	mov    %eax,(%esp)
  56:	e8 fc ff ff ff       	call   57 <main+0x2f>
  5b:	a1 00 00 00 00       	mov    0x0,%eax
  60:	89 04 24             	mov    %eax,(%esp)
  63:	e8 fc ff ff ff       	call   64 <main+0x3c>
  68:	8b 44 24 1c          	mov    0x1c(%esp),%eax
  6c:	89 04 24             	mov    %eax,(%esp)
  6f:	e8 fc ff ff ff       	call   70 <main+0x48>
  74:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
  7b:	e8 fc ff ff ff       	call   7c <main+0x54>
  80:	eb fe                	jmp    80 <main+0x58>
  82:	c9                   	leave  
  83:	c3                   	ret    

Code: Select all

printreg:
    #push   %ebp
    pusha
    movl    %esp,%ebp
    movl    $4,%ecx
    xor     %ebx,%ebx
    movl    36(%ebp),%eax
    start_printing:
    roll    $8,%eax
    movb    %al,%bl
    shrb    $4,%bl
    call    printNible
    movb    %al,%bl
    andb    $0x0f,%bl
    call    printNible
    loop    start_printing
    mov     %ebp,%esp
    popa
    #pop    %ebp
    ret

printNible:
    cmpb    $0xA,%bl
    jl      lessthen_0xA
    addb    $0x37,%bl
    push    %ebx
    call    printchar
    pop     %ebx
    ret
    lessthen_0xA:
    addb    $0x30,%bl
    push    %ebx
    call    printchar
    pop     %ebx
    ret

...

.global printint
.type printint, @function
printint:
    push    %ebp
    mov     %esp, %ebp
    movl    8(%ebp), %eax
    push    %eax
    call    printreg
    push    $10
    call    printchar
    mov     %ebp, %esp
    pop     %ebp
    ret

Code: Select all

00000028 <main>:
38:   00 00 00 
42:   00 

Code: Select all

4a:   e8 fc ff ff ff          call   4b <main+0x23>
4f:   8d 44 24 1c             lea    0x1c(%esp),%eax

Code: Select all

    mov     %ax,%ss
    mov     $STACK_BASE,%ebx
    movl    $STACK_LIMIT,%ecx
    movl    $4096, %eax
    mull    %ecx
    addl    %ebx,%eax
    sub     $0x20,%eax
    mov     %eax,%esp