gRPC cmake Probleme

DocShoe

Hallo zusammen,

wir versuchen gerade das gRPC Framework mit dem Embarcadero RAD Studio zum Laufen zu bringen und stossen da auf Probleme.

Versuchsvorbereitung:

Aktuelles CMake Paket (3.31.4) heruntergeladen und installiert. Pfad zu cmake.exe in den Suchpfad aufgenommen
Anpassungen laut Embarcadero vorgenommen, damit der Embarcadero C/C++ Compiler von cmake erkannt und unterstützt wird
Aktuelles Ninja Paket (1.21.1) heruntergeladen und installiert. Pfad zu ninja.exe in den Suchpfad aufgenommen.
gRPC git repo mit allen Dependencies laut gRCP C++ Doku heruntergeladen
Ein neues build-Unterverzeichnis in grpc\cmake erstellt und in das Verzeichnis gewechselt

Versuchdurchführung (erster Versuch):
cmake gestartet grpc\cmake\build>cmake -DCMAKE_ASM_COMPILER=bcc64.exe -DCMAKE_C_COMPILER=bcc64.exe -DCMAKE_CXX_COMPILER=bcc64.exe -DCMAKE_CXX_STANDARD=17 -G Ninja ..\.. > build.log

CMake sagte:

CMake Error at third_party/boringssl-with-bazel/CMakeLists.txt:50 (enable_language):

No CMAKE_ASM_NASM_COMPILER could be found.
Tell CMake where to find the compiler by setting either the environment
variable "ASM_NASM" or the CMake cache entry CMAKE_ASM_NASM_COMPILER to the
full path to the compiler, or to the compiler name if it is in the PATH.

Versuchdurchführung (zweiter Versuch):
Definition für ASM_NASM_COMPILER per Kommandozeiler ergänzt:
cmake -DCMAKE_ASM_COMPILER=bcc32c.exe -DCMAKE_ASM_NASM_COMPILER=bcc32c.exe -DCMAKE_C_COMPILER=bcc32c.exe -DCMAKE_CXX_COMPILER=bcc32c.exe -DCMAKE_CXX_STANDARD=17 -G Ninja ..\.. > build.log

@CMake sagt:

CMake Error at third_party/protobuf/cmake/protobuf-configure-target.cmake:10 (target_compile_features):
target_compile_features no known features for CXX compiler
"Embarcadero" version 7.70.38315.
Call Stack (most recent call first):
third_party/protobuf/cmake/libprotoc.cmake:21 (protobuf_configure_target)
third_party/protobuf/CMakeLists.txt:312 (include)

Hm. Also laut Fehlermeldung soll in Zeile 10 der Datei protobuf-configure-target.cmake der Fehler auftreten, dass die unterstützten Features für den C++ Compiler nicht bestimmt werden können? Merkwürdig, der Embarcadero C++ Compiler ist doch erkannt worden und mit C++17 ist der Sprachstandard festgelegt worden. Die enstprechende Datei sieht so aus:

# Protocol Buffers - Google's data interchange format
# Copyright 2013 Google LLC  All rights reserved.
#
# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file or at
# https://developers.google.com/open-source/licenses/bsd

# Refactors configuration options set on all Protobuf targets
function(protobuf_configure_target target)
    target_compile_features("${target}" PUBLIC cxx_std_14)
    if (MSVC)
        # Build with multiple processes
        target_compile_options("${target}" PRIVATE /MP)
        # Set source file and execution character sets to UTF-8
        target_compile_options("${target}" PRIVATE /utf-8)
        # MSVC warning suppressions
        target_compile_options("${target}" PRIVATE
            /wd4065 # switch statement contains 'default' but no 'case' labels
            /wd4146 # unary minus operator applied to unsigned type
            /wd4244 # 'conversion' conversion from 'type1' to 'type2', possible loss of data
            /wd4251 # 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
            /wd4267 # 'var' : conversion from 'size_t' to 'type', possible loss of data
            /wd4305 # 'identifier' : truncation from 'type1' to 'type2'
            /wd4307 # 'operator' : integral constant overflow
            /wd4309 # 'conversion' : truncation of constant value
            /wd4334 # 'operator' : result of 32-bit shift implicitly converted to 64 bits (was 64-bit shift intended?)
            /wd4355 # 'this' : used in base member initializer list
            /wd4506 # no definition for inline function 'function'
            /wd4800 # 'type' : forcing value to bool 'true' or 'false' (performance warning)
            /wd4996 # The compiler encountered a deprecated declaration.
        )
        # Allow big object
        target_compile_options("${target}" PRIVATE /bigobj)
    endif ()
    if (protobuf_UNICODE)
        target_compile_definitions("${target}" PRIVATE -DUNICODE -D_UNICODE)
    endif ()
    target_compile_definitions("${target}" PRIVATE -DGOOGLE_PROTOBUF_CMAKE_BUILD)

    if (protobuf_DISABLE_RTTI)
      target_compile_definitions("${target}" PRIVATE -DGOOGLE_PROTOBUF_NO_RTTI=1)
    endif()

    # The Intel compiler isn't able to deal with noinline member functions of
    # template classes defined in headers.  As such it spams the output with
    #   warning #2196: routine is both "inline" and "noinline"
    # This silences that warning.
    if (CMAKE_CXX_COMPILER_ID MATCHES Intel)
        target_compile_options("${target}" PRIVATE -diag-disable=2196)
    endif()

    if (HAVE_ZLIB)
        target_compile_definitions("${target}" PRIVATE -DHAVE_ZLIB)
    endif ()
