BCC64X

Aus RAD Studio
Wechseln zu: Navigation, Suche

Nach oben zu Durch Clang erweiterte C++-Compiler


BCC64X ist ein C++-Compiler für 64-Bit-Windows (Modern) von RAD Studio.

BCC64X basiert auf Clang. Weitere Informationen zu Gemeinsamkeiten des BCC64X-Compilers mit anderen, durch Clang erweiterten C++-Compilern finden Sie unter Durch Clang erweiterte C++-Compiler.

Hinweis: Verwenden Sie für 32-Bit-Windows BCC32C (durch Clang erweiterter Compiler) oder BCC32 (Compiler der vorherigen Generation).
Hinweis: BCC64X ist der Compiler/die Toolkette für Modern Win64 und wird für alle Anwendungen empfohlen. Der alte BCC64 ist aber weiterhin vorhanden.

Allgemeine Informationen

Feld Wert
Clang-Version 15.0
LLVM-Version 15.0
Aufrufkonventionen Microsoft x64 (EN)
Ergänzen von Namen Itanium
Standardbibliothek LLVM libc++
C++-Laufzeit Custom based on MinGW-LLVM
C-Laufzeit UCRT

Ausgabedateien

Dateityp Dateierweiterung Dateiformat
Ausführbare Datei .exe PE64 (PE32+)
Gemeinsame Bibliothek .dll PE64 (PE32+)
Statische Bibliothek .lib und lib[name].a Bibliothek der Objektdateien; weitere Informationen zu Erweiterungen finden Sie unter Automatisches Linken.
Compiliertes Objekt .o COFF64
Debug-Informationen .pdb PDB
Hinweis: Die neue Clang unterstützt statisches und dynamisches Linken von Packages. Sie können diese Dateien in EXE- oder DLL-Dateien linken.

Schreiben von C++-Code für BCC64X

Verwenden Sie die folgende Anweisung, um C++-Code speziell für BCC64X zu schreiben: 

#if defined(__BORLANDC__) && defined(_WIN64) && defined(__MINGW64__)

Fügen Sie eine Prüfung wie die folgende hinzu, um ein bestimmtes Release zu verwenden:

#if __clang_major__ == 15
  #pragma message("Using version 15 of Clang")
#endif


Weitere Informationen finden Sie unter Durch Clang erweiterte C++-Compiler, Vordefinierte Makros.

Toolkette

Bei der C++-Toolkette für 64-Bit-Windows Modern (bcc64x) handelt es sich um eine völlig neue Implementierung der Clang-Erweiterungen und C++Builder-Features mit neuer plattformbasierter Technologie. Mit dem LLD-Linker, der neuen RTL und mehr ist die neue Clang-Toolkette unsere empfohlene C++-Toolkette.

Sie verwendet die LLVM-libc++-STL, eine angepasste C++-RTL, die Windows-UCRT für die C-Laufzeit und gibt Objektdateien im COFF64-Format mit PDB-Debug-Informationen aus.

Führen Sie die folgenden Schritte durch, um diese Toolkette einem vorhandenen C++-Projekt hinzuzufügen:

  1. Klicken Sie in der Projekthierarchie mit der rechten Maustaste auf den Knoten Zielplattformen.
  2. Wählen Sie Plattform hinzufügen aus.
  3. Wählen Sie Windows 64 Bit (Modern) aus.
Hinweis: Sie können problemlos zwischen der alten und der neuen Win64-Plattform wechseln, da beide Plattformen installiert sind und einem Projekt gleichzeitig hinzugefügt werden können, was ein einfaches Upgrade ermöglicht.
Achtung: Ältere Toolketten haben mehrere Versionen der Laufzeit bereitgestellt, damit sowohl nur Einzelthread- als auch Multithread-Anwendungen unterstützt werden konnten. Die Modern-Toolkette hat eine einzelne Multithread-Laufzeit. Daher ist die Multithread-Laufzeit die einzige verfügbare Option. Wenn Ihre Anwendung nur einen Einzelthread nutzt, können Sie sie trotzdem verwenden.

Verwendung des neuen BCC64X-Compilers testen

RAD Studio bietet eine empfohlene Methode für Entwickler, Code zu schreiben, der erkennt, ob die neue Toolkette verwendet wird:

  • Empfohlen: Verwenden Sie einen Makrotest für _CODEGEARC_ und _clang_major_ >= 15 für diese und neuere Versionen. Dieser Test wird für RAD Studio empfohlen, da sich die Clang-Version im Laufe der Zeit ändern kann und dieser Code für die aktuellen und zukünftigen Versionen dieser Toolkette gilt. Diesen Test sollten Sie unbedingt Ihrem Code hinzufügen.
  • Mit dem Makrotest _CODEGEARC_ und _clang_major_ == 15 testen Sie auf diese spezielle Version. Verwenden Sie dies nur, um speziell auf die erste Version der Toolkette zu testen. Dieser Test erkennt zukünftige Versionen der gleichen Toolkette nicht, weshalb der vorherige Test empfohlen wird.
