Microsoft Visual C++ Processor Pack Release Readme

© 2000 Microsoft Corporation. All rights reserved.

Welcome to the Microsoft Visual C++ Processor Pack Release with Service Pack 5 for Visual C++ 6.0. The Microsoft Visual C++ Processor Pack Release Readme contains the following sections:

• Setup Instructions
• Compiler-Specific Notes
• Debugger-Specific Notes
• Documentation Notes
• Fixed Issues in this Service Pack
• Intel Performance Libraries and Sample Files
• AMD Sample Files
• Using MASM to Assemble .asm Files

Setup Instructions

The Processor Pack requires that you have already installed Microsoft Visual C++ version 6.0 with Service Pack 5 or greater. To install Service Pack 5, go to the Product Updates page at http://msdn.microsoft.com/vstudio/downloads/updates.asp and download the appropriate version.

The Processor Pack also requires Microsoft Visual C++ version 6.0 Professional or Enterprise Editions. The Processor Pack will not install on the Standard Edition.

To install the Processor Pack, run Vcpp.exe. The Setup program overwrites your compiler files, and the Processor Pack documentation (procpack.chm) is installed in the Vc98 folder. MASM version 6.15 is installed in the bin folder, located in the Vc98 folder.

There is no uninstall; you must uninstall Microsoft Visual C++ 6.0 and manually remove the Processor Pack files.

Compiler-Specific Notes

• No EMMS Instruction Warning
  You may get the message "Warning C4799: Function x has no EMMS instruction" from the compiler in locations that no EMMS instruction is needed. To disable this warning, use #pragma warning.
• Rebuilding MFC with Processor Pack Compiler
  You cannot rebuild MFC with the Processor Pack compiler. Because of changes related to inlining, rebuilding MFC with the Processor Pack compiler results in link errors. The link errors are unresolved externals for CTime::operator members. If you need to rebuild MFC, you must uninstall Visual C++ 6.0, manually remove the files installed by Visual C++ Processor Pack and then reinstall Visual C++ 6.0 and any necessary service packs.
• Calling a Virtual Member Function in Constructor Invocation
  If you call a virtual member function in a constructor invocation, the compiler may generate an Internal Compiler Error message. To work around this, call the virtual member function and assign its return value to a temporary. Then pass this temporary in the construction invocation.
• Passing __m64 and __m128 Argument Types
  Passing multibyte argument types by value may result in a run time performance penalty. For __m64 and __m128 types, this is of particular concern because of the additional requirement of memory alignment. While this compiler imposes no restrictions on passing __m64 and __m128 types, a future release of the compiler will prohibit the passing of more than three __m64 or three __m128 types by value. The first 3 parameters are passed in registers, thus avoiding alignment and performance issues; it is recommended that the fourth __m64 or __m128 parameters and beyond be passed by reference. To avoid compatibility problems with future compilers and to enhance performance, do not pass more then three __m64 or __m128 types by value. There are no restrictions to passing these argument types by reference (pointers).

  An additional construct to avoid is passing a structure by value, particularly a structure that contains a __m64 or __m128 data type. In many case, accessing a __m64 or __m128 value in a structure passed by value results in an alignment exception being thrown.

• Variable Argument List and Passing __m64 and __m128 Argument Types
  Because of alignment issues, passing these argument types in a variable argument list by value is not supported. Future compilers may support this feature.
• Compatibility with Intel Compiler
  Some compatibility issues have been identified with mixing source and object files between the Microsoft Visual C++ Processor Pack compiler and the Intel C/C++ compiler. These issues arise when using __m64 and __m128 types. These problems are exposed when sharing these data types across compilers either as global variables or as formal parameters. To minimize any problems, it is recommended that uses of __m64 and __m128 types remain within the scope of a single compiler. Both compilers are in the process of eliminating these inconsistencies in future releases.

Debugger-Specific Notes

The debugger requires that if you are running Windows NT version 4.0, you must have Service Pack 5 or greater installed. For remote debugging, you must have Visual C++ with Service Pack 5 installed on both machines.

If you edit the value of a register from the Registers window or an EE window (such as QuickWatch or Watch), it may revert to the previous value once you step in the debugger. This affects STO-ST7, FPU status, MM0-MM7, XMM0-XMM7, XMM00-XMM73, and MM00-MM71 registers on Windows 95 and Windows 98.

Documentation Notes

Fixed Issues in this Service Pack

The problems with QIfist have been addressed in this service pack. If you encounter any problems using QIfist, report them to Microsoft Product Support Services at http://support.microsoft.com/directory.

Intel Performance Libraries and Sample Files

Intel performance libraries are available at http://developer.intel.com/vtune/perflibst/.

Intel SSE samples are available at http://developer.intel.com/vtune/cbts/strmsimd/appnotes.htm.

Intel SSE2 samples are available at http://developer.intel.com/vtune/cbts/strmsimd/sse2_appnotes.htm.

