Samouczek: debugowanie projektu CMake na zdalnym komputerze z systemem Windows

W tym samouczku użyto programu Visual Studio C++ w systemie Windows do utworzenia i skompilowania projektu CMake, który można wdrożyć i debugować na zdalnej maszynie z systemem Windows. Samouczek jest specyficzny dla systemu Windows ARM64, ale kroki można uogólnić dla innych architektur.

W programie Visual Studio domyślne środowisko debugowania dla usługi ARM64 to zdalne debugowanie maszyny z systemem Windows ARM64. Skonfiguruj ustawienia debugowania, jak pokazano w tym samouczku. W przeciwnym razie podczas próby debugowania projektu CMake ARM64 zostanie wyświetlony błąd, że program Visual Studio nie może odnaleźć maszyny zdalnej.

Z tego samouczka dowiesz się, jak wykonywać następujące czynności:

• tworzenie projektu CMake
• konfigurowanie projektu CMake do kompilowania dla usługi ARM64
• konfigurowanie projektu CMake do uruchamiania na zdalnej maszynie z systemem Windows ARM64
• debugowanie projektu CMake uruchomionego na zdalnej maszynie z systemem Windows ARM64

Wymagania wstępne

Na maszynie hosta

Aby skonfigurować program Visual Studio na potrzeby programowania w języku C++ dla wielu platform, zainstaluj narzędzia kompilacji dla architektury docelowej. Na potrzeby tego samouczka zainstaluj narzędzia kompilacji ARM64, wykonując następujące czynności:

1. Uruchom Instalator programu Visual Studio. Jeśli jeszcze nie zainstalowano programu Visual Studio, zobacz Instalowanie programu Visual Studio
2. Na ekranie głównym Instalator programu Visual Studio wybierz pozycję Modyfikuj.
3. W obszarze wyboru u góry wybierz pozycję Poszczególne składniki.
4. Przewiń w dół do sekcji Kompilatory, narzędzia kompilacji i środowiska uruchomieniowe .
5. Upewnij się, że wybrano następujące elementy:
   • C++ CMake tools for Windows
   • MSVC w wersji 142 — VS 2019 C++ ARM64 build tools (najnowsza wersja) Ważne jest, aby wybrać ARM64 narzędzia kompilacji, a nie ARM narzędzia kompilacji (wyszukaj 64) i wybrać wersję, która jest zgodna z VS 2019programem .
6. Wybierz pozycję Modyfikuj , aby zainstalować narzędzia.

Na maszynie zdalnej

1. Zainstaluj narzędzia zdalne na maszynie zdalnej. Na potrzeby tego samouczka zainstaluj narzędzia ARM64, postępując zgodnie z instrukcjami w temacie Pobieranie i instalowanie narzędzi zdalnych.
2. Uruchom i skonfiguruj zdalny debuger na maszynie zdalnej. W tym samouczku wykonaj czynności opisane w temacie Konfigurowanie zdalnego debugera na zdalnym komputerze z systemem Windows.

Tworzenie projektu CMake

Na maszynie hosta z systemem Windows:

1. Uruchamianie programu Visual Studio
2. W menu głównym wybierz pozycję Plik>nowy>projekt.
3. Wybierz pozycję Projekt>CMake Dalej
4. Nadaj projektowi nazwę i wybierz lokalizację. Następnie wybierz Utwórz.

Poczekaj chwilę na utworzenie projektu i wypełnienie Eksplorator rozwiązań programu Visual Studio.

Konfigurowanie dla usługi ARM64

Aby zastosować maszynę z systemem Windows ARM64, należy skompilować przy użyciu narzędzi kompilacji ARM64.

Wybierz listę rozwijaną Konfiguracja programu Visual Studio i wybierz pozycję Zarządzaj konfiguracjami.

Dodaj nową konfigurację, wybierając pozycję Dodaj nową konfigurację (zielony + przycisk).
W wyświetlonym oknie dialogowym CMake Ustawienia wybierz pozycję arm64-debug, a następnie wybierz pozycję Wybierz:

