[Android] support fastdeploy with armeabi-v7a and arm64-v8a (#268)

* [Andorid] support fastdeploy with armeabi-v7a and arm64-v8a

* [Android] support fastdeploy with armeabi-v7a and arm64-v8a

* [cmake] fixed custom opencv_directory error for android

.gitignore

@@ -1,4 +1,3 @@
-fastdeploy/libs/lib*
 build
 cmake-build-debug
 cmake-build-release
@@ -12,11 +11,14 @@ fastdeploy_gpu_python.egg-info
 .setuptools-cmake-build
 fastdeploy/version.py
 fastdeploy/core/config.h
-fastdeploy/c_lib_wrap.py
+python/fastdeploy/c_lib_wrap.py
-fastdeploy/LICENSE*
+python/fastdeploy/LICENSE*
-fastdeploy/ThirdPartyNotices*
+python/fastdeploy/ThirdPartyNotices*
 *.so*
-fastdeploy/libs/third_libs
+fpython/astdeploy/libs/third_libs
-csrc/fastdeploy/core/config.h
+fastdeploy/core/config.h
-csrc/fastdeploy/pybind/main.cc
+fastdeploy/pybind/main.cc
+python/fastdeploy/libs/lib*
 __pycache__
+build_fastdeploy_android.sh
+python/scripts/process_libraries.py

CMakeLists.txt

@@ -36,6 +36,12 @@ if(NOT MSVC)
   set(CMAKE_CXX_STANDARD 11)
 endif(NOT MSVC)
 
+if(ANDROID)
+  # To reduce the volume of the library
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g0 -Os -ffunction-sections -fdata-sections")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g0 -Os -ffunction-sections -fdata-sections")
+endif()
+
 #############################CMAKE FOR FASTDEPLOY################################
 option(ENABLE_PADDLE_FRONTEND "Whether to enable PaddlePaddle frontend to support load paddle model in fastdeploy." ON)
 option(WITH_GPU "Whether WITH_GPU=ON, will enable onnxruntime-gpu/paddle-infernce-gpu" OFF)
@@ -52,6 +58,9 @@ option(ENABLE_TEXT "Whether to enable text models usage." OFF)
 option(WITH_TESTING "Whether to compile with unittest." OFF)
 option(OPENCV_DIRECTORY "User can specify the installed opencv directory.")
 option(ORT_DIRECTORY "User can specify the installed onnxruntime directory.")
+######################### Options for Android cross compiling ####################
+option(WITH_OPENCV_STATIC "Use OpenCV static lib for Android." OFF)
+option(WITH_LITE_STATIC "Use Paddle-Lite static lib for Android." OFF)
 
 # Please don't open this flag now, some bugs exists.
 # option(ENABLE_OPENCV_CUDA "Whether to enable opencv with cuda, this will allow process image with GPU." OFF)
@@ -109,6 +118,21 @@ if(BUILD_EXAMPLES AND EXISTS ${PROJECT_SOURCE_DIR}/examples)
   endif()
 endif()
 
+if(ANDROID OR IOS)
+  if(ENABLE_ORT_BACKEND)
+    message(FATAL_ERROR "Not support ONNXRuntime backend for Andorid/IOS now. Please set ENABLE_ORT_BACKEND=OFF.")
+  endif()
+  if(ENABLE_PADDLE_BACKEND)
+    message(FATAL_ERROR "Not support Paddle backend for Andorid/IOS now. Please set ENABLE_PADDLE_BACKEND=OFF.")
+  endif()
+  if(ENABLE_OPENVINO_BACKEND)
+    message(FATAL_ERROR "Not support OpenVINO backend for Andorid/IOS now. Please set ENABLE_OPENVINO_BACKEND=OFF.")
+  endif()
+  if(ENABLE_TRT_BACKEND)
+    message(FATAL_ERROR "Not support TensorRT backend for Andorid/IOS now. Please set ENABLE_TRT_BACKEND=OFF.")
+  endif()
+endif()
+
 add_definitions(-DFASTDEPLOY_LIB)
 # configure files before glob sources.
 configure_file(${PROJECT_SOURCE_DIR}/${CSRCS_DIR_NAME}/fastdeploy/core/config.h.in ${PROJECT_SOURCE_DIR}/${CSRCS_DIR_NAME}/fastdeploy/core/config.h)
