Als Programmierer, was brauche ich zu kümmern, wenn sie 64-Bit-Fenster zu verschieben?

StackOverflow https://stackoverflow.com/questions/544296

  •  23-08-2019
  •  | 
  •  

Frage

Die meisten meiner bisherigen Programmierung wurde auf 32-Bit-Windows mit C / C ++ / C # / VB6. In letzter Zeit fragen meine Kunden, wenn mein Code auf 64-Bit-Windows ausgeführt wird.

Ich frage mich, was für Legacy-Funktionen, die ich kann, dass auf 64-Bit-Windows brechen verwenden? Was sind einige der realen Welt Fragen, die ich brauchen, darüber nachzudenken und Sorgen über?

Natürlich werde ich meinen Code auf dem OS-64-Bit-Test, aber ich würde gerne wissen, was häufig gestellten Fragen zu suchen. Ich mehr mit den vorhandenen Binärdateien, aber ich bin offen für Kommentare über das, was zu befürchten, wenn neu zu kompilieren (wo möglich).

EDIT: Hier ist ein schöne Liste von 64-Bit-Portierung von Bugs.

Andere Tipps

Was mich betrifft, die wichtigste Sache über Windows-C / C ++ Code zu 64-Bit-Portierung ist auf Testen Sie Ihre Anwendung mit MEM_TOP_DOWN Zuweisungen aktiviert (AllocationPreference Registrierungswert) , wie beschrieben in 4-Gigabyte Tuning :

  

Um Zuordnungen zu zwingen, von den höheren Adressen zu Testzwecken vor niedrigeren Adressen zuzuweisen, MEM_TOP_DOWN angeben, wenn VirtualAlloc Aufruf oder legen Sie den folgenden Registrierungswert auf 0x100000:

     

HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Memory Management\AllocationPreference

Wann wird diese Angelegenheit?

  • Wenn Sie vorhandene 32-Bit-EXE-Dateien, die mit dem /LARGEADDRESSAWARE MSVC Linker-Option (oder bei denen die IMAGE_FILE_LARGE_ADDRESS_AWARE Flagge in ihren PE-Header durch andere Mittel festgelegt, wie editbin.exe), dann erhalten sie ein volles 4 GB virtuellen Adressraum in 64-Bit-Windows, und Sie müssen sie mit dem Test AllocationPreference Registrierungswert gesetzt.
  • Wenn Sie vorhandene 32-Bit-DLLs, die durch große Adresse bewusst EXE-Dateien geladen werden kann, müssen Sie diese mit dem AllocationPreference Registrierungswert testen.
  • Wenn Sie Ihren C neu kompilieren / C ++ Code in eine 64-Bit-EXE oder DLL, müssen Sie es mit dem AllocationPreference Registrierungswert testen.

Wenn Sie Ihre C / C ++ Anwendung in eine dieser drei Kategorien fällt und Sie nicht testen mit MEM_TOP_DOWN Zuweisungen, Test ist sehr unwahrscheinlich, dass Zeiger Abschneiden / Signedness Fehler in Ihrem Code zu fangen.

Die zweite wichtige Sache, wenn Sie MSVC verwenden und Sie sind neu zu kompilieren C / C ++ Code für 64-Bit ist auf verwenden, um die /Wp64 Compiler-Option für Ihr 64-Bit bauen :

  • Dadurch wird der Compiler verursachen Warnungen für Typumwandlungen zu emittieren, die Zeiger oder erweitern kleinere ganzzahlige Typen in Zeiger gestutzt (auch wenn reinterpret_cast oder eine C-Casts verwendet wird), sowie ein paar andere 64-Bit-Portierung Probleme.
  • Ja, die Dokumentation sagt, dass statt mit /Wp64 kompilieren Sie sollte einen Compiler verwenden, der eine 64-Bit-Plattform zielt, aber das allein wird nicht Zeiger Abschneiden / Erweiterung Probleme bei der Kompilierung fangen. Mit einem Compiler, der 64-Bit- Ziele und ermöglicht die /Wp64 Compiler-Option für die 64-Bit-Build werden viele Zeiger Abschneiden / Erweiterung Probleme bei der Kompilierung fangen, und dies wird Ihnen Zeit auf lange Sicht speichern.
  • Leider mit MSVC 2008 wird dies auch eine „Befehlszeile Warnung“ für jede Übersetzungseinheit produzieren sagen, dass die /Wp64 Option ist veraltet. Ich kann sehen, warum die Option für 32-Bit veraltet baut (wo es ein böser Hack ist, die mit Anmerkungen versehen viele Ihrer typedefs erfordert), aber es ist bedauerlich, dass es auch für 64-Bit veraltet baut (wo es wirklich sinnvoll ist).

