Improved ndk-build integration.

Reviewed By: jvillard

Differential Revision: D3450150

fbshipit-source-id: a3163e5
master
Daiva Naudziuniene 9 years ago committed by Facebook Github Bot 6
parent 4e67ff6771
commit 6054b4c6d4

@ -1,2 +0,0 @@
TOOLCHAIN_ARCH := arm
TOOLCHAIN_ABIS := armeabi armeabi-v7a armeabi-v7a-hard

@ -1,159 +0,0 @@
# A custom toolchain for infer to intercept calls to clang
# This file is modified toochain/arm-linux-androideabi-clang3.6/setup.mk
# Copyright (C) 2014 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# this file is used to prepare the NDK to build with the arm clang-3.6
# toolchain any number of source files
#
# its purpose is to define (or re-define) templates used to build
# various sources into target object files, libraries or executables.
#
# Note that this file may end up being parsed several times in future
# revisions of the NDK.
#
#
# Override the toolchain prefix
#
TOOLCHAIN_VERSION := 4.8
TOOLCHAIN_NAME := arm-linux-androideabi-$(TOOLCHAIN_VERSION)
TOOLCHAIN_ROOT := $(NDK_ROOT)/toolchains/$(TOOLCHAIN_NAME)
TOOLCHAIN_PREBUILT_ROOT := $(call host-prebuilt-tag,$(TOOLCHAIN_ROOT))
TOOLCHAIN_PREFIX := $(TOOLCHAIN_PREBUILT_ROOT)/bin/arm-linux-androideabi-
# empty path to clang
TARGET_CC := clang$(HOST_EXEEXT)
TARGET_CXX := clang++$(HOST_EXEEXT)
#
# CFLAGS
#
TARGET_CFLAGS := \
-gcc-toolchain $(call host-path,$(TOOLCHAIN_PREBUILT_ROOT)) \
-fpic \
-ffunction-sections \
-funwind-tables \
-fstack-protector-strong \
-Wno-invalid-command-line-argument \
-Wno-unused-command-line-argument \
-no-canonical-prefixes
# Disable integrated-as for better compatibility
TARGET_CFLAGS += \
-fno-integrated-as \
-flto # to generate .o files in one clang call
TARGET_C_INCLUDES := \
$(SYSROOT_INC)/usr/include
ifneq ($(filter %armeabi-v7a,$(TARGET_ARCH_ABI)),)
LLVM_TRIPLE := armv7-none-linux-androideabi
TARGET_CFLAGS += -target $(LLVM_TRIPLE) \
-march=armv7-a \
-mfloat-abi=softfp \
-mfpu=vfpv3-d16
else
ifneq ($(filter %armeabi-v7a-hard,$(TARGET_ARCH_ABI)),)
LLVM_TRIPLE := armv7-none-linux-androideabi
TARGET_CFLAGS += -target $(LLVM_TRIPLE) \
-march=armv7-a \
-mfpu=vfpv3-d16 \
-mhard-float \
-D_NDK_MATH_NO_SOFTFP=1
else
LLVM_TRIPLE := armv5te-none-linux-androideabi
TARGET_CFLAGS += -target $(LLVM_TRIPLE) \
-march=armv5te \
-mtune=xscale \
-msoft-float
endif
endif
TARGET_CFLAGS.neon := -mfpu=neon
TARGET_arm_release_CFLAGS := -O2 \
-g \
-DNDEBUG \
-fomit-frame-pointer \
-fstrict-aliasing
TARGET_thumb_release_CFLAGS := -mthumb \
-Os \
-g \
-DNDEBUG \
-fomit-frame-pointer \
-fno-strict-aliasing
# When building for debug, compile everything as arm.
TARGET_arm_debug_CFLAGS := $(TARGET_arm_release_CFLAGS) \
-O0 \
-UNDEBUG \
-fno-omit-frame-pointer \
-fno-strict-aliasing
TARGET_thumb_debug_CFLAGS := $(TARGET_thumb_release_CFLAGS) \
-O0 \
-UNDEBUG \
-marm \
-fno-omit-frame-pointer
# This function will be called to determine the target CFLAGS used to build
# a C or Assembler source file, based on its tags.
#
TARGET-process-src-files-tags = \
$(eval __arm_sources := $(call get-src-files-with-tag,arm)) \
$(eval __thumb_sources := $(call get-src-files-without-tag,arm)) \
$(eval __debug_sources := $(call get-src-files-with-tag,debug)) \
$(eval __release_sources := $(call get-src-files-without-tag,debug)) \
$(call set-src-files-target-cflags, \
$(call set_intersection,$(__arm_sources),$(__debug_sources)), \
$(TARGET_arm_debug_CFLAGS)) \
$(call set-src-files-target-cflags,\
$(call set_intersection,$(__arm_sources),$(__release_sources)),\
$(TARGET_arm_release_CFLAGS)) \
$(call set-src-files-target-cflags,\
$(call set_intersection,$(__arm_sources),$(__debug_sources)),\
$(TARGET_arm_debug_CFLAGS)) \
$(call set-src-files-target-cflags,\
$(call set_intersection,$(__thumb_sources),$(__release_sources)),\
$(TARGET_thumb_release_CFLAGS)) \
$(call set-src-files-target-cflags,\
$(call set_intersection,$(__thumb_sources),$(__debug_sources)),\
$(TARGET_thumb_debug_CFLAGS)) \
$(call add-src-files-target-cflags,\
$(call get-src-files-with-tag,neon),\
$(TARGET_CFLAGS.neon)) \
$(call set-src-files-text,$(__arm_sources),arm) \
$(call set-src-files-text,$(__thumb_sources),thumb)
# Re-defining default build commands
# Link / install / strip as noop
define cmd-build-shared-library
endef
define host-install
endef
define cmd-strip
endef