@@ -151,6 +175,7 @@ if(ENABLE_LITE_BACKEND)
   add_definitions(-DENABLE_LITE_BACKEND)
   include(${PROJECT_SOURCE_DIR}/cmake/paddlelite.cmake)
   list(APPEND ALL_DEPLOY_SRCS ${DEPLOY_LITE_SRCS})
+  list(APPEND DEPEND_LIBS external_paddle_lite)
 endif()
 
 if(ENABLE_PADDLE_BACKEND)
@@ -177,6 +202,9 @@ if(WITH_GPU)
   if(APPLE)
     message(FATAL_ERROR "Cannot enable GPU while compling in Mac OSX.")
     set(WITH_GPU OFF)
+  elseif(ANDROID OR IOS)
+    message(FATAL_ERROR "Cannot enable GPU while compling in Android or IOS.")
+    set(WITH_GPU OFF)
   else()
     add_definitions(-DWITH_GPU)
     include_directories(${CUDA_DIRECTORY}/include)
@@ -190,8 +218,8 @@ if(WITH_GPU)
 endif()
 
 if(ENABLE_TRT_BACKEND)
-  if(APPLE)
+  if(APPLE OR ANDROID OR IOS)
-    message(FATAL_ERROR "Cannot enable tensorrt backend in mac os, please set -DENABLE_TRT_BACKEND=OFF.")
+    message(FATAL_ERROR "Cannot enable tensorrt backend in mac/ios/android os, please set -DENABLE_TRT_BACKEND=OFF.")
   endif()
   if(NOT WITH_GPU)
     message(FATAL_ERROR "While -DENABLE_TRT_BACKEND=ON, must set -DWITH_GPU=ON, but now it's OFF")
@@ -232,25 +260,17 @@ if(ENABLE_VISION)
   add_definitions(-DENABLE_VISION)
   if(ENABLE_OPENCV_CUDA)
     add_definitions(-DENABLE_OPENCV_CUDA)
-    if(APPLE)
+    if(APPLE OR ANDROID OR IOS)
-      message(FATAL_ERROR "Cannot enable opencv with cuda in mac os, please set -DENABLE_OPENCV_CUDA=OFF.")
+      message(FATAL_ERROR "Cannot enable opencv with cuda in mac/ios/android os, please set -DENABLE_OPENCV_CUDA=OFF.")
     endif()
   endif()
   add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/yaml-cpp)
   list(APPEND DEPEND_LIBS yaml-cpp)
   list(APPEND ALL_DEPLOY_SRCS ${DEPLOY_VISION_SRCS})
   include_directories(${PROJECT_SOURCE_DIR}/third_party/yaml-cpp/include)
-  if (OPENCV_DIRECTORY)
+  include(${PROJECT_SOURCE_DIR}/cmake/opencv.cmake)
-    message(STATUS "Use the opencv lib specified by user. The OpenCV path: ${OPENCV_DIRECTORY}")
+  list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
-    STRING(REGEX REPLACE "\\\\" "/" OPENCV_DIRECTORY ${OPENCV_DIRECTORY})
+
-    find_package(OpenCV REQUIRED PATHS ${OPENCV_DIRECTORY})
-    list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
-    include_directories(${OpenCV_INCLUDE_DIRS})
-  else()
-    message(STATUS "Use the default opencv lib.")
-    include(${PROJECT_SOURCE_DIR}/cmake/opencv.cmake)
-    list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
-  endif()
   if(ENABLE_VISION_VISUALIZE)
     add_definitions(-DENABLE_VISION_VISUALIZE)
   endif()
@@ -261,6 +281,13 @@ else()
   endif()
 endif()
 
+if(ANDROID OR IOS)
+  if(ENABLE_TEXT)
+    set(ENABLE_TEXT OFF CACHE BOOL "Force ENABLE_TEXT OFF" FORCE)
+    message(STATUS "Found Android or IOS, force ENABLE_TEXT OFF. We do not support faster_tokenizer with Android/IOS now.")
+  endif()
+endif()
+
 if(ENABLE_TEXT)
   add_definitions(-DENABLE_TEXT)
   list(APPEND ALL_DEPLOY_SRCS ${DEPLOY_TEXT_SRCS})
@@ -282,6 +309,18 @@ file(READ "${PROJECT_SOURCE_DIR}/VERSION_NUMBER" FASTDEPLOY_VERSION)
 string(STRIP "${FASTDEPLOY_VERSION}" FASTDEPLOY_VERSION)
 if (APPLE)
   set_target_properties(${LIBRARY_NAME} PROPERTIES COMPILE_FLAGS "-fvisibility=hidden")
