Linking to C/C++ in Protected Mode

Linking to C/C++ in Protected Mode

Programs written for x86 processors running in Protected mode can sometimes have bottlenecks

that must be optimized for runtime efficiency. If they are embedded systems, they may have

stringent memory size limitations. With such goals in mind, we will show how to write external

procedures in assembly language that can be called from C and C++ programs running in Protected mode. Such programs consist of at least two modules: The first, written in assembly

language, contains the external procedure; the second module contains the C/C++ code that

starts and ends the program. There are a few specific requirements and features of C/C++ that

affect the way you write assembly code.

Arguments(实参) Arguments are passed by C/C++ programs from right to left, as they appear in

the argument list. After the procedure returns, the calling program is responsible for cleaning up

the stack. This can be done by either adding a value to the stack pointer equal to the size of the

arguments or popping an adequate number of values from the stack.

External Identifiers In the assembly language source, specify the C calling convention in

the .MODEL directive and create a prototype for each procedure called from an external C/C++

program:

.586

.model flat,C

AsmFindArray PROTO,

srchVal:DWORD, arrayPtr:PTR DWORD, count:DWORD

Declaring the Function In a C program, use the extern qualifier when declaring an external

assembly language procedure. For example, this is how to declare AsmFindArray:

extern bool AsmFindArray( long n, long array[], long count );

If the procedure will be called from a C++ program, add a “C” qualifier to prevent C++ name

decoration:

extern "C" bool AsmFindArray( long n, long array[], long count );

Name decoration is a standard C++ compiler technique that involves modifying a function name

with extra characters that indicate the exact type of each function parameter. It is required in any

language that supports function overloading (two functions having the same name, with different

parameter lists). From the assembly language programmer’s point of view, the problem with

name decoration is that the C++ compiler tells the linker to look for the decorated name rather

than the original one when producing the executable file.

13.3.1 Using Assembly Language to Optimize C++ Code

One of the ways you can use assembly language to optimize programs written in other languages

is to look for speed bottlenecks. Loops are good candidates for optimization because any

extra statements in a loop may be repeated enough times to have a noticeable effect on your program’s

performance.

Most C/C++ compilers have a command-line option that automatically generates an assembly

language listing of the C/C++ program. In Microsoft Visual C++, for example, the listing file can

contain any combination of C++ source code, assembly code, and machine code, shown by the

options in Table 13-2. Perhaps the most useful is /FAs, which shows how C++ statements are

translated into assembly language.

Table 13-2 Visual C++ Command-Line Options for ASM Code Generation.

 

 

 

Command Line	Contents of Listing File
/FA	Assembly-only listing
/FAc	Assembly with machine code
/FAs	Assembly with source code
/FAcs	Assembly, machine code, and source

FindArray Example

Let’s create a program that shows how a sample C++ compiler generates code for a function

named FindArray. Later, we will write an assembly language version of the function, attempting

to write more efficient code than the C++ compiler. The following FindArray function (in C++)

searches for a single value in an array of long integers:

bool FindArray( long searchVal, long array[], long count )

{

for(int i = 0; i < count; i++)

{

if( array[i] == searchVal )

return true;

}

return false;

}

FindArray Code Generated by Visual C++

Let’s look at the assembly language source code generated by Visual C++ for the FindArray

function, alongside the function’s C++ source code. This procedure was compiled to a Release

target with no code optimization in effect:

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

    TITLE    c:UsersStudDocumentsVisual Studio 2008ProjectsFindArrayFindArrayFindArray.cpp
    .686P
    .XMM
    include listing.inc
    .model    flat

INCLUDELIB MSVCRTD
INCLUDELIB OLDNAMES

