When using Macro Assembler by Microsoft you should use the latest and greatest version because of the extended instruction sets. However, to use those new instructions you need to turn on functionality.

When using this assembler, the first thing you need to do is activate the appropriate CPU target by using one of the following assembler directives depending on what processor will be executing that section of code. There are several of these directives such as .386, .486, .586, etc. If the target is for an embedded 486, then obviously the .586 directive would not be used, as instructions would be allowed that the 486 would not understand. When you write your code for a single processor you can merely set the appropriate directive(s) at the top of the file, but quite often a single file will contain sets of code unique to individual processors.

There are other legacy declarations such as .387, .286, .386, .386P, .486, .486P, etc. The suffix "P" indicates an enabling of privileged instructions.

For more information, see http://msdn2.microsoft.com/library/afzk3475(en-us,vs.80).aspx.

Here is a sample file that you should be able to drop into a Win32 application in conjunction with the Visual C++ compiler:

        TITLE zipX86M.asm – My x86 (MASM) Assembly
        PAGE    53,160
;       This module is designed to Blah Blah Blah!
;
;       Created - 20 May 98 - J.Leiterman
;       Tabs = 8

        .686
        .MMX
        .K3D
        .model flat, C

        .data
        ALIGN 4
foo     dd       0                     ; Data value

zipX86M SEGMENT USE32 PUBLIC 'CODE'

;
; void unzip(byte *pRaw, byte *pZip, uint nWidth);
;

         align     16
unzip    PROC C PUBLIC USES ebx esi edi pRaw:PTR, pZip:PTR,
           nWidth:DWORD


         mov      esi,pRaw
         mov      edi,pZip
         mov      ecx,nWidth
         ;
         ;
         ;
         ret
unzip    endp


zipX86M  ends
         end

The function is declared PUBLIC, meaning it's global in definition and can therefore be accessed by functions in other files.

unzip  PROC C PUBLIC USES ebx esi edi pRaw:PTR, pZip:PTR,
         nWidth:DWORD

For convenience, you can specify the registers to push onto the stack and in what order. The RET instruction is actually a macro when used within this PROC, and therefore the registers are popped automatically in a reverse order wherever a RET instruction is encountered. The coup de grâce? No more pesky code like:

mov   esi,[ebp+arg1]        ; pRaw

Instead, you just use:

mov    esi,pRaw

The assembler expands the PROC macro and takes care of everything for you, making your code a little more readable.

You will notice that I used the default data segment (.data) as this is a flat memory model, but I declared a 32-bit Protected Mode code segment. The reasoning is that I tend to group my assembly files using an object-oriented approach and as such all my decompression functions/ procedures would reside within this segment. Other assembly code related to other functionality would be contained in a different file with a different segment name. They can occur with the same segment name but they wouldn't appear very organized, especially in the application address/data map.

zipX86M SEGMENT USE32 PUBLIC 'CODE'
:
:
zipX86M ends

Since segments are being mentioned I am going to give you a snapshot of segments back in the days of DOS and DOS extenders. Code and data was differentiated by 16-bit code/data versus 32-bit code/data addressing. The following is a snippet of code from those days.

;      Segment Ordering Sequence


       INN_CODE32   segment para USE32 'CODE'
       INN_CODE32   ends
       _TEXT        segment
       _TEXT        ends
       INN_DATA32   segment para USE32 'DATA'
       INN_DATA32   ends


       DGROUP       GROUP INN_DATA32
       CGROUP       GROUP _TEXT
       CGROUP       GROUP INN_CODE32

We also must not forget the (end) signal to the assembler that it has reached the end of the file:

End

I personally think this is just a carryover from the good old days of much simpler assemblers. With the advent of macros such as the following, you can turn on or off various sections of code and not just the bottom portion of your file:

if 0
else
endif

