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

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

[danalbert]

test/lldbtest.py

1993

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.

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 = self.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():
+            dictionary["OS"] = "Android"
+            if android_device_api() > 14:
+                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)
 

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