PUBLIC    ?FindArray@@YA_NJQAJJ@Z                ; FindArray
EXTRN    __RTC_Shutdown:PROC
EXTRN    __RTC_InitBase:PROC
;    COMDAT rtc$TMZ
; File c:usersstuddocumentsvisual studio 2008projectsfindarrayfindarrayfindarray.cpp
rtc$TMZ    SEGMENT
__RTC_Shutdown.rtc$TMZ DD FLAT:__RTC_Shutdown
rtc$TMZ    ENDS
;    COMDAT rtc$IMZ
rtc$IMZ    SEGMENT
__RTC_InitBase.rtc$IMZ DD FLAT:__RTC_InitBase
; Function compile flags: /Odtp /RTCsu /ZI
rtc$IMZ    ENDS
;    COMDAT ?FindArray@@YA_NJQAJJ@Z
_TEXT    SEGMENT
_i$5245 = -8                        ; size = 4
_searchVal$ = 8                        ; size = 4
_array$ = 12                        ; size = 4
_count$ = 16                        ; size = 4
?FindArray@@YA_NJQAJJ@Z PROC                ; FindArray, COMDAT
; Line 7
    push    ebp
    mov    ebp, esp
    sub    esp, 204                ; 000000ccH
    push    ebx
    push    esi
    push    edi
    lea    edi, DWORD PTR [ebp-204]
    mov    ecx, 51                    ; 00000033H
    mov    eax, -858993460                ; ccccccccH
    rep stosd
; Line 8
    mov    DWORD PTR _i$5245[ebp], 0
    jmp    SHORT $LN4@FindArray
$LN3@FindArray:
    mov    eax, DWORD PTR _i$5245[ebp]
    add    eax, 1
    mov    DWORD PTR _i$5245[ebp], eax
$LN4@FindArray:
    mov    eax, DWORD PTR _i$5245[ebp]
    cmp    eax, DWORD PTR _count$[ebp]
    jge    SHORT $LN2@FindArray
; Line 10
    mov    eax, DWORD PTR _i$5245[ebp]
    mov    ecx, DWORD PTR _array$[ebp]
    mov    edx, DWORD PTR [ecx+eax*4]
    cmp    edx, DWORD PTR _searchVal$[ebp]
    jne    SHORT $LN1@FindArray
; Line 11
    mov    al, 1
    jmp    SHORT $LN5@FindArray
$LN1@FindArray:
; Line 12
    jmp    SHORT $LN3@FindArray
$LN2@FindArray:
; Line 13
    xor    al, al
$LN5@FindArray:
; Line 14
    pop    edi
    pop    esi
    pop    ebx
    mov    esp, ebp
    pop    ebp
    ret    0
?FindArray@@YA_NJQAJJ@Z ENDP                ; FindArray
_TEXT    ENDS
PUBLIC    _wmain
; Function compile flags: /Odtp /RTCsu /ZI
;    COMDAT _wmain
_TEXT    SEGMENT
_argc$ = 8                        ; size = 4
_argv$ = 12                        ; size = 4
_wmain    PROC                        ; COMDAT
; Line 16
    push    ebp
    mov    ebp, esp
    sub    esp, 192                ; 000000c0H
    push    ebx
    push    esi
    push    edi
    lea    edi, DWORD PTR [ebp-192]
    mov    ecx, 48                    ; 00000030H
    mov    eax, -858993460                ; ccccccccH
    rep stosd
; Line 18
    xor    eax, eax
; Line 19
    pop    edi
    pop    esi
    pop    ebx
    mov    esp, ebp
    pop    ebp
    ret    0
_wmain    ENDP
_TEXT    ENDS
END

Specify the /FA switch for the cl compiler. Depending on the value of the switch either only assembly code or high-level code and assembly code is integrated. The filename gets .asm file extension. Here are the supported values:

• /FA Assembly code; .asm
• /FAc Machine and assembly code; .cod
• /FAs Source and assembly code; .asm
• /FAcs Machine, source, and assembly code; .cod

Click "Project"-> Double Click "Configuration Properties（配置属性）"-> Choose "C/C++"-> Click "Output Files"->

 

Three 32-bit arguments were pushed on the stack in the following order: count, array, and
searchVal. Of these three, array is the only one passed by reference because in C/C++, an array
name is an implicit pointer to the array’s first element. The procedure saves EBP on the stack and
creates space for the local variable i by pushing an extra doubleword on the stack (Figure 13–1).

Inside the procedure, the compiler reserves local stack space for the variable i by pushing ECX
(line 9). The same storage is released at the end when EBP is copied back into ESP (line 14).
There are 14 instructions between the labels $L284 and $L285, which constitute the main body
of the loop. We can easily write an assembly language procedure that is more efficient than the
code shown here.