Detect if necessary to build inferior with -pie for Android.

[chaoren]

Summary

• Add target_is_android check (with cached results).
• Make android_device_api also cache results.
• Also removes the need to pass --env OS=Android when testing against Android.

[clayborg]

Looks fine.

[danalbert]

test/lldbtest.py

1993 ↗

(On Diff #30027)

I thought this was >= 16. I don't think we supported it in 15.

[danalbert]

test/lldbtest.py

1993 ↗

(On Diff #30027)

Yes, 16 (4.1) was the first to support it: https://source.android.com/devices/tech/security/enhancements/enhancements41.html

[chaoren]

Ah okay, we'd need to update some comments in Android.cmake too then.

[chaoren]

• API 16 is the first to support PIE, not 14.

[danalbert]

LGTM.

[chaoren]

Minor fixup.

lldb/trunk/cmake/platforms/Android.cmake

 
 # flags and definitions
 remove_definitions( -DANDROID -D__ANDROID__ )
 add_definitions( -DANDROID -D__ANDROID_NDK__ -DLLDB_DISABLE_LIBEDIT )
 set( ANDROID True )
 set( __ANDROID_NDK__ True )
 
 # linking lldb-server statically for Android avoids the need to ship two
-# binaries (pie for API 21+ and non-pie for API 14-). It's possible to use
-# a non-pie shim on API 14-, but that requires lldb-server to dynamically export
+# binaries (pie for API 21+ and non-pie for API 16-). It's possible to use
+# a non-pie shim on API 16-, but that requires lldb-server to dynamically export
 # its symbols, which significantly increases the binary size. Static linking, on
 # the other hand, has little to no effect on the binary size.
 if ( NOT DEFINED LLVM_BUILD_STATIC )
  set( LLVM_BUILD_STATIC True )
 endif()
 
 set( ANDROID_ABI "${ANDROID_ABI}" CACHE INTERNAL "Android Abi" FORCE )
 if( ANDROID_ABI STREQUAL "x86" )

  if ( LLVM_BUILD_STATIC )
   # Temporary workaround for static linking with the latest API.
   set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -DANDROID_ARM_BUILD_STATIC" )
  endif()
 endif()
 
 if ( NOT LLVM_BUILD_STATIC )
  # PIE is required for API 21+ so we enable it if we're not statically linking
- # unfortunately, it is not supported before API 14 so we need to do something else there
- # see http://llvm.org/pr23457
+ # unfortunately, it is not supported before API 16 so we need to do something
+ # else there see http://llvm.org/pr23457
  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -pie -fPIE" )
 endif()
 
 # linker flags
 set( ANDROID_CXX_FLAGS    "${ANDROID_CXX_FLAGS} -fdata-sections -ffunction-sections" )
 set( ANDROID_LINKER_FLAGS "${ANDROID_LINKER_FLAGS} -Wl,--gc-sections" )
 
 # cache flags

lldb/trunk/test/lldbtest.py

def run_adb_command(cmd, device_id):
     device_id_args = []
     if device_id:
         device_id_args = ["-s", device_id]
     full_cmd = ["adb"] + device_id_args + cmd
     p = Popen(full_cmd, stdout=PIPE, stderr=PIPE)
     stdout, stderr = p.communicate()
     return p.returncode, stdout, stderr
 
+def target_is_android():
+    if not hasattr(target_is_android, 'result'):
+        triple = lldb.DBG.GetSelectedPlatform().GetTriple()
+        match = re.match(".*-.*-.*-android", triple)
+        target_is_android.result = match is not None
+    return target_is_android.result
+
 def android_device_api():
+    if not hasattr(android_device_api, 'result'):
         assert lldb.platform_url is not None
         device_id = None
         parsed_url = urlparse.urlparse(lldb.platform_url)
         if parsed_url.scheme == "adb":
             device_id = parsed_url.netloc.split(":")[0]
         retcode, stdout, stderr = run_adb_command(
             ["shell", "getprop", "ro.build.version.sdk"], device_id)
         if retcode == 0:
-        return int(stdout)
+            android_device_api.result = int(stdout)
         else:
             raise LookupError(
                 ">>> Unable to determine the API level of the Android device.\n"
                 ">>> stdout:\n%s\n"
                 ">>> stderr:\n%s\n" % (stdout, stderr))
+    return android_device_api.result
 
 #
 # Decorators for categorizing test cases.
 #
 
 from functools import wraps
 def python_api_test(func):
     """Decorate the item as a Python API only test."""
def expectedFailureAndroid(bugnumber=None, api_levels=None):
     """ Mark a test as xfail for Android.
 
     Arguments:
         bugnumber - The LLVM pr associated with the problem.
         api_levels - A sequence of numbers specifying the Android API levels
             for which a test is expected to fail.
     """
     def fn(self):
-        triple = self.dbg.GetSelectedPlatform().GetTriple()
-        match = re.match(".*-.*-.*-android", triple)
-        if match:
+        if target_is_android():
             if not api_levels:
                 return True
             device_api = android_device_api()
             return device_api and (device_api in api_levels)
 
     return expectedFailure(fn, bugnumber)
 
 # if the test passes on the first try, we're done (success)
def skipIfTargetAndroid(api_levels=None):
     def myImpl(func):
         if isinstance(func, type) and issubclass(func, unittest2.TestCase):
             raise Exception("@skipIfTargetAndroid can only be used to "
                             "decorate a test method")
         @wraps(func)
         def wrapper(*args, **kwargs):
             from unittest2 import case
             self = args[0]
-            triple = self.dbg.GetSelectedPlatform().GetTriple()
-            if re.match(".*-.*-.*-android", triple):
+            if target_is_android():
                 if api_levels:
                     device_api = android_device_api()
                     if device_api and (device_api in api_levels):
                         self.skipTest(
                             "skip on Android target with API %d" % device_api)
                 else:
                     self.skipTest("skip on Android target")
             func(*args, **kwargs)
def buildDsym(self, architecture=None, compiler=None, dictionary=None, clean=True):
         if not module.buildDsym(self, architecture, compiler, dictionary, clean):
             raise Exception("Don't know how to build binary with dsym")
 
     def buildDwarf(self, architecture=None, compiler=None, dictionary=None, clean=True):
         """Platform specific way to build binaries with dwarf maps."""
         if lldb.skip_build_and_cleanup:
             return
         module = builder_module()
+        if target_is_android():
+            if dictionary is None:
+                dictionary = {}
+            dictionary["OS"] = "Android"
+            if android_device_api() >= 16:
+                dictionary["PIE"] = 1
         if not module.buildDwarf(self, architecture, compiler, dictionary, clean):
             raise Exception("Don't know how to build binary with dwarf")
 
     def signBinary(self, binary_path):
         if sys.platform.startswith("darwin"):
             codesign_cmd = "codesign --force --sign lldb_codesign %s" % (binary_path)
             call(codesign_cmd, shell=True)
 

lldb/trunk/test/make/Makefile.rules

ifneq (,$(findstring clang,$(CC)))
     LDFLAGS += -fuse-ld=lld
   endif
 endif
 
 #----------------------------------------------------------------------
 # Android specific options
 #----------------------------------------------------------------------
 ifeq "$(OS)" "Android"
+    ifdef PIE
         LDFLAGS += -pie
+    endif
     replace_with = $(if $(findstring clang,$(1)), \
                         $(subst clang,$(2),$(1)), \
                         $(if $(findstring gcc,$(1)), \
                              $(subst gcc,$(2),$(1)), \
                              $(subst cc,$(2),$(1))))
     ifeq "$(notdir $(CC))" "$(CC)"
         replace_cc_with = $(call replace_with,$(CC),$(1))
     else