AMD Sample Files

AMD sample files are available in your installation folder. You can find them by going to the Samples folder in the Vc98 folder. Click the AMD folder, and there are two sample folders, Isdk and Asdk, which contain the sample files. You do not need a project; compile each sample with cl /Ox /DWIN32 /Fesample.exe *.cpp.

Using MASM to Assemble .asm Files

Microsoft Visual C++ does not support assembler source files by default, that is, the Developer Studio does not associate any special significance  to .asm files. However, there are two viable options. You can use the following two methods to add .asm files to a Visual C++ project. The methods are:

• Using custom build rules.
• Using an assembler to build the .obj file from the .asm file from the command line and add the .obj file to the project or add to the linker input files.

The use of custom build is described below. By using a custom build rule, a project can invoke MASM on a per-file basis to assemble .asm files. The resulting object modules are then automatically linked into the desired target.

For more information about MASM, see MASM Reference Documentation.

Using Visual C++ Developer Studio, the following provides sample code and a step-by-step example of how to create a simple console application, CAPP, that requires MASM (ML.exe) to assemble one of its source files.

Sample Code - C Module

/* Filename: CMAIN.C */ 

#include <stdio.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
void MasmSub (char *, short *, long *);
 
#ifdef __cplusplus
}
#endif

char chararray[4] = "abc";
short shortarray[3]  = {1, 2, 3};
long longarray[3] = {32768, 32769, 32770};

void main( void )
{
   printf ("%s\n", chararray);
   printf ("%d %d %d\n", shortarray[0], shortarray[1], shortarray[2]);
   printf ("%ld %ld %ld\n", longarray[0], longarray[1], longarray[2]);
   MasmSub (chararray, shortarray, longarray);
   printf ("%s\n", chararray);
   printf ("%d %d %d\n", shortarray[0], shortarray[1], shortarray[2]);
   printf ("%ld %ld %ld\n", longarray[0], longarray[1], longarray[2]);
} 

Sample Code - ASM Module

; Filename: MASMSUB.ASM
; Assemble options needed for ML: /c /Cx /coff

.386
.MODEL flat, C
.CODE

MasmSub PROC uses esi, \ 
   arraychar:PTR, \ 
   arrayshort:PTR, \ 
   arraylong:PTR
   mov esi, arraychar ; Load ESI with the address of the char array.
   mov BYTE PTR [esi], "x"      ; Since a char is 1 byte long, each
   mov BYTE PTR [esi+1], "y"    ; successive element can be accessed
   mov BYTE PTR [esi+2], "z"    ; by adding 1 more to esi.
   mov esi, arrayshort; Load ESI with the address of the short array.
   add WORD PTR [esi], 7        ; Since a short is 2 bytes long, each
   add WORD PTR [esi+2], 7      ; successive element can be accessed
   add WORD PTR [esi+4], 7      ; by adding 2 more to esi.
   mov esi, arraylong ; Load ESI with the address of the long array.
   inc DWORD PTR [esi]          ; Since a long is 4 bytes long, each
   inc DWORD PTR [esi+4]        ; successive element can be accessed
   inc DWORD PTR [esi+8]        ; by adding 4 more to esi.
   ret
MasmSub ENDP
END

Sample Code - Step-by-Step Instructions for Building CAPP

Use the following steps to create the project:

1. Start the Visual C++ Developer Studio program (Msdev.exe).
2. Create and save Cmain.c and MasmSub.asm.
3. On the File menu, click New. Create a new console application named CAPP.

Use the following steps to build the project:

1. On the Project menu, click Add To Project, and then click Files.
2. Find and select both Cmain.c and MasmSub.asm.
3. In the Project Workspace window, right-click the file MasmSub.asm and click Settings on the shortcu menu.
4. On the Project Settings dialog box, select All Configurations in the Settings For list.
5. Click the Custom Build tab.
6. In the first line of the Build command(s) dialog box, enter ml.exe. Then enter the desired MASM command-line options, -Fo immediately followed by the macros for the Intermediate directory and file Input Name followed by .obj with the macros separated by a backslash (\), and the macro for the file Input Name followed by .asm. Obtain the macros by selecting the Directories button and choosing Intermediate; then select the Files button and choose Input Name from the resulting menu. For example, the entry would appear as follows:

   ml.exe -c -coff -Cx -Fo$(IntDir)\$(InputName).obj $(InputName).asm

   Note that you must always add -c and -coff when using MASM. For the debug build, select the Win32 Debug configuration and add the -Zi switch.

7. In the first line of the Output file(s) dialog box, enter $(IntDir)\$(InputName).obj. You can obtain the macros with the same procedure used in step 6.
8. Select the desired build configuration. On the Build menu, click Rebuild All.

For more information on custom build rules, see the Visual C++ online Help for the Custom Build tab (press the Help button in the Project Settings dialog box when the Custom Build tab is selected).