@ -5,12 +5,8 @@
# LICENSE file in the root directory of this source tree. An additional grant
# of patent rights can be found in the PATENTS file in the same directory.
import os
import shutil
import make
import util
from inferlib import config
MODULE_NAME = 'ndk-build/clang'
MODULE_DESCRIPTION = '''Run analysis of code built with ndk-build
@ -29,51 +25,6 @@ create_argparser = \
class NdkBuildCapture(make.MakeCapture):
def __init__(self, args, cmd):
cmd = [cmd[0], 'NDK_TOOLCHAIN_VERSION=clang', 'TARGET_CC=clang',
'TARGET_CXX=clang++', 'TARGET_LD=ld'] + cmd[1:]
make.MakeCapture.__init__(self, args, cmd)
def get_envvars(self):
env_vars = make.MakeCapture.get_envvars(self)
env_vars['NDK_TOOLCHAIN'] = 'infer'
return env_vars
def _get_android_ndk_dir(self):
# TODO: other ways to get android_ndk
android_ndk = self.get_envvars()['ANDROID_NDK']
if not os.path.exists(android_ndk):
raise Exception('Cannot find the location of the Android NDK. '
'Please set the ANDROID_NDK environment variable '
'to a path containing an installation of the '
'Android NDK.')
return android_ndk
def _setup_infer_toolchain(self):
src_dir = os.path.join(config.LIB_DIRECTORY, 'ndk_capture', 'infer')
android_ndk = self._get_android_ndk_dir()
dest_dir = os.path.join(android_ndk, 'toolchains', 'infer')
if not os.path.exists(dest_dir):
try:
shutil.copytree(src_dir, dest_dir)
except shutil.Error:
raise Exception('An error occurred while setting up infer '
'toolchain in Android NDK. Please ensure '
'infer has write access to the '
'$ANDROID_NDK/toolchains directory.')
def _cleanup_infer_toolchain(self):
android_ndk = self._get_android_ndk_dir()
infer_toolchain = os.path.join(android_ndk, 'toolchains', 'infer')
if os.path.exists(infer_toolchain):
try:
shutil.rmtree(infer_toolchain)
except shutil.Error:
raise Exception('An error occurred while cleaning up infer '
'toolchain in Android NDK. Please ensure '
'infer has write access to the '
'$ANDROID_NDK/toolchains directory.')
def capture(self):
try:
self._setup_infer_toolchain()
return make.MakeCapture.capture(self)
finally:
self._cleanup_infer_toolchain()

@ -339,11 +339,20 @@ class BuildIntegrationTest(unittest.TestCase):
root = os.path.join(CODETOANALYZE_DIR, 'ndk-build', 'hello_app')
gen_lib_dir = os.path.join(root, 'libs')
gen_obj_dir = os.path.join(root, 'obj')
env = os.environ.copy()
ndk_dir = os.getenv('ANDROID_NDK',
os.path.join(os.path.sep,
'opt',
'android_ndk',
'r10e'))
env['PATH'] = '{}:{}'.format(os.getenv('PATH'), ndk_dir)
if test('ndk-build', 'ndk-build',
root,
[['ndk-build', '-B', 'NDK_LIBS_OUT=./libs', 'NDK_OUT=./obj']],
clean_commands=[['ndk-build', 'clean']],
available=lambda: is_tool_available(['ndk-build', '-v'])):
available=lambda: is_tool_available([
os.path.join(ndk_dir, 'ndk-build'), '-v']),
env=env):
# remove libs/ and obj/ directories
shutil.rmtree(gen_lib_dir)
shutil.rmtree(gen_obj_dir)

Loading…
Cancel
Save