+elseif(ANDROID)
+  set_target_properties(${LIBRARY_NAME} PROPERTIES COMPILE_FLAGS "-fvisibility=hidden")
+  # strip debug C++ symbol table
+  set(COMMON_LINK_FLAGS "-Wl,-exclude-libs,ALL")
+  set(COMMON_LINK_FLAGS_REL "-Wl,-s,--gc-sections,-exclude-libs,ALL")
+  if(WITH_OPENCV_STATIC OR WITH_LITE_STATIC)
+    set(COMMON_LINK_FLAGS "${COMMON_LINK_FLAGS},--allow-multiple-definition")
+    set(COMMON_LINK_FLAGS_REL "${COMMON_LINK_FLAGS_REL},--allow-multiple-definition")
+  endif()
+  set_target_properties(${LIBRARY_NAME} PROPERTIES LINK_FLAGS ${COMMON_LINK_FLAGS})
+  set_target_properties(${LIBRARY_NAME} PROPERTIES LINK_FLAGS_RELEASE ${COMMON_LINK_FLAGS_REL})
+  set_target_properties(${LIBRARY_NAME} PROPERTIES LINK_FLAGS_MINSIZEREL ${COMMON_LINK_FLAGS_REL})
 elseif(MSVC)
 else()
   set_target_properties(${LIBRARY_NAME} PROPERTIES COMPILE_FLAGS "-fvisibility=hidden")

cmake/opencv.cmake

@@ -12,10 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
-set(OPENCV_INSTALL_DIR ${THIRD_PARTY_PATH}/install/)
-set(OPENCV_URL_PREFIX "https://bj.bcebos.com/paddle2onnx/libs")
-
 set(COMPRESSED_SUFFIX ".tgz")
 if(WIN32)
   set(OPENCV_LIB "opencv-win-x64-3.4.16")
@@ -26,6 +22,21 @@ elseif(APPLE)
   else()
     set(OPENCV_LIB "opencv-osx-x86_64-3.4.16")
   endif()
+elseif(ANDROID)
+  # Use different OpenCV libs according to toolchain
+  # gcc: OpenCV 3.x, clang: OpenCV 4.x
+  if(ANDROID_TOOLCHAIN MATCHES "clang")
+    set(OPENCV_LIB "opencv-android-4.6.0")
+    set(OPENCV_ANDROID_SHARED_LIB_NAME "libopencv_java4.so")
+  elseif(ANDROID_TOOLCHAIN MATCHES "gcc")
+    set(OPENCV_LIB "opencv-android-3.4.16")
+    set(OPENCV_ANDROID_SHARED_LIB_NAME "libopencv_java3.so")
+  else()
+    message(FATAL_ERROR "Only support clang/gcc toolchain, but found ${ANDROID_TOOLCHAIN}.")
+  endif()  
+elseif(IOS)
+  message(FATAL_ERROR "Not support cross compiling for IOS now!")
+# Linux
 else()
   if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "aarch64")
     set(OPENCV_LIB "opencv-linux-aarch64-3.4.14")
@@ -40,13 +51,77 @@ else()
   endif()
 endif()
 
