Difference between Inline function and Ordinary function

Discussion in 'C++' started by Amal P, Sep 7, 2006.

  1. Amal P

    Amal P Guest

    Hi,

    This is the program that i made to test the usage of inline
    function. I am using vc 6.0 compiler. Please see the below program.

    int NonInline( int a, int b )
    {
    return ( a > b )? a: b;
    }

    inline int InLineFun( int a, int b )
    {
    return ( a > b )? a: b;
    }

    int main(int argc, char* argv[])
    {
    int a=10,b=20;
    NonInline( a,b );
    InLineFun( a,b );
    return 0;
    }

    When i compile this source code with vc6.0 compiler i can get the
    following code,

    ; Listing generated by Microsoft (R) Optimizing Compiler Version
    12.00.9044.0

    TITLE D:\Personal Data\VC Studies\AssembleAnalyze\AssembleAnalyze.cpp
    .386P
    include listing.inc
    if @Version gt 510
    ..model FLAT
    else
    _TEXT SEGMENT PARA USE32 PUBLIC 'CODE'
    _TEXT ENDS
    _DATA SEGMENT DWORD USE32 PUBLIC 'DATA'
    _DATA ENDS
    CONST SEGMENT DWORD USE32 PUBLIC 'CONST'
    CONST ENDS
    _BSS SEGMENT DWORD USE32 PUBLIC 'BSS'
    _BSS ENDS
    $$SYMBOLS SEGMENT BYTE USE32 'DEBSYM'
    $$SYMBOLS ENDS
    $$TYPES SEGMENT BYTE USE32 'DEBTYP'
    $$TYPES ENDS
    _TLS SEGMENT DWORD USE32 PUBLIC 'TLS'
    _TLS ENDS
    ; COMDAT ?NonInline@@YAHHH@Z
    _TEXT SEGMENT PARA USE32 PUBLIC 'CODE'
    _TEXT ENDS
    ; COMDAT ?InLineFun@@YAHHH@Z
    _TEXT SEGMENT PARA USE32 PUBLIC 'CODE'
    _TEXT ENDS
    ; COMDAT _main
    _TEXT SEGMENT PARA USE32 PUBLIC 'CODE'
    _TEXT ENDS
    FLAT GROUP _DATA, CONST, _BSS
    ASSUME CS: FLAT, DS: FLAT, SS: FLAT
    endif

    INCLUDELIB LIBCD
    INCLUDELIB OLDNAMES

    PUBLIC ?NonInline@@YAHHH@Z ; NonInline
    ; Function compile flags: /Odt /GZ /ZI
    ; File D:\Personal Data\VC Studies\AssembleAnalyze\AssembleAnalyze.cpp
    ; COMDAT ?NonInline@@YAHHH@Z
    _TEXT SEGMENT
    _a$ = 8
    _b$ = 12
    ?NonInline@@YAHHH@Z PROC NEAR ; NonInline, COMDAT

    ; 7 : {

    push ebp
    mov ebp, esp
    sub esp, 68 ; 00000044H
    push ebx
    push esi
    push edi
    lea edi, DWORD PTR [ebp-68]
    mov ecx, 17 ; 00000011H
    mov eax, -858993460 ; ccccccccH
    rep stosd

    ; 8 : return ( a > b )? a: b;

    mov eax, DWORD PTR _a$[ebp]
    cmp eax, DWORD PTR _b$[ebp]
    jle SHORT $L546
    mov ecx, DWORD PTR _a$[ebp]
    mov DWORD PTR -68+[ebp], ecx
    jmp SHORT $L547
    $L546:
    mov edx, DWORD PTR _b$[ebp]
    mov DWORD PTR -68+[ebp], edx
    $L547:
    mov eax, DWORD PTR -68+[ebp]

    ; 9 : }

    pop edi
    pop esi
    pop ebx
    mov esp, ebp
    pop ebp
    ret 0
    ?NonInline@@YAHHH@Z ENDP ; NonInline
    _TEXT ENDS
    PUBLIC ?InLineFun@@YAHHH@Z ; InLineFun
    PUBLIC _main
    EXTRN __chkesp:NEAR
    ; Function compile flags: /Odt /GZ /ZI
    ; COMDAT _main
    _TEXT SEGMENT
    _a$ = -4
    _b$ = -8
    _main PROC NEAR ; COMDAT

    ; 17 : {

    push ebp
    mov ebp, esp
    sub esp, 72 ; 00000048H
    push ebx
    push esi
    push edi
    lea edi, DWORD PTR [ebp-72]
    mov ecx, 18 ; 00000012H
    mov eax, -858993460 ; ccccccccH
    rep stosd

    ; 18 : int a=10,b=20;

    mov DWORD PTR _a$[ebp], 10 ; 0000000aH
    mov DWORD PTR _b$[ebp], 20 ; 00000014H

    ; 19 : NonInline( a,b );

    mov eax, DWORD PTR _b$[ebp]
    push eax
    mov ecx, DWORD PTR _a$[ebp]
    push ecx
    call ?NonInline@@YAHHH@Z ; NonInline
    add esp, 8

    ; 20 : InLineFun( a,b );

    mov eax, DWORD PTR _b$[ebp]
    push eax
    mov ecx, DWORD PTR _a$[ebp]
    push ecx
    call ?InLineFun@@YAHHH@Z ; InLineFun
    add esp, 8

    ; 21 : return 0;

    xor eax, eax

    ; 22 : }

    pop edi
    pop esi
    pop ebx
    add esp, 72 ; 00000048H
    cmp ebp, esp
    call __chkesp
    mov esp, ebp
    pop ebp
    ret 0
    _main ENDP
    ; Function compile flags: /Odt /GZ /ZI
    _TEXT ENDS
    ; COMDAT ?InLineFun@@YAHHH@Z
    _TEXT SEGMENT
    _a$ = 8
    _b$ = 12
    ?InLineFun@@YAHHH@Z PROC NEAR ; InLineFun, COMDAT

    ; 12 : {

    push ebp
    mov ebp, esp
    sub esp, 68 ; 00000044H
    push ebx
    push esi
    push edi
    lea edi, DWORD PTR [ebp-68]
    mov ecx, 17 ; 00000011H
    mov eax, -858993460 ; ccccccccH
    rep stosd

    ; 13 : return ( a > b )? a: b;

    mov eax, DWORD PTR _a$[ebp]
    cmp eax, DWORD PTR _b$[ebp]
    jle SHORT $L553
    mov ecx, DWORD PTR _a$[ebp]
    mov DWORD PTR -68+[ebp], ecx
    jmp SHORT $L554
    $L553:
    mov edx, DWORD PTR _b$[ebp]
    mov DWORD PTR -68+[ebp], edx
    $L554:
    mov eax, DWORD PTR -68+[ebp]

    ; 14 : }

    pop edi
    pop esi
    pop ebx
    mov esp, ebp
    pop ebp
    ret 0
    ?InLineFun@@YAHHH@Z ENDP ; InLineFun
    _TEXT ENDS
    END

    And my doubt is there is no difference in the calling of the inline
    function and the non inline function. Why is it so? Wont inline
    function's code get replaced inside the calling function?

    Thanks,
    Amal P.
     
    Amal P, Sep 7, 2006
    #1
    1. Advertising

  2. Amal P

    Amal P Guest

    I am sorry. I found my mistake. The problem was there is compiler
    option to set. Or else you have make release build in vc6.0




    Amal P wrote:
    > Hi,
    >
    > This is the program that i made to test the usage of inline
    > function. I am using vc 6.0 compiler. Please see the below program.
    >
    > int NonInline( int a, int b )
    > {
    > return ( a > b )? a: b;
    > }
    >
    > inline int InLineFun( int a, int b )
    > {
    > return ( a > b )? a: b;
    > }
    >
    > int main(int argc, char* argv[])
    > {
    > int a=10,b=20;
    > NonInline( a,b );
    > InLineFun( a,b );
    > return 0;
    > }
    >
    > When i compile this source code with vc6.0 compiler i can get the
    > following code,
    >
    > ; Listing generated by Microsoft (R) Optimizing Compiler Version
    > 12.00.9044.0
    >
    > TITLE D:\Personal Data\VC Studies\AssembleAnalyze\AssembleAnalyze.cpp
    > .386P
    > include listing.inc
    > if @Version gt 510
    > .model FLAT
    > else
    > _TEXT SEGMENT PARA USE32 PUBLIC 'CODE'
    > _TEXT ENDS
    > _DATA SEGMENT DWORD USE32 PUBLIC 'DATA'
    > _DATA ENDS
    > CONST SEGMENT DWORD USE32 PUBLIC 'CONST'
    > CONST ENDS
    > _BSS SEGMENT DWORD USE32 PUBLIC 'BSS'
    > _BSS ENDS
    > $$SYMBOLS SEGMENT BYTE USE32 'DEBSYM'
    > $$SYMBOLS ENDS
    > $$TYPES SEGMENT BYTE USE32 'DEBTYP'
    > $$TYPES ENDS
    > _TLS SEGMENT DWORD USE32 PUBLIC 'TLS'
    > _TLS ENDS
    > ; COMDAT ?NonInline@@YAHHH@Z
    > _TEXT SEGMENT PARA USE32 PUBLIC 'CODE'
    > _TEXT ENDS
    > ; COMDAT ?InLineFun@@YAHHH@Z
    > _TEXT SEGMENT PARA USE32 PUBLIC 'CODE'
    > _TEXT ENDS
    > ; COMDAT _main
    > _TEXT SEGMENT PARA USE32 PUBLIC 'CODE'
    > _TEXT ENDS
    > FLAT GROUP _DATA, CONST, _BSS
    > ASSUME CS: FLAT, DS: FLAT, SS: FLAT
    > endif
    >
    > INCLUDELIB LIBCD
    > INCLUDELIB OLDNAMES
    >
    > PUBLIC ?NonInline@@YAHHH@Z ; NonInline
    > ; Function compile flags: /Odt /GZ /ZI
    > ; File D:\Personal Data\VC Studies\AssembleAnalyze\AssembleAnalyze.cpp
    > ; COMDAT ?NonInline@@YAHHH@Z
    > _TEXT SEGMENT
    > _a$ = 8
    > _b$ = 12
    > ?NonInline@@YAHHH@Z PROC NEAR ; NonInline, COMDAT
    >
    > ; 7 : {
    >
    > push ebp
    > mov ebp, esp
    > sub esp, 68 ; 00000044H
    > push ebx
    > push esi
    > push edi
    > lea edi, DWORD PTR [ebp-68]
    > mov ecx, 17 ; 00000011H
    > mov eax, -858993460 ; ccccccccH
    > rep stosd
    >
    > ; 8 : return ( a > b )? a: b;
    >
    > mov eax, DWORD PTR _a$[ebp]
    > cmp eax, DWORD PTR _b$[ebp]
    > jle SHORT $L546
    > mov ecx, DWORD PTR _a$[ebp]
    > mov DWORD PTR -68+[ebp], ecx
    > jmp SHORT $L547
    > $L546:
    > mov edx, DWORD PTR _b$[ebp]
    > mov DWORD PTR -68+[ebp], edx
    > $L547:
    > mov eax, DWORD PTR -68+[ebp]
    >
    > ; 9 : }
    >
    > pop edi
    > pop esi
    > pop ebx
    > mov esp, ebp
    > pop ebp
    > ret 0
    > ?NonInline@@YAHHH@Z ENDP ; NonInline
    > _TEXT ENDS
    > PUBLIC ?InLineFun@@YAHHH@Z ; InLineFun
    > PUBLIC _main
    > EXTRN __chkesp:NEAR
    > ; Function compile flags: /Odt /GZ /ZI
    > ; COMDAT _main
    > _TEXT SEGMENT
    > _a$ = -4
    > _b$ = -8
    > _main PROC NEAR ; COMDAT
    >
    > ; 17 : {
    >
    > push ebp
    > mov ebp, esp
    > sub esp, 72 ; 00000048H
    > push ebx
    > push esi
    > push edi
    > lea edi, DWORD PTR [ebp-72]
    > mov ecx, 18 ; 00000012H
    > mov eax, -858993460 ; ccccccccH
    > rep stosd
    >
    > ; 18 : int a=10,b=20;
    >
    > mov DWORD PTR _a$[ebp], 10 ; 0000000aH
    > mov DWORD PTR _b$[ebp], 20 ; 00000014H
    >
    > ; 19 : NonInline( a,b );
    >
    > mov eax, DWORD PTR _b$[ebp]
    > push eax
    > mov ecx, DWORD PTR _a$[ebp]
    > push ecx
    > call ?NonInline@@YAHHH@Z ; NonInline
    > add esp, 8
    >
    > ; 20 : InLineFun( a,b );
    >
    > mov eax, DWORD PTR _b$[ebp]
    > push eax
    > mov ecx, DWORD PTR _a$[ebp]
    > push ecx
    > call ?InLineFun@@YAHHH@Z ; InLineFun
    > add esp, 8
    >
    > ; 21 : return 0;
    >
    > xor eax, eax
    >
    > ; 22 : }
    >
    > pop edi
    > pop esi
    > pop ebx
    > add esp, 72 ; 00000048H
    > cmp ebp, esp
    > call __chkesp
    > mov esp, ebp
    > pop ebp
    > ret 0
    > _main ENDP
    > ; Function compile flags: /Odt /GZ /ZI
    > _TEXT ENDS
    > ; COMDAT ?InLineFun@@YAHHH@Z
    > _TEXT SEGMENT
    > _a$ = 8
    > _b$ = 12
    > ?InLineFun@@YAHHH@Z PROC NEAR ; InLineFun, COMDAT
    >
    > ; 12 : {
    >
    > push ebp
    > mov ebp, esp
    > sub esp, 68 ; 00000044H
    > push ebx
    > push esi
    > push edi
    > lea edi, DWORD PTR [ebp-68]
    > mov ecx, 17 ; 00000011H
    > mov eax, -858993460 ; ccccccccH
    > rep stosd
    >
    > ; 13 : return ( a > b )? a: b;
    >
    > mov eax, DWORD PTR _a$[ebp]
    > cmp eax, DWORD PTR _b$[ebp]
    > jle SHORT $L553
    > mov ecx, DWORD PTR _a$[ebp]
    > mov DWORD PTR -68+[ebp], ecx
    > jmp SHORT $L554
    > $L553:
    > mov edx, DWORD PTR _b$[ebp]
    > mov DWORD PTR -68+[ebp], edx
    > $L554:
    > mov eax, DWORD PTR -68+[ebp]
    >
    > ; 14 : }
    >
    > pop edi
    > pop esi
    > pop ebx
    > mov esp, ebp
    > pop ebp
    > ret 0
    > ?InLineFun@@YAHHH@Z ENDP ; InLineFun
    > _TEXT ENDS
    > END
    >
    > And my doubt is there is no difference in the calling of the inline
    > function and the non inline function. Why is it so? Wont inline
    > function's code get replaced inside the calling function?
    >
    > Thanks,
    > Amal P.
     
    Amal P, Sep 7, 2006
    #2
    1. Advertising

  3. Amal P

    Guest

    Amal P wrote:
    > Hi,
    >
    > This is the program that i made to test the usage of inline
    > function. I am using vc 6.0 compiler. Please see the below program.
    >
    > int NonInline( int a, int b )
    > {
    > return ( a > b )? a: b;
    > }
    >
    > inline int InLineFun( int a, int b )
    > {
    > return ( a > b )? a: b;
    > }


    No real difference there. Since these are the only two definitions, it
    doesn't
    matter, but you could define InLineFun again in another Translation
    Unit.
    Now, "inline" is also a suggestion to the compiler that the function
    call
    overhead may exceed the work done in the function, but a good compiler
    can figure that out anyway. All functions are visible tot he compiler.

    Usually, the inline keyword is (should be) used only after profiling
    shows
    that the compiler misjudged the call overhead versus work done ratio.

    HTH,
    Michiel Salters
     
    , Sep 8, 2006
    #3
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. jakk
    Replies:
    4
    Views:
    12,636
  2. prabhu
    Replies:
    3
    Views:
    792
    Roger Leigh
    Jan 27, 2004
  3. baumann@pan
    Replies:
    2
    Views:
    997
    baumann@pan
    May 19, 2005
  4. TGOS
    Replies:
    3
    Views:
    403
    Kevin Bracey
    Feb 28, 2005
  5. SpOiLeR
    Replies:
    10
    Views:
    855
    SpOiLeR
    Oct 19, 2005
Loading...

Share This Page