Hinweis: Weitere Informationen zum Erkennen der LLVM und ihrer Version finden Sie hier (EN).
  • Verwenden Sie die Makros _has_feature und _has_builtin, um auf bestimmte C++- oder Compiler-/LLVM-Features und -Builtins zu testen, die nicht C++Builder-spezifisch sind, aber für mehrere Clang-basierte Toolketten gelten. Weitere Informationen zu Makros für das Testen auf Features finden Sie hier (EN).


Das folgende Codebeispiel zeigt den von uns empfohlenen Test für die neue Toolkette. Verwenden Sie diesen Test, um für die Toolkette spezifischen Code zu kapseln, z. B. um bestimmte Header einzuschließen. 

#include <iostream>
#include <tchar.h>

int _tmain(int argc, _TCHAR* argv[])
{
      #if defined(__CODEGEARC__) && (__clang_major__ >= 15)
           std::cout << "C++Builder Modern Compiler, 12.1 or newer";
      #else
           std::cout << "A different compiler";
      #endif
}

Um Ihre bestehende Codebasis weiter zu migrieren, sollten Sie spezifischen Code für die neue Toolkette in ein solches Makro aufnehmen.

Hinweis: Eine vollständige Liste der Makros finden Sie auf der Seite Vordefinierte Makros.

Anpassen von Pfaden

Fügen Sie die Variable $(CC_SUFFIX) dem Bibliothekspfad hinzu, damit der Compiler die korrekten Pfade findet.

Zum Beispiel: 

$(BDSLIB)\$(PLATFORM)$(CC_SUFFIX)\debug;..\..\..\..\..\Public\Documents\Embarcadero\Studio\15.0\Samples\CPP\Mobile Samples\User Interface\KeyboardToolbar\

Die Variable $CC_SUFFIX behandelt den Unterschied zwischen den beiden Win64-Toolketten. Die neue Toolkette, bcc64x, hat am Ende ein X, was bedeutet, dass der korrekte Plattformspeicherort für Dateien, mit denen verknüpft wird, "win64x" ist. $CC_SUFFIX wird zu X ausgewertet, wenn diese Plattform verwendet wird.

Testen auf Windows im Vergleich zu Testen auf eine bestimmte Toolkette

Bei der Verwendung von C++-Quellcode von Drittanbietern kann es vorkommen, dass Header, Methodendefinitionen usw. vorhanden sind, die Windows-spezifisch sind und fälschlicherweise in ein Makro gekapselt werden, das die Toolkette (normalerweise MSVC) testet. Ersetzen Sie diese Makros durch einen Plattformtest, anstatt des Toolketten-Tests.

Testen Sie, ob _WIN32 oder _WIN64 definiert sind, um auf Windows, MSVC, C++Builder oder eine andere Toolkette zu prüfen. Sowohl in C++Builder als auch in MSVC sind diese Makros definiert. Dies wird für Windows-spezifischen Code empfohlen.

Tests auf Plattformkombinationen (Windows) mit Toolketten-Tests scheinen unter Windows aufgrund der zunehmenden Verwendung anderer Toolketten wie RAD Studio und mingw-llvm rückläufig zu sein. Es ist jedoch immer noch ein häufiges Problem, wenn C++-Quellcode oder -Bibliotheken von Drittanbietern eingebunden werden.

Mit DLLs linken

Erzeugen eines DLL-Builds und Generieren der Exportdatei (.def)

RAD Studio wird mit llvm-dlltool.exe ausgeliefert, da diese Datei Teil von llvm-project ist, aus dem unser Clang-basierter bcc64x.exe-Compiler erzeugt wird. Es wird empfohlen, zum Generieren einer .def-Datei das Tool tdump.exe zu verwenden.

Direkt mit einer DLL linken

Die neue Toolkette kann direkt mit einer .dll-Datei gelinkt werden. Sie können entweder die Funktion -lmydll verwenden oder, wenn eine Kopie der .dll-Datei im Pfad LIBRARY vorhanden ist, können Sie #pragma comment(lib, "mydll") ohne eine Importbibliothek verwenden.

Unter Automatisches Linken finden Sie weitere Informationen.

Der Linker kann manuell durch den Compiler aufgerufen werden, indem Sie dem Linker den folgenden Pfad hinzufügen: 

libclang_rt.builtins-x86_64.a

Erstellen von DLL-Importbibliotheken