Visual C++ has never really had a peaceful coexistence with its own MASM Assembler. In the early days of around version 3.x you had to assemble your files using batch files or external make files and only link the *.obj files into your project files. Microsoft has fortunately made this a little simpler, but in my opinion it still seems shortsighted. My assumption is that they would prefer you to use either inline assembly or none at all. (But I've been known to be wrong before!)

The first thing you need to do is add the MASM hooks into your version 5.0 or above Visual C++ environment. Select the Tools|Options menu item, and then select the Directories tab. Set the following to the path of your MASM installation:

Executable Files:   c:masmin
                    c:masminr
Include Files:      c:masminclude

With your project loaded in your FileView tab, just right-click on the project files folder, and select the pop-up menu item Add Files to Project. The Insert Files into Project dialog box will be displayed. That dialog seems to support almost every file type known except for assembly! What you need to do is select the All Files (*.*) option, select the assembly file you desire, and then press the OK button.

Now that the file occurs in your list of files in your project, right-click on that file and select the Settings item from the pop-up menu. In the Commands edit box insert the following:

ml @MyGame.amk ..utilunzipx86.asm

This will execute the assembler using the option switches defined in the MyGame.amk file. In the Outputs edit box insert the following:

unzipx86.obj

Then press the OK button.

To make my life simpler I use a file, such as the following, that I refer to as my assembly make file. I clone it from project to project, as you'll never know when you'll need to tweak it.

File: MYGAME.AMK
      /L../util
      /c
      /coff
      /Cp
      /Fl
      /Fm
      /FR
      /Sg
      /Zd
      /Zi

For those of you who would prefer to use in-line assembly or just plain don't have an assembler, you can do the same thing with the following from within your C/C++ code.

Figure 20-1. VC6 assembler configuration display

void unzip(byte *pRaw, byte *pZip, uint nWidth)
{
    __asm {
        mov      esi,pRaw
        mov      edi,pZip
        mov      ecx,nWidth

      };
}

You should be very careful if you mix C/C++ and in-line assembly code unless you push the registers to save them. Setting a breakpoint at the beginning of your function and then examining the source code during run time can help point out any register use conflicts.

MASM is my favorite macro assembler as it has an excellent macro expansion ability. Not only can new instructions be incorporated by use of macros but the predefined macro expansion can be taken to advantage as they are C like. In some cases, I find it better than C. In fact, in-line assembly sucks! (Another technical term!) (Note: I only said in some cases!) The following are some of the highlights. For details, read the technical manuals. For example, the MASM toolset has the following manuals:

In the following charts, notice the C method on the left and the MASM method on the right.

Defines are pretty similar; however, enums do not exist and so must be emulated with a standard equate.

#define FOO 3                  FOO = 3


typedef enum
{
    CPUVEN_UNKNOWN = 0,        CPUVEN_UNKNOWN = 0
}  CPUVEN;

MASM can contain a structure definition just like C:

typedef struct CpuInfoType {            CpuInfo struct 4
   uint   nCpuId;  // CPU Id               nCpuId  dd 0   ; CPU Id
   uint   nFpuId;  // FPU Id               nFpuId  dd 0   ; FPU Id
   uint   nBits;   // Feature              nBits   dd 0   ; Feature
   uint   nMfg;    // Mfg                  nMfg    dd 0   ; Mfg.
   uint16 SerialNum[6];                    SerialNum dw 0,0,0,0,0,0
   uint   nSpeed;  // Speed                nSpeed  dd 0   ; Speed
} CpuInfo;                              CpuInfo ends

In C there is no looping macro expansion; there is only one-shot (a definition gets expanded). However, some special macro functionality is available when using a MACRO assembler.

i = 0
   REPEAT 5
mov [i + ebx],eax
i = i + 4
   ENDM

mov [0 + ebx],eax
mov [4 + ebx],eax
mov [8 + ebx],eax
mov [12 + ebx],eax
mov [16 + ebx],eax

i = 0
   WHILE i LE 20    ; <
mov [i + ebx],eax
i = i + 4
   ENDM

   FOR arg, <1,3,5,7,9,11,13,17,19,23>
out dx,arg
   ENDM

The more recent Visual C++ and Intel compilers support a method of programming in assembly language referred to as intrinsics. This is where the functionality of SIMD instructions has been wrapped within C wrappers and compiled into code as inline code. Let us examine the following example:

void test(float *c, float a, float b)
{
   *c = a + b;
}

Not to oversimplify the power of using intrinsics to get code up and running quickly, the following code uses intrinisics in conjunction with (__m128) XMM registers with SSE single-precision floating-point instructions. Note that it looks more complicated, but I chose a simple scalar expression to resolve.

#include <xmmintrin.h>


void test(float *c, float a, float b)
{
  __m128 ta, tb;

   ta = _mm_load_ps(&a);
   tb = _mm_load_ps(&b);

   ta = _mm_add_ps(ta, tb);
   _mm_store_ps(c, ta);
}

But underneath in the pure assembly code generated by the compiler this breaks down to something similar to the following:

push     ebx
mov      ebx,esp
sub      esp,8
and      esp,0FFFFFFF0h   ; 16-byte align stack
add      esp,4
push     ebp
mov      ebp,dword ptr [ebx+4]
mov      dword ptr [esp+4],ebp
mov      ebp,esp
sub      esp,98h
push     esi
push     edi
  ; __m128 ta, tb
  ; ta = _mm_load_ps(&a);
lea      eax,[ebx+0Ch]
movaps   xmm0,xmmword ptr [eax]
movaps   xmmword ptr [ebp-30h],xmm0
movaps   xmm0,xmmword ptr [ebp-30h]
movaps   xmmword ptr [ebp-10h],xmm0
  ; tb = _mm_load_ps(&b);
lea      eax,[ebx+10h]
movaps   xmm0,xmmword ptr [eax]
movaps   xmmword ptr [ebp-40h],xmm0
movaps   xmm0,xmmword ptr [ebp-40h]
movaps   xmmword ptr [ebp-20h],xmm0
  ; ta = _mm_add_ps(ta, tb);
movaps   xmm0,xmmword ptr [ebp-20h]
movaps   xmm1,xmmword ptr [ebp-10h]
addps    xmm1,xmm0
movaps   xmmword ptr [ebp-50h],xmm1
movaps   xmm0,xmmword ptr [ebp-50h]
movaps   xmmword ptr [ebp-10h],xmm0
  ; _mm_store_ps(c, ta);
movaps   xmm0,xmmword ptr [ebp-10h]
mov      eax,dword ptr [ebx+8]
movaps   xmmword ptr [eax],xmm0


pop      edi
pop      esi
mov      esp,ebp
pop      ebp
mov      esp,ebx
pop      ebx
ret