endfunction ()

Ich verstehe die Fehlermeldung nicht und habe auch keine Ahnung, was ich da tun könnte. Das ist auch mein erster Kontakt mit cmake und mit Sicherheit ist das zusammen mit gRPC kein einfacher Einstieg.
Weiß jemand Rat?

Edit:
im Tutorial wird gRPC v1.66 geklont, das aktuelle Release ist v1.69. Hab also das Repo aktualisiert und den Versuch mit 32bit/64bit (bcc32c.exe/bcc64.exe) wiederholt, die Ergebnisse sind allerdings die gleichen.

Finnegan

@DocShoe So auf die Schnelle: Versteht denn bcc32c.exe denn überhaupt den NASM-Assembler-Dialekt? Ich würde vermuten eher nicht und empfehlen, NASM zu installieren: https://www.nasm.us/ und dessen exe bei CMAKE_ASM_NASM_COMPILER anzugeben. Für CMAKE_ASM_COMPILER kann man durchaus den Compiler angeben - zumindest bei GCC/Clang, aber NASM verwendet ne andere Syntax.

DocShoe

Hab jetzt den NASM installiert und im Kommandozeilenaufruf eingesetzt:
cmake -DCMAKE_ASM_COMPILER=bcc32c.exe -DCMAKE_ASM_NASM_COMPILER=nasm.exe -DCMAKE_C_COMPILER=bcc32c.exe -DCMAKE_CXX_COMPILER=bcc32c.exe -DCMAKE_CXX_STANDARD=17 -G Ninja ..\.., aber das Ergebnis bleibt das Gleiche:

@cmake sagte:

CMake Error at third_party/protobuf/cmake/protobuf-configure-target.cmake:10 (target_compile_features):
target_compile_features no known features for CXX compiler
"Embarcadero" version 7.70.38315.
Call Stack (most recent call first):
third_party/protobuf/cmake/libprotobuf-lite.cmake:31 (protobuf_configure_target)
third_party/protobuf/CMakeLists.txt:306 (include)

Finnegan

@DocShoe Das war jedenfalls auch ein Problem das früher oder später hätte gelöst werden müssen, insofern keine Zeitverschwendung

Die Fehlermeldung liest sich ein wenig, als ob CMake den Compiler nicht wirklich kennt bzw. zumindest keine "Features" für den oder sie nicht unterstützt. Hier soll offenbar der C++14 auf portable weise für das target aktiviert werden. Ein schneller Hack wäre die Zeile target_compile_features("${target}" PUBLIC cxx_std_14) herauszunehmen und dem Compiler manuell die Flags mitzugeben, die C++14 aktivieren. Bzw. die im CMake-Skript mithilfe von target_compile_options hinzuzufügen.

Laut dieser Liste hier scheint CMake für diesen Compiler auch keine Features zu unterstützen. Daher würde ich tatsächlich das Skript anpassen und die Compiler-Optionen manuell hinzufügen. target_compile_features("${target}" PUBLIC cxx_std_14) macht ja letztendlich nichts anderes - nur eben portabel, unabhängig vom Compiler.

DocShoe

So....
Einen Schritt weiter gekommen, die Doku von Embarcadero war für eine andere RAD Studio Version und ungenau. Es reicht nicht aus, die in Schritt 2) aufgelisteten Anpassung durchzuführen, man musste auch noch zwei weitere Dateien aus anderen Verzeichnissen in das entsprechende cmake Verzeichnis kopieren. Danach ist cmake durchgelaufen und hat das Ninja-Buildscript erzeugt. Der Buildprozess bricht jetzt aber mit C++ Fehlern ab, da muss man mal schauen, ob und wie wir die in den Griff kriegen.

Edit:
Embarcadero hat den clang compiler v3.3 (oder inzwischen sogar v5?) angepasst, damit der ihre Delphi Konstruktionen versteht und übersetzt. Embarcadero liefert .cmake Dateien für ihren Compiler mit, damit cmake den erkennt (siehe oben, Schritt 2).