In RAD Studio können Sie jetzt eine .dll direkt ohne Verwendung einer Importbibliothek linken. Diese neue Implementierung gilt nur für Win64x-Plattformen.

Die Importbibliothek wird jedoch häufig verwendet, um eine .dll-Datei zu importieren, weil der Linker zuerst nach Bibliotheken und zuletzt nach .dll-Dateien sucht.

Die Toolkette unterstützt alle vorhandenen COFF-Bibliotheken. Sie können aber auch eine eigene erstellen.

Führen Sie die folgenden Schritte aus, um eine eigene Importbibliothekdatei (.lib) zu erstellen:

  1. Generieren Sie die Definitionsdatei (.def) für die DLL.
    Hinweis: Sie können die .def-Datei aus einer .dll-Datei mit dem Tool tdump generieren.
  2. Führen Sie im tdump-Tool den folgenden Befehl aus, um die .def-Datei zu erstellen:
    tdump -def mydll.dll mydll.def
    Hinweis: Eine .def-Datei enthält reinen Text. Öffnen Sie die Datei und überprüfen Sie, dass sie LIBRARY <dll-Name>.dll mit dem korrekten <dll-Namen> enthält.
  3. Generieren Sie mit dem neuen LLD-Linker die Importbibliothek, indem Sie den folgenden Befehl in der RAD Studio-Eingabeaufforderung eingeben:
    ld.lld.exe -m i386pep --out-implib file.lib file.def

Die IDE erstellt beim Erzeugen des Builds automatisch die DLL-Importbibliothek. Sie können die Importbibliothek aber auch manuell erstellen, indem Sie eine der folgenden Anweisungen in der Befehlszeile ausführen: 

bcc64x -tD -Xlinker --out-implib=dll.lib dll.cpp

oder 

bcc64x -tD dll.cpp -Wl,--out-implib,dll.lib

Parallele Compilierung

C++Builder-Projekte für die neue Win64-Toolkette werden standardmäßig parallel erzeugt. Dies führt zu einer schnelleren Erzeugung mit bcc64x im Vergleich zur Erzeugung mit:

  • "--jobs", das den alten bcc64 verwendet (alte Win64-Toolkette).
  • CMake und Ninja, die beide den alten und den neuen bcc64/x verwenden.
  • Visual C++ mit CMake und Ninja und der Befehlszeilenoption /MP.

Dies ist standardmäßig für Projekte aktiviert, die diese Plattform verwenden. Lesen Sie die folgende Dokumentation, um Einstellungen zu konfigurieren oder zu verstehen, wie es funktioniert.

Grundlagen

Bei der parallelen Compilierung von C++Builder-Projekten werden zwei Funktionen kombiniert: Stapel-Compilierung, bei der der Compiler mehrere C++-Dateien auf einmal erhält, anstatt die Compilierung für jeweils eine Datei aufzurufen, und --jobs, bei der der Compiler die vorliegenden Dateien parallel verarbeitet.

Der Compiler erhält also viele Dateien zum Compilieren (Stapel-Compilierung) und er wird angewiesen, sie parallel zu compilieren (--jobs.)

Warum beides? Wenn Sie nur die Stapel-Compilierung ausführen, werden viele Dateien mit einem einzigen Aufruf der Compiler-EXE compiliert, aber der Compiler verarbeitet sie nacheinander. Wenn Sie nur --jobs ausführen, wird das parallele System verwendet, aber nur mit einer einzigen Datei, und dies ergibt nur eine einzige sinnlose Datei. Sie müssen beide Einstellungen aktivieren: (a) viele Daten simultan und (b) parallel.

Verhalten der parallelen Compilierung sowie Nutzung der CPU

Im Folgenden finden Sie einige Informationen über die Funktionsweise der Stapel-Compilierung mit --jobs zur Optimierung Ihrer Build-Umgebungen, um eine schnellere und effizientere Compilierung und gleichzeitig eine ausgeglichene Ressourcenauslastung zu erreichen.

Compiler-Ausgabe

Compiler-Meldungen sind nicht verschachtelt. Obwohl sie parallel ablaufen, werden die Ausgabemeldungen einer gesamten Datei nach deren Fertigstellung auf einmal ausgegeben.

Bei einem Compilierfehler wird die gesamte Compilierung beendet. Nach dem Fehler erhalten Sie möglicherweise Meldungen über eine erfolgreiche Compilierung, da die anderen Dateien, die parallel compiliert werden, bis zu deren Ende compiliert wurden.

Build-Systeme

Das parallele "--jobs"-Build-System kann in der IDE und vom Befehlszeilen-MSBuild sowie direkt über die Befehlszeile "bcc64x" verwendet werden.