To polecenie dodaje konfigurację debugowania o nazwie arm64-Debug do pliku CmakeSettings.json . Ta nazwa konfiguracji to unikatowa, przyjazna nazwa, która ułatwia identyfikację tych ustawień na liście rozwijanej Konfiguracja .

Lista rozwijana Zestawu narzędzi jest ustawiona na msvc_arm64_x64. Ustawienia powinny teraz wyglądać następująco:

Uwaga

Na liście rozwijanej Zestaw narzędzi msvc_arm64 wybiera 32-bitowe narzędzia hosta do kompilowania krzyżowego do usługi ARM64, natomiast msvc_arm64 x64 wybiera 64-bitowe narzędzia hosta do krzyżowego kompilowania do usługi ARM64, co zrobisz w tym samouczku. Aby uzyskać więcej informacji na temat dostępnych środowisk zestawu narzędzi, zobacz Środowiska wstępnie zdefiniowane.

Zapisz plik CMakeSettings.json. Z listy rozwijanej konfiguracji wybierz pozycję arm64-debug. (Zapisanie CMakeSettings.json pliku na liście może potrwać chwilę):

Dodawanie pliku konfiguracji debugowania

Następnie dodaj informacje o konfiguracji, które informują program Visual Studio, gdzie można znaleźć maszynę zdalną, wraz z innymi szczegółami konfiguracji.

Zmień widok Eksplorator rozwiązań na cele, wybierając przycisk Przełącz widoki:

Następnie w Eksplorator rozwiązań kliknij dwukrotnie pozycję Widok obiektów docelowych narzędzia CMake, aby wyświetlić projekt.

Otwórz folder projektu (w tym przykładzie CMakeProject3 Project), a następnie kliknij prawym przyciskiem myszy plik wykonywalny i wybierz polecenie Dodaj konfigurację debugowania:

To polecenie tworzy launch.vs.json plik w projekcie. Otwórz go i zmień następujące wpisy, aby włączyć debugowanie zdalne:

• projectTarget: ta wartość jest ustawiana w przypadku dodania pliku konfiguracji debugowania z widoku obiektów docelowych Eksplorator rozwiązań zgodnie z powyższymi instrukcjami.
• remoteMachineName: ustaw adres IP zdalnej maszyny ARM64 lub jej nazwę maszyny.

Aby uzyskać więcej informacji na temat launch.vs.json ustawień, zobacz launch.vs.json dokumentację schematu.

Uwaga

Jeśli używasz widoku folderu zamiast widoku obiektów docelowych w Eksplorator rozwiązań, kliknij prawym przyciskiem myszy plik i wybierz polecenie Dodaj konfigurację CMakeLists.txtdebugowania. To środowisko różni się od dodawania konfiguracji debugowania z widoku obiektów docelowych w następujący sposób:

• Zostanie wyświetlony monit o wybranie debugera (wybierz pozycję C/C++ Remote Windows Debug).
• Program Visual Studio udostępni mniej informacji o szablonie launch.vs.json konfiguracji w pliku, więc musisz dodać go samodzielnie. Musisz podać remoteMachineName wpisy i projectTarget . Po dodaniu konfiguracji z widoku obiektów docelowych wystarczy określić tylko element remoteMachineName.
• projectTarget Dla wartości ustawienia sprawdź listę rozwijaną elementu uruchamiania, aby uzyskać unikatową nazwę elementu docelowego, na przykład w tym samouczku jest CMakeProject3.exeto ".

Uruchamianie zdalnego monitora debugera na zdalnej maszynie z systemem Windows

Przed uruchomieniem projektu CMake upewnij się, że zdalny debuger programu Visual Studio 2019 jest uruchomiony na zdalnej maszynie z systemem Windows. W zależności od sytuacji uwierzytelniania może być konieczna zmiana opcji zdalnego debugera.