-set(OPENCV_URL ${OPENCV_URL_PREFIX}/${OPENCV_LIB}${COMPRESSED_SUFFIX})
+set(OPENCV_INSTALL_DIR ${THIRD_PARTY_PATH}/install/)
-download_and_decompress(${OPENCV_URL} ${CMAKE_CURRENT_BINARY_DIR}/${OPENCV_LIB}${COMPRESSED_SUFFIX} ${THIRD_PARTY_PATH}/install/)
+if(ANDROID)
-
+  set(OPENCV_URL_PREFIX "https://bj.bcebos.com/fastdeploy/third_libs")
-set(OpenCV_DIR ${THIRD_PARTY_PATH}/install/${OPENCV_LIB}/)
+else() # TODO: use fastdeploy/third_libs instead.
-if (WIN32)
+  set(OPENCV_URL_PREFIX "https://bj.bcebos.com/paddle2onnx/libs")
-  set(OpenCV_DIR ${OpenCV_DIR}/build/)
+endif()
+set(OPENCV_URL ${OPENCV_URL_PREFIX}/${OPENCV_LIB}${COMPRESSED_SUFFIX})
+
+if(OPENCV_DIRECTORY)
+  message(STATUS "Use the opencv lib specified by user. The OpenCV path: ${OPENCV_DIRECTORY}")
+  STRING(REGEX REPLACE "\\\\" "/" OPENCV_DIRECTORY ${OPENCV_DIRECTORY})
+  # For Android, the custom path to OpenCV with JNI should look like: 
+  # -DOPENCV_DIRECTORY=your-path-to/OpenCV-android-sdk/sdk/native/jni
+  if(ANDROID)
+    if(WITH_OPENCV_STATIC)
+      set(OpenCV_DIR ${OPENCV_DIRECTORY})
+      find_package(OpenCV REQUIRED PATHS ${OpenCV_DIR})
+      include_directories(${OpenCV_INCLUDE_DIRS})
+      list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
+    else()
+      set(OpenCV_INCLUDE_DIRS ${OPENCV_DIRECTORY}/include)
+      get_filename_component(OpenCV_NATIVE_DIR ${OPENCV_DIRECTORY} DIRECTORY)
+      set(OpenCV_LIBS_DIR ${OpenCV_NATIVE_DIR}/libs)
+      include_directories(${OpenCV_INCLUDE_DIRS})
+      add_library(external_opencv_java STATIC IMPORTED GLOBAL)
+      set_property(TARGET external_opencv_java PROPERTY IMPORTED_LOCATION 
+        ${OpenCV_LIBS_DIR}/${ANDROID_ABI}/${OPENCV_ANDROID_SHARED_LIB_NAME})
+      list(APPEND DEPEND_LIBS external_opencv_java)
+    endif()
+  # Win/Linux/Mac
+  else()
+    find_package(OpenCV REQUIRED PATHS ${OPENCV_DIRECTORY})
+    include_directories(${OpenCV_INCLUDE_DIRS})
+    list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
+  endif()
+else()
+  message(STATUS "Use the default OpenCV lib from: ${OPENCV_URL}")
+  if(ANDROID)
+    if(WITH_OPENCV_STATIC)
+      # When FastDeploy uses the OpenCV static library, there is no need to install OpenCV to FastDeploy thirds_libs
+      download_and_decompress(${OPENCV_URL} ${CMAKE_CURRENT_BINARY_DIR}/${OPENCV_LIB}${COMPRESSED_SUFFIX} ${THIRD_PARTY_PATH})
+      set(OpenCV_DIR ${THIRD_PARTY_PATH}/${OPENCV_LIB}/sdk/native/jni)
+      find_package(OpenCV REQUIRED PATHS ${OpenCV_DIR})
+      include_directories(${OpenCV_INCLUDE_DIRS})
+      list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
+      # Still need OpenCV headers now. TODO(qiuyanjun): May remove OpenCV headers.
+      execute_process(
+        COMMAND ${CMAKE_COMMAND} -E copy_directory ${OpenCV_DIR} 
+        ${THIRD_PARTY_PATH}/install/${OPENCV_LIB}/sdk/native/jni)
+    else()
+      # Installing OpenCV shared lib to FastDeploy third_libs/install dir.
+      download_and_decompress(${OPENCV_URL} ${CMAKE_CURRENT_BINARY_DIR}/${OPENCV_LIB}${COMPRESSED_SUFFIX} ${THIRD_PARTY_PATH}/install)
+      set(OpenCV_DIR ${THIRD_PARTY_PATH}/install/${OPENCV_LIB}/sdk/native/jni)
+      get_filename_component(OpenCV_NATIVE_DIR ${OpenCV_DIR} DIRECTORY)
+      set(OpenCV_INCLUDE_DIRS ${OpenCV_DIR}/include)
+      set(OpenCV_LIBS_DIR ${OpenCV_NATIVE_DIR}/libs)
+      include_directories(${OpenCV_INCLUDE_DIRS})
+      add_library(external_opencv_java STATIC IMPORTED GLOBAL)
+      set_property(TARGET external_opencv_java PROPERTY IMPORTED_LOCATION 
+        ${OpenCV_LIBS_DIR}/${ANDROID_ABI}/${OPENCV_ANDROID_SHARED_LIB_NAME})
+      list(APPEND DEPEND_LIBS external_opencv_java)
+    endif()
+  # Win/Linux/Mac
+  else()
+    download_and_decompress(${OPENCV_URL} ${CMAKE_CURRENT_BINARY_DIR}/${OPENCV_LIB}${COMPRESSED_SUFFIX} ${THIRD_PARTY_PATH}/install/)
+    set(OpenCV_DIR ${THIRD_PARTY_PATH}/install/${OPENCV_LIB}/)
+    if (WIN32)
+      set(OpenCV_DIR ${OpenCV_DIR}/build/)
+    endif()
+    find_package(OpenCV REQUIRED PATHS ${OpenCV_DIR})
+    include_directories(${OpenCV_INCLUDE_DIRS})
+    list(APPEND DEPEND_LIBS ${OpenCV_LIBS})
+  endif()
 endif()