Beachten Sie, dass Sie dies uneingeschränkt für CI, Build-Server und mehr verwenden können, wenn Sie den Build über einen MSBuild-Befehl in der Befehlszeile erzeugen. Sie müssen den Compiler nicht direkt aufrufen. Das Standard-Build-System kann parallel von der Befehlszeile aus den Build erzeugen.

Erzeugen Sie den Build oder compilieren Sie wie üblich. Das parallele Erzeugen eines Builds wird standardmäßig verwendet. Wenn Sie den Task-Manager öffnen, sollte ein einzelner bcc64x-Prozess mit mehreren Threads angezeigt werden, der bis zu 100 % CPU beansprucht.

680px

Öffnen Sie die Projektoptionen, um zu überprüfen, ob Ihr Projekt parallele Builds verwendet:

  1. Vergewissern Sie sich, dass die Plattform "Windows 64 Bit (Modern)" in Ihrem Projekt ausgewählt und aktiv ist.
  2. Öffnen Sie die Projektoptionen. Wählen Sie in der Dropdown-Liste "Alle Konfigurationen" aus.
  3. Erzeugen > C++-Compiler > Stapel-Compilierung aktivieren sollte auf "true" festgelegt sein. Vergewissern Sie sich, dass keine der anderen Zielkonfigurationen diesen Wert überschreibt. Dies sollte die Standardeinstellung auf einer übergeordneten geerbten Ebene sein.
  4. Projekteigenschaften > Allgemein > Anzahl der Unterprozesse sollte auf 0 festgelegt sein. Damit wird jeder vorhandene Kern verwendet.

Rufen Sie "msbuild" mit Ihrem Projekt auf. Solange die oben genannten Einstellungen in den Projektoptionen in der IDE festgelegt sind, wird die parallele Compilierung ausgeführt. 

> msbuild MyProject.cbproj

Die vollständige Liste der Parameter finden Sie unter Erzeugen eines Projekts mit einem MSBuild-Befehl. Stellen Sie sicher, dass die parallele Erzeugung für das Projekt in der IDE konfiguriert ist. Diese Einstellungen werden immer verwendet, wenn Sie "msbuild" in der Befehlszeile mit demselben Projekt verwenden.

Zur direkten Implementierung über die Befehlszeile verwenden Sie einfach Folgendes: 

> bcc64x a.cpp b.cpp c.cpp --jobs=0 ...other parameters

Diese Batches senden mehrere Dateien auf einmal an den Compiler, weisen ihn an, parallel zu erzeugen (jobs) und so viele Kerne wie verfügbar zu verwenden ("0" bedeutet alle Kerne.)

CPU-Sättigung

Suchen Sie auf der Registerkarte Projektoptionen > Projekteigenschaften > Allgemein die Einstellung Anzahl der Unterprozesse. Die Standardeinstellung ist "0". Das bedeutet, dass alle verfügbaren Kerne verwendet werden. Es werden doppelt so viele Threads ausgeführt, wie Kerne vorhanden sind.

Wenn Sie möchten, dass das Build-System nicht alle, aber fast alle verfügbaren Ressourcen nutzt, legen Sie diese Einstellung auf -1 fest. Damit wird ein Kern weniger als bei der Standardeinstellung ("0") genutzt. Verwenden Sie diese Einstellung nur, wenn Sie während der Compilierung etwas anderes ausführen möchten und andere Prozesse verlangsamt ausgeführt werden.

Sie können für diese Einstellung auch einen positiven Integerwert festlegen. Je nachdem, wie viele Kerne verfügbar sind, werden Kerne bis zu dieser Anzahl verwendet. Wenn Sie festlegen, dass mehr Kerne verwendet werden sollen, als vorhanden sind, werden einfach so viele Kerne verwendet, wie möglich.

Sie können denselben Wert festlegen, wenn Sie den Compiler direkt aufrufen und den Befehlszeilenparameter "--jobs=n" angeben.

Unser empfohlener Wert ist 0 (die Standardeinstellung.) Dadurch wird eine vollständige CPU-Sättigung erreicht und Builds so schnell wie möglich erzeugt.

Bekannte Probleme

Komponenten aus Packages, die mit Delphi-Projekten für WIN64X erstellt wurden, müssen zunächst für die Plattform aktiviert werden. Anleitungen zum Aktivieren von Komponenten für die Plattform Windows 64 Bit (Modern) finden Sie unter Delphi-Packages für C++ erzeugen.

Hinweis: Dieses Problem tritt nur bei vorhandenen Projekten auf. Neu erstellte Projekte sind davon nicht betroffen.

Weitere Informationen finden Sie unter ComponentPlatformsAttribute.

Siehe auch

Abgerufen von „https://docwiki.embarcadero.com/RADStudio/Athens/d/index.php?title=BCC64X&oldid=220281“