Es könnte einfacher sein, .NET-Code zu migrieren, wenn Sie 100% „Typen sicher verwalteten Code“ haben. Sie können kopieren Sie sie einfach auf die 64-Bit-Plattform und führen Sie es erfolgreich unter den 64-Bit-CLR. Sehen Sie sich diese MSDN Link auf 32-Bit-Managed Code Migration auf 64- Bit.

Btw, Hanselman gebloggt über das Thema vor kurzem.

Wenn Sie sprechen über 32-Bit-Programme, dann haben Sie praktisch nichts zu befürchten, da Windows 64 wird sie unter Emulation als 32-Bit laufen. Alle Probleme mit zukünftigen Windows-Versionen (zum Beispiel Windows 7) sind wahrscheinlich Inkompatibilitäten sein, anstatt Probleme mit einem 64-Bit-Betriebssystem.

Allerdings, wenn Ihr verwalteten Code für die „Any CPU“ Zielplattform kompiliert und Sie Anrufe in nicht verwalteten Code machen (z PInvoke) oder auf anderen Baugruppen angewiesen sind, dann gibt es einige Dinge zu beachten. Scott Hanselman Post über die x86 / x64 CLR deckt diese und ist eine gute Erklärung für die CLR auf Win32 / 64.

Bei der Entwicklung von nativen 64-Bit-Programme dann die Programmierung Leitfaden für die 64-Bit-Windows- ist ein guter Führer. Es kommt weitgehend auf Zeiger und die Größe der Datentypen:)

32-Bit-Programme werden fein auf 64-Bit-Windows ausgeführt werden. Solange Sie alle Gerätetreiber Art der Entwicklung natürlich nicht tun.

Wenn Sie Ihre Software als 64-Bit-Software zum ersten Mal kompilieren, müssen Sie kümmern sich um folgende:

  • ein Zeiger ist 64 Bit breit, während ein int 32 Bit ist. Bewahren Sie keine Zeiger in ints, Ihr Code brechen.
  • 64-Bit-Prozesse müssen 64-Bit-DLLs. Wenn Sie auf dem dritten Teil DLLs abhängen, stellen Sie sicher, dass sie auch in 64-Bit vorgesehen sind. Wenn Sie zwischen einem 32-Bit-Prozess und einem 64-Bit-Prozess kommunizieren müssen, werden Sie einige der vielen verschiedenen Arten von IPC unter Windows benötigen. außer Frage Funktionen direkt aufrufen ist.
  • Die Systemverzeichnisse auf 64-Bit-Windows-sind anders als auf 32-Bit-Windows-. Wenn Sie einige hart codierte Pfade haben, müssen Sie sie erneut überprüfen.

Wenn Sie das tun DLL-Injektion aus irgendeinem Grund Probleme haben wird.

Von einem C / C ++ Perspektive ....

Eine offensichtliche Sache ist, dass die Größe eines int wird 8 Bytes statt 4 Bytes werden. Wenn eines der Code auf, dass abhängig ist, kann es zu unerwarteten Ergebnissen kommen. Struktur und variable Alignments kann verschieben. Sie können es überwinden, mit einem #pragma pack können, aber ich bin nicht sehr fließend in Ausrichtungen und Verpackung.

Wenn Sie irgendwelche Gewerkschaften mit ints in ihnen verwenden, kann das Verhalten ändern.

Wenn Sie bitfield Strukturen verwenden, basierend auf ints die zusätzlichen 32 Bits zu Verwirrung führen kann. Das Vorzeichenbit wird nicht dort, wo man dachte, es war.

Wenn Sie Hex-Konstanten codieren und erwarten Zeichen negativ zu gehen, können Sie Probleme haben. Beispiel 0x8000000 eine negative Zahl als log oder 32-Bit-Ganzzahl. 0x80000000 als Integer auf einer 64-Bit-Plattform ist eine positive Zahl. um direkt das Zeichen gesetzt würden Sie haben 0x80000000 00000000 verwenden (zum besseren Lesbarkeit Embedded-Bereich nur)

Auch erwarte ich size__t angemessen zu wachsen. Wenn Sie Zuweisungen machen basierend auf MAX_INT, werden sie viel größer sein.

Um diese Art von Größe Anomalien zu vermeiden, bleibe ich im Allgemeinen mit longs statt Ints.

Ist die 32-Bit-Emulation wirklich kugelsicher? Ich habe gesehen, dass die Registrierung ist ein wenig anders gelegt werden. Ich frage mich nur, was typische Dinge nicht funktionieren ...

Auch die C: \ windows \ system32-Verzeichnis kann nur 64-Bit-DLLs enthalten. Wenn Sie eine 32-Bit-DLL haben, müssen Sie es in C setzen: \ windows \ syswow64 \

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top