-find_package(OpenCV REQUIRED PATHS ${OpenCV_DIR})
-include_directories(${OpenCV_INCLUDE_DIRS})
-list(APPEND DEPEND_LIBS ${OpenCV_LIBS})

cmake/paddlelite.cmake

@@ -18,6 +18,7 @@ set(PADDLELITE_PROJECT "extern_paddlelite")
 set(PADDLELITE_PREFIX_DIR ${THIRD_PARTY_PATH}/paddlelite)
 set(PADDLELITE_SOURCE_DIR
     ${THIRD_PARTY_PATH}/paddlelite/src/${PADDLELITE_PROJECT})
+# TODO(qiuyanjun): install all paddle library to 'paddlelibs' dir.    
 set(PADDLELITE_INSTALL_DIR ${THIRD_PARTY_PATH}/install/paddlelite)  
 set(PADDLELITE_INC_DIR
     "${PADDLELITE_INSTALL_DIR}/include"
@@ -27,29 +28,43 @@ set(PADDLELITE_LIB_DIR
     CACHE PATH "paddlelite lib directory." FORCE)
 set(CMAKE_BUILD_RPATH "${CMAKE_BUILD_RPATH}" "${PADDLELITE_LIB_DIR}")
 
-#set(PADDLELITE_URL "https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.11/inference_lite_lib.armlinux.armv8.gcc.with_extra.with_cv.tar.gz")
+set(PADDLELITE_URL_PREFIX "https://bj.bcebos.com/fastdeploy/third_libs")
-set(PADDLELITE_URL "https://bj.bcebos.com/fastdeploy/third_libs/lite-linux-arm64-20220920.tgz")
 
-if(WIN32)
+if(ANDROID)
-  message(FATAL_ERROR "Doesn't support windows platform with backend Paddle-Lite.")
+  if(WITH_LITE_STATIC)
-elseif(APPLE)
+      message(FATAL_ERROR "Doesn't support WTIH_LITE_STATIC=ON for Paddle-Lite now.")
-  message(FATAL_ERROR "Doesn't support Mac OSX platform with backend Paddle-Lite.")
+  endif()
-else()
+  # check ABI, toolchain
+  if((NOT ANDROID_ABI MATCHES "armeabi-v7a") AND (NOT ANDROID_ABI MATCHES "arm64-v8a"))
+    message(FATAL_ERROR "FastDeploy with Paddle-Lite only support armeabi-v7a, arm64-v8a now.")
+  endif()
+  if(NOT ANDROID_TOOLCHAIN MATCHES "clang")
+     message(FATAL_ERROR "Currently, only support clang toolchain while cross compiling FastDeploy for Android with Paddle-Lite backend, but found ${ANDROID_TOOLCHAIN}.")
+  endif()  
+endif()
+
+if(WIN32 OR APPLE OR IOS)
+  message(FATAL_ERROR "Doesn't support windows/mac/ios platform with backend Paddle-Lite now.")
+elseif(ANDROID)
+  set(PADDLELITE_URL "${PADDLELITE_URL_PREFIX}/lite-android-${ANDROID_ABI}-2.11.tgz")
+else() # Linux
   if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "aarch64")
-    set(PADDLELITE_URL "https://bj.bcebos.com/fastdeploy/third_libs/lite-linux-arm64-20220920.tgz")
+    set(PADDLELITE_URL "${PADDLELITE_URL_PREFIX}/lite-linux-arm64-20220920.tgz")
   else()
     message(FATAL_ERROR "Only support Linux aarch64 now, x64 is not supported with backend Paddle-Lite.")
   endif()
 endif()
 
