View Full Version : خبر: VIVA 64 - Build 64bits program on 32bits platform or win32 on VS

دوشنبه 20 خرداد 1387, 18:48 عصر
بنا به اقتضای کارم و نبود ابزار مناسب جستجو در اینترنت مفید بود و به ابزار مناسبی برخورد کردم:
بعد از نصب نسخه محدود VS به صورت تصویر ضمیمه شد
بهرحال مستندات ذیل گویا هستند:

Viva64 (http://www.viva64.com/) is a tool designed for software developers. With this tool, you can easily convert 32-bit applications to 64-bit ones.

A problem of the nearest future: release of 64-bit applications

Personal computers with 64-bit processors appeared on the market only at the beginning of 2006. Right after that, developers began to modify their applications to make them compatible with the new architecture. However, it suddenly turned out that applications could work incorrectly when running on new platforms. Standard means of diagnostics do not allow determining the new class of errors that occur in applications, and it is not good to leave those errors unfixed either.
The necessity to convert applications to 64-bit ones placed developers in a difficult situation. The behavior of applications that have worked for years without any problems has become unpredictable. Of course, there is more random access memory for applications, however, when working with greater amounts of data applications may hang, crash, or even they may generate useless files instead of the needed results.

Viva64 is a solution to the problem

One of possible solutions that can be used to search for errors when converting code is the use of special tools - static code analyzers. Viva64 is one of such tools. It is a code analyzer that finds potential errors in applications written in C and C++.
Viva64 is integrated into Microsoft Visual Studio 2005 as its extension module. Below is the appearance of Microsoft Visual Studio 2005 with Viva64 integrated into it.

Figure 1. The appearance of Microsoft Visual Studio 2005 with Viva64 integrated into it.

This allows developers to work with Viva64 in a familiar environment - there is no need to spend time on familiarizing with a new interface. Viva64 just adds a few new elements (in Fig.1 they are marked with red): the Viva64 menu item, a toolbar containing Viva64 commands and a window containing the list of found problems. Any developer can easily figure out how to work with Viva64.
Figure 2 demonstrates an example of Viva64 documentation. This is a description of one of the errors found by the code analyzer. The description is in the format that is compatible with the standard MSDN help system, and it can be automatically integrated into it. So, developers will not have to familiarize themselves with a new help system.

Figure 2 – A description of an error found by Viva64.

Viva64 allows you to:

find incorrect constructions in code (from the point of view of 64-bit applications);

make a precise and complete diagnostic of errors, right up to the line number and error description;

navigate to incorrect code snippets;

analyze the aftermath an error may cause. This is done with the help of detailed documentation that is integrated into the MSDN help system;

find ways to fix problems by using examples the documentation contains;

analyze the code of the entire project or solution (in Microsoft Visual Studio terminology), but not only single files.

Viva64 and competitors' products

I'd like to name the main competitors of Viva64, as well as similar means of analysis.
First of all, I'd like to note that Microsoft Visual Studio 2005 already includes a primitive tool that searches for possible conversion problems. However, this tool is not a Viva64 competitor, since it provides only preliminary code analysis. Viva64 provides a much higher level of code analysis and diagnostics.

Below is a list of tools that are similar to Viva64:

Parasoft C++test (www.parasoft.com (http://www.parasoft.com/));

Gimpel Software PC-Lint (www.gimpel.com (http://www.gimpel.com/)).

The above-mention products are code analyzers as well. Here is what makes Viva64 different:

Viva64 searches only for those errors that occur during code conversion. The competitive tools are general-purpose code analyzers. Though it is announced that the competitive tools can search for conversion problems, it's actually hard to use them to analyze Windows applications. The point is that they are mainly intended for Unix applications.

Viva64 is completely integrated into Microsoft Visual Studio, which makes it possible to navigate to files, projects and solutions, jump to problematic code snippets and use the integrated help system.

Since Viva64 is used only for one purpose (it searches only for conversion errors) it's very easy to customize it. Viva64 is ready to function right after it is installed, which is a real advantage that the competitive products do not have.


In general, I can say that the use of Viva64 will allow you to greatly reduce the time needed to prepare 64-bit applications for the release. This happens because potentially dangerous code snippets are found automatically - there is no need to spend a lot of time searching for them manually.
Also, Viva64 brings your applications to a higher quality level. It's quite possible that developers can miss some errors when analyzing code manually. Viva64 allows you to avoid this.

یک مقاله:

64 bits, Wp64, Visual Studio 2008, Viva64 and all the rest...

Andrey Karpov
E-Mail: karpov@Viva64.com
Date: April 2008

The purpose of this article is to answer some questions related to safe port of C/C++ code on 64-bit systems. The article is written as an answer to the topic often discussed on forums and related to the use of /Wp64 key and Viva64 tool.

I am a developer of a static code analyzer Viva64 [1 (http://www.viva64.com/articles/Viva64_-_what_is_and_for.html)], intended for diagnosing errors in 64-bit programs (http://javascript<b></b>:void(0)). The analyzer integrates into Visual Studio 2005/2008 environment and allows you to check if C/C++ code is correct according to the set of corresponding rules [2 (http://www.viva64.com/articles/Verification_of_the_64-bit_Applications.html)]. Potentially dangerous code sections detected by Viva64 tool may be analyzed and corrected in time and it reduces costs on testing and maintenance a lot [3 (http://www.viva64.com/articles/Problems_of_testing_64-bit_applications.html)].
While communicating with software developers (http://javascript<b></b>:void(0)) on forums, via e-mail or at conferences I've noticed that there are some mistakes which lead to incorrect questions, remarks and comments. Within the limits of this article I want to try to clarify these points related to the use of 64-bit compilers (http://javascript<b></b>:void(0)), /Wp64 key and static analyzer Viva64. For that I will put several general questions and then answer them. I hope these answers will help you to better understand 64-bit technologies and find right solutions of different tasks.

1. What is /Wp64 key?

Wp64 key tells the compiler (http://javascript<b></b>:void(0)) to search possible errors which may occur during compilation of code for 64-bit systems. The check consists in that types marked in 32-bit code by __w64 keyword are interpreted as 64-bit types.

For example, we have the following code:
typedef int MyInt32;
#ifdef _WIN64
typedef __int64 MySSizet;
typedef int MySSizet;
void foo() {
MyInt32 value32 = 10;
MySSizet size = 20;
value32 = size;

Expression "value32 = size;" will cause contraction of value and consequently a potential error. We want to diagnose this case. But during compilation of a 32-bit application everything is correct and we won't get an warning message

To deal with 64-bit systems we should add /Wp64 key and insert __w64 keyword while defining MySSizet type in a 32-bit version. As a result the code will look like this:
typedef int MyInt32;
#ifdef _WIN64
typedef __int64 MySSizet;
typedef int __w64 MySSizet; // Add __w64 keyword
void foo() {
MyInt32 value32 = 10;
MySSizet size = 20;
value32 = size; // C4244 64-bit int assigned to 32-bit int

Now we'll get an warning message C4244 which will help us to prepare the port of the code on a 64-bit platform.

Pay attention that /Wp64 key doesn't matter for the 64-bit compilation mode as all the types already have the necessary size and the compiler will carry the necessary checks. It means that while compiling the 64-bit version even with /Wp64 key switched off we'll get C4244 message.

That's why, if you regularly compile you code in 64-bit mode you may refuse using /Wp64 in 32-bit code as in this mode the check is fuller. Besides, diagnosis systems with /Wp64 key is not perfect and often can cause false response or, just on the contrary, miss of messages. To learn more about this problem you may see the following links [4 (http://www.pluralsight.com/blogs/keith/archive/2005/01/13/4940.aspx), 5 (http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=2956204&SiteID=1)].

2. Why do we need Viva64 analyzer if we have /Wp64?

This question is one of the most frequent but it is actually incorrect. Let's at first refer to some analogy. Modern C/C++ compilers give a lot of messages warning about potential errors. But this doesn't decrease the urgency of such tools as lint, Gimpel PC-Lint, Parasoft C++Test or Abraxas CodeCheck. And nobody asks what for we need these analyzers if Visual C++ compiler contains /Wp64 key or /Wall key?

The compiler's task is to detect syntax errors in programs and to give messages on the main potential type errors. The need of the diagnosis's details to be limited is related to the necessity of choosing a reasonable number of diagnoses that could be useful for all programmers. Another reason is the requirement that the compiler should be high-performance. Some checks take a lot of time but many programmers may not need it.

Universal static analyzers allow you to diagnose large classes of potential errors and bad coding style - that is, everything that is absent in the compiler. The static analyzer's settings are adjusted for concrete tasks and give detailed information about errors in which a developer is interested. Although static analyzers are launched regularly they are not launched during compilation of every file being developed. This allows you to carry rather deep analysis demanding more time. Static analysis is an excellent methodology among others which help to increase quality and safety of the code.

Similar to this is the situation with checking compatibility of the code with 64-bit systems. We have briefly discussed what we get with the help of /Wp64 key. This key is a great help for a programmer but it cannot be useful in every case. Unfortunately, there are much more cases of type errors related to the use of 64-bit systems. These type errors are described in detail in the article "20 issues of porting C++ code on the 64-bit platform" [6 (http://www.viva64.com/articles/20_issues_of_porting_C++_code_on_the_64-bit_platform.html)] which I strongly recommend you. It is the great difference in the number of checks provided by /Wp64 and the number of necessary checks why we need a specialized tool. Viva64 is such a tool.

There is one more related question: "Some analyzers such as Gimpel PC-Lint or Parasoft C++Test support diagnosis of 64-bit errors. Why do we need Viva64 then?" It's true that these analyzers support diagnosis of 64-bit errors, but firstly it is not so thorough. For example, some errors related to the peculiarities of modern C++ language are not taken into consideration. And secondly, these analyzers work with Unix-systems data models and cannot analyze 64-bit programs developed in Visual Studio environment. To learn more about all this see "Forgotten problems of development of 64-bit programs" [7 (http://www.viva64.com/articles/Forgotten_problems.html)].

Summary: /Wp64 key and other static analyzers don't reduce the need of Viva64.

3. Why is /Wp64 key declared deprecated in Visual Studio 2008?

There is a wrong opinion that /Wp64 key is declared deprecated because diagnosis of 64-bit errors has become much better in Visual Studio 2008. But it is not so.

/Wp64 key is declared deprecated in Visual Studio 2008 only because it has become unnecessary. The time to "prepare for 64-bit code" has passed and now it's high time to create 64-bit programs. For that there is a 64-bit compiler in Visual Studio 2008 (as well as in Visual Studio 2005).

/Wp64 key is useful only in mode of compilation of 32-bit programs. It was created to detect some errors in time which the program will face in future after migration on 64-bit systems.

During compilation of a 64-bit program /Wp64 key is of no purpose. The compiler of 64-bit applications carries automatic checks similar to /Wp64 but more accurate. While compiling 32-bit programs /Wp64 mode glitched and it resulted in false error messages. It is not very pleasant and many developers complained of it and asked to upgrade this mode. Visual C++ developers have acted, in my opinion, very reasonably. Instead of wasting time on upgrading /Wp64 they declared it outdated. By this they:
encourage programmers to compile their programs with the help of the 64-bit compiler;
simplify the system of the compiler's commands (which is overload enough) by removing the temporary auxiliary key;
get rid of requests to upgrade this key.

4. Does Viva64 tool remain topical if we switch to Visual Studio 2008?

Yes, it does as nothing has changed. The compiler hasn't changed much what creation of 64-bit programs is concerned. /Wp64 key in the 32-bit compiler was declared deprecated to stimulate switching to 64-bit systems but it doesn't concern Viva64. Viva64 analyzer detects much more potential "64-bit" errors than 64-bit compiler Visual C++ 2005/2008 and is used successfully by many developers.

I would like once more to devote some time to the fight with "evangelists" who propagate that the compiler can diagnose all the 64-bit errors and that refusing to use /Wp64 key just confirms it.

I ask you to reread the article "20 issues of porting C++ code on the 64-bit platform" [6 (http://www.viva64.com/articles/20_issues_of_porting_C++_code_on_the_64-bit_platform.html)]. Please, think about it!

The compiler cannot give messages on constructions of the following kind:
unsigned i;
size_t size;
for (i = 0; i != size; i++)

Or, for example:
int x, y, z, w, h;
int position = x + y * w + z * w * h;
bigArray[position] = 0.0f;

These are classical widely spread constructions. They are safe in most cases, and developers of compilers won't introduce warning messages on such constructions although they are potentially dangerous while porting on 64-bit systems! They should be analyzed at least once. Such errors are difficult to detect and they occur only in large data arrays or while processing a large number of items.

But all these problems can be easily solved if you look through the code with the help of Viva64. Please, don't deceive developers convincing them that everything is OK in their programs. You won't do them any good but may encourage them to switch to 64-bit systems carelessly and thus bring some rare errors which will occur only when a program will be launched..


/Wp64 key is useful but not sufficient at all to guarantee that a 64-bit program will work.
For deeper analysis of 64-bit code one should use static analyzers providing corresponding checks.
The specialized Viva64 tool is the best solution to check C/C++ code for the 64-bit versions of Windows.


Evgeniy Ryzhkov. Viva64: what is it and for whom is it meant? http://www.Viva64.com/articles/Viva64_-_what_is_and_for.html (http://www.viva64.com/articles/Viva64_-_what_is_and_for.html)

Andrey Karpov, Evgeniy Ryzhkov. Static code analysis for verification of 64-bit applications. http://www.viva64.com/articles/Verificatio...plications.html (http://www.viva64.com/articles/Verification_of_the_64-bit_Applications.html)

Andrey Karpov. Problems of testing 64-bit applications. http://www.viva64.com/articles/Problems_of...plications.html (http://www.viva64.com/articles/Problems_of_testing_64-bit_applications.html)

Keith Brown, SetWindowLongPtr and /Wp64. http://www.pluralsight.com/blogs/keith/arc...01/13/4940.aspx (http://www.pluralsight.com/blogs/keith/archive/2005/01/13/4940.aspx)

MSDN Forum, http://forums.microsoft.com/MSDN/ShowPost....04&SiteID=1 (http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=2956204&SiteID=1)

Andrey Karpov, Evgeniy Ryzhkov. 20 Issues of Porting C++ Code on the 64-bit Platform. http://www.viva64.com/articles/20_issues_o...t_platform.html (http://www.viva64.com/articles/20_issues_of_porting_C++_code_on_the_64-bit_platform.html)

Andrey Karpov. Forgotten problems of 64-bit programs development. http://www.viva64.com/articles/Forgotten_problems.html (http://www.viva64.com/articles/Forgotten_problems.html)

دوشنبه 20 خرداد 1387, 19:37 عصر
لطفا تاپیک را ویرایش کنید و لینک عکس ها را قرار دهید ، چون این طوری درست نمی توانیم مطالب را مشاهده کنیم.

موفق باشید