Na przykład na komputerze zdalnym na pasku menu zdalny debuger programu Visual Studio wybierz pozycję Narzędzia>Opcje. Ustaw tryb uwierzytelniania tak, aby był zgodny z konfiguracją środowiska:

Następnie w programie Visual Studio na maszynie hosta zaktualizuj launch.vs.json plik tak, aby był zgodny. Jeśli na przykład wybierzesz pozycję Brak uwierzytelniania w zdalnym debugerze, zaktualizuj launch.vs.json plik w projekcie, dodając "authenticationType": "none" do configurations sekcji launch.vs.json. "authenticationType" W przeciwnym razie wartości domyślne i "windows" nie muszą być jawnie określone. W tym przykładzie pokazano plik skonfigurowany pod kątem launch.vs.json braku uwierzytelniania:

{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
        "type": "remoteWindows",
        "authenticationType": "none"
        "name": "CMakeLists.txt",
        "project": "CMakeLists.txt",
        "projectTarget": "CMakeProject3.exe",
        "remoteMachineName": "<ip address goes here>",
        "cwd": "${debugInfo.defaultWorkingDirectory}",
        "program": "${debugInfo.fullTargetPath}",
        "deploy": [],
        "args": [],
        "env": {}
    },
    {
      "type": "default",
      "project": "CMakeLists.txt",
      "projectTarget": "CMakeProject3.exe",
      "name": "CMakeProject3.exe"
    }
  ]
}

Debugowanie aplikacji

Na maszynie hosta w programie Visual Studio Eksplorator rozwiązań otwórz plik CPP dla projektu CMake. Jeśli nadal korzystasz z widoku obiektów docelowych narzędzia CMake, musisz otworzyć węzeł (wykonywalny), aby go wyświetlić.

Domyślny plik CPP to prosta aplikacja konsolowa hello world. Ustaw punkt przerwania na .return 0;

Na pasku narzędzi programu Visual Studio użyj listy rozwijanej Element startowy, aby wybrać nazwę określoną "name" w launch.vs.json pliku:

Aby rozpocząć debugowanie, na pasku narzędzi programu Visual Studio wybierz pozycję Debuguj>rozpocznij debugowanie (lub naciśnij klawisz F5).

Jeśli nie zostanie uruchomiona, upewnij się, że następujące ustawienia są poprawnie ustawione w launch.vs.json pliku:

• "remoteMachineName" powinna być ustawiona na adres IP lub nazwę maszyny zdalnej maszyny z systemem Windows ARM64.
• "name" powinna być zgodna z wyborem na liście rozwijanej elementu uruchamiania programu Visual Studio.
• "projectTarget" powinna być zgodna z nazwą docelowego narzędzia CMake, który chcesz debugować.
• "type" powinna być "remoteWindows"
• Jeśli typ uwierzytelniania w zdalnym debugerze ma wartość Brak uwierzytelniania, należy ustawić "authenticationType": "none" w launch.vs.json pliku .
• Jeśli używasz uwierzytelniania systemu Windows, zaloguj się po wyświetleniu monitu przy użyciu konta rozpoznanego przez maszynę zdalną.

Po kompilacji projektu aplikacja powinna pojawić się na zdalnej maszynie z systemem Windows ARM64:

Program Visual Studio na maszynie hosta powinien zostać zatrzymany w punkcie przerwania dla programu return 0;.

Podsumowanie

W tym samouczku utworzono projekt CMake, skonfigurowano go do kompilowania dla systemu Windows w usłudze ARM64 i debugował go na zdalnej maszynie z systemem Windows ARM64.

Następne kroki

Dowiedz się więcej na temat konfigurowania i debugowania projektów CMake w programie Visual Studio:

Projekty CMake w programie Visual Studio
Dostosowywanie ustawień kompilacji narzędzia CMake
Konfigurowanie sesji debugowania narzędzia CMake
Dokumentacja wstępnie zdefiniowanej konfiguracji narzędzia CMake
launch.vs.json odwołanie do schematu