-include_directories(${PADDLELITE_INC_DIR})
+if(WIN32 OR APPLE OR IOS)
-
+  message(FATAL_ERROR "Doesn't support windows/mac/ios platform with backend Paddle-Lite now.")
-if(WIN32)
+elseif(ANDROID AND WITH_LITE_STATIC)
-elseif(APPLE)
+  set(PADDLELITE_LIB "${PADDLELITE_LIB_DIR}/libpaddle_full_api_shared.a")
 else()
-  set(PADDLELITE_LIB "${PADDLELITE_INSTALL_DIR}/lib/libpaddle_full_api_shared.so")
+  set(PADDLELITE_LIB "${PADDLELITE_LIB_DIR}/libpaddle_full_api_shared.so")
 endif()
 
+include_directories(${PADDLELITE_INC_DIR})
+
 ExternalProject_Add(
   ${PADDLELITE_PROJECT}
   ${EXTERNAL_PROJECT_LOG_ARGS}

cmake/summary.cmake

@@ -52,6 +52,15 @@ function(fastdeploy_summary)
   message(STATUS "  ENABLE_TEXT               : ${ENABLE_TEXT}")
   message(STATUS "  ENABLE_DEBUG              : ${ENABLE_DEBUG}")
   message(STATUS "  ENABLE_VISION_VISUALIZE   : ${ENABLE_VISION_VISUALIZE}")
+  if(ANDROID)
+    message(STATUS "  ANDROID_ABI               : ${ANDROID_ABI}")
+    message(STATUS "  ANDROID_PLATFORM          : ${ANDROID_PLATFORM}")
+    message(STATUS "  ANDROID_NDK               : ${ANDROID_NDK}")
+    message(STATUS "  WITH_OPENCV_STATIC:       : ${WITH_OPENCV_STATIC}")
+    if(ENABLE_LITE_BACKEND)
+      message(STATUS "  WITH_LITE_STATIC          : ${WITH_LITE_STATIC}")
+    endif()
+  endif() 
   if (${BUILD_FASTDEPLOY_PYTHON})
     message(STATUS "  Python executable         : ${PYTHON_EXECUTABLE}")
     message(STATUS "  Python includes           : ${PYTHON_INCLUDE_DIR}")

examples/CMakeLists.txt

@@ -22,6 +22,21 @@ function(get_fastdeploy_example_names NAME_SPACE CLASS_NAME CC_FILE)
   set(${CLASS_NAME} ${_CLASS_NAME} PARENT_SCOPE)
 endfunction()
 
+function(config_fastdeploy_executable_link_flags TARGET_NAME)
+  if(ANDROID)
+    # some specific flags for Android.
+    set(COMMON_LINK_FLAGS "-Wl,-exclude-libs,ALL")
+    set(COMMON_LINK_FLAGS_REL "-Wl,-s,--gc-sections,-exclude-libs,ALL")
+    if(WITH_OPENCV_STATIC OR WITH_LITE_STATIC)
+      set(COMMON_LINK_FLAGS "${COMMON_LINK_FLAGS},--allow-multiple-definition")
+      set(COMMON_LINK_FLAGS_REL "${COMMON_LINK_FLAGS_REL},--allow-multiple-definition")
+    endif()
+    set_target_properties(${TARGET_NAME} PROPERTIES LINK_FLAGS ${COMMON_LINK_FLAGS})
+    set_target_properties(${TARGET_NAME} PROPERTIES LINK_FLAGS_RELEASE ${COMMON_LINK_FLAGS_REL})
+    set_target_properties(${TARGET_NAME} PROPERTIES LINK_FLAGS_MINSIZEREL ${COMMON_LINK_FLAGS_REL})
+  endif()
+endfunction()
+
 set(EXAMPLES_NUM 0)
 function(add_fastdeploy_executable FIELD CC_FILE)
   # temp target name/file var in function scope
@@ -33,6 +48,7 @@ function(add_fastdeploy_executable FIELD CC_FILE)
   if(EXISTS ${TEMP_TARGET_FILE} AND TARGET fastdeploy)
     add_executable(${TEMP_TARGET_NAME} ${TEMP_TARGET_FILE})
     target_link_libraries(${TEMP_TARGET_NAME} PUBLIC fastdeploy)
+    config_fastdeploy_executable_link_flags(${TEMP_TARGET_NAME})
     math(EXPR _EXAMPLES_NUM "${EXAMPLES_NUM} + 1")
     set(EXAMPLES_NUM ${_EXAMPLES_NUM} PARENT_SCOPE)
     string(LENGTH ${EXAMPLES_NUM} len)