Add support for running lldb-test on android targets

[chying]

Summary

• Add build/compile steps for android target using ndk
• Modify current remote test steps to work for android
• Allow combination of running lldb tests on local host, android and linux platform

[chying]

Revert one local workaround that was accidentially included in previous revision

[sivachandra]

Hi,

This change is fairly large that I need time to digest all of it. I have few preliminary nitty comments. Addressing them might help me digest faster.

A general comment is that commands being specified as strings and not lists. We should do this only if it is unavoidable, for example on LLDBBuilder.py:368. I should have pointed this out during the review of http://reviews.llvm.org/D8711.

zorg/buildbot/builders/LLDBBuilder.py

416 ↗

(On Diff #24663)

I think time has come to add doc strings describing what these args are and how they should be formatted.

475 ↗

(On Diff #24663)

I think this function can be named getLLDBAndroidCmakeStep and decoupled with compilation step. Non-Android cmake step can be as before. See my comments below.

504 ↗

(On Diff #24663)

I know this is copied over code, but I think it is better done this way:

cmake_args.append("-DCMAKE_C_COMPILER=%s" % getCCompilerCmd(build_compiler))
cmake_args.append("-DCMAKE_CXX_COMPILER=%s" % getCxxCompilerCmd(build_compiler))

The get functions as follows:

def getCCompilerCmd(compiler):
  if compiler == "clang":
    return "clang"
  elif compiler == "gcc":
    return "gcc"

def getCxxCompilerCmd(compiler):
  if compiler == "clang":
    return "clang++"
  elif compiler == "gcc":
    return "gcc++"

528 ↗

(On Diff #24663)

Looks like the only reason config step and compile step are combined in this function is because of |extra_ninja_cmd|. If you treat |extra_ninja_cmd| as |ninja_targets|, then this will not be required. As in, linux builds take no targets (implying all targets), while android builds take one target named "lldb-server".

531 ↗

(On Diff #24663)

+1 wrt PEP8, but I think it is not following the style in this file.

[chying]

> A general comment is that commands being specified as strings and not lists. We should do this only if it is unavoidable, for example on LLDBBuilder.py:368.
Using lists makes it slightly more complicated when there're single/double quotes in the command.
I will try to convert strings to lists in the next revision.

zorg/buildbot/builders/LLDBBuilder.py

416 ↗

(On Diff #24663)

Will do this in next revision.

475 ↗

(On Diff #24663)

This function contains both steps, because cmake and compilation step will always be called together for local configuration first, and then once for each target platform. If compilation step is decoupled, then we need to have the same code for compilation step in multiple places.

528 ↗

(On Diff #24663)

Same as above, these two steps are combined because they will be called together.
It's good to add ninja_targets.

[sivachandra]

zorg/buildbot/builders/LLDBBuilder.py

475 ↗

(On Diff #24663)

OK. Then I suggest 1. Rename getLLDBCmakeCompileSteps to getLLDBCMakeAndCompileSteps. 2. Add these functions:

def getLLDBCMakeStep(...):
  if ... == 'linux':
    getLLDBLinuxCMakeStep(...)
  elif ... == 'android':
    getLLDBAndroidCMakeStep(...)

def getLLDBLinuxCMakeStep(...):
  ...

def getLLDBAndroidCMakeStep(...):
  ...

[sivachandra]

zorg/buildbot/builders/LLDBBuilder.py

475 ↗

(On Diff #24663)

Sorry, forgot to mention that you should call getLLDBCMakeStep from getLLDBCMakeAndCompileSteps.

[chying]

1. Convert shell command single strings to list of strings when possible
2. Add Docstring for getLLDBUbuntuCMakeBuildFactory function
3. Add one step to clean remote directory after remote testing
4. Break cmake function to smaller functions

[chying]

Use 'adb://deviceid:port' as platform url to connect android devices since lldb support multiple devices

[sivachandra]

LGTM with nits.

I have not gone through the correctness of the various commands involved as I do not understand them yet. Chaoren, can you do that?

zorg/buildbot/builders/LLDBBuilder.py

257 ↗

(On Diff #24832)

Nit: space before and after '='. Except when specifying default function args, there should be a space before and after '='. Space like that are missing at a number of places in this change. Same should be done with '+=' as well.

347 ↗

(On Diff #24832)

Nit: Python variables "leak" out of scope. Hence, you do not need lines 344-347.

404 ↗

(On Diff #24832)

Seems like there should be an 'else' case which just returns 'f'. Not that it matters in the current state of affairs, but it seems like a hole in the logic. For, if the platform is neither linux nor android, you will still go ahead and add other steps. I am not sure if this is OK.

561 ↗

(On Diff #24832)

Nit: seems like you could just say return getLLDB....

567 ↗

(On Diff #24832)

Same here.

[chying]

zorg/buildbot/builders/LLDBBuilder.py

347 ↗

(On Diff #24832)

Thanks, It's good to know.

404 ↗

(On Diff #24832)

This case will be handled in the beginning of this function,
' # only supports linux and android as remote target at this time

if remote_config.platform not in ('linux', 'android'):
      return f '

[sivachandra]

buildbot/osuosl/master/config/builders.py

751 ↗

(On Diff #24832)

Sorry for the revisit. Is this a change you forgot to uncomment before uploading?

Nit: there should be a space before and after ','. This happens at a number of places in this change.

zorg/buildbot/builders/LLDBBuilder.py

404 ↗

(On Diff #24832)

Ah, OK. Sorry, I missed it.

[chying]

Fix a few nits based on code review
Change job number for this slave to 40 since it's a 40 core station

zorg/trunk/buildbot/osuosl/master/config/builders.py

 
 from zorg.buildbot.builders import PollyBuilder
 reload(PollyBuilder)
 from zorg.buildbot.builders import PollyBuilder
 
 from zorg.buildbot.builders import LLDBBuilder
 reload(LLDBBuilder)
 from zorg.buildbot.builders import LLDBBuilder
+from zorg.buildbot.builders.LLDBBuilder import RemoteConfig
 
 from zorg.buildbot.builders import LLDBuilder
 reload(LLDBuilder)
 from zorg.buildbot.builders import LLDBuilder
 
 from zorg.buildbot.builders import LLGoBuilder
 reload(LLGoBuilder)
 from zorg.buildbot.builders import LLGoBuilder
return [
                         '--enable-assertions'],
                     env={'SHELL':"/bin/bash"})},
         {'name': "lldb-x86_64-ubuntu-14.04-cmake",
          'slavenames': ["lldb-build1-ubuntu-1404"],
          'builddir': "buildWorkingDir",
          'factory': LLDBBuilder.getLLDBUbuntuCMakeBuildFactory(
                     build_compiler="clang",
                     build_type="Debug",
-                    test_archs=['x86_64', 'i386'],
-                    test_compilers=['clang', 'totclang', 'gcc4.8.2', 'gcc4.9.2'],
-                    #remote_test_archs=['x86_64'],
-                    #remote_test_compilers=['clang'],
+                    local_test_archs=['x86_64', 'i386'],
+                    local_test_compilers=['clang', 'totclang', 'gcc4.8.2', 'gcc4.9.2'],
+                    #remote_configs=[RemoteConfig('linux','x86_64',['clang'],['x86_64'])],
                     env={'SHELL':"/bin/bash"})},
         {'name': "lldb-x86_64-darwin-13.4",
          'slavenames': ["lldb-x86_64-darwin-13.4"],
          'builddir': "buildDir",
          'factory': LLDBBuilder.getLLDBxcodebuildFactory()},
+        {'name': "lldb-x86_64-ubuntu-14.04-cross-compilation",
+         'slavenames': ["lldb-lab-linux01"],
+         'builddir': "lldb-cross-compile",
+         'factory': LLDBBuilder.getLLDBUbuntuCMakeBuildFactory(
+                    build_compiler="clang",
+                    build_type="Debug",
+                    remote_configs= [
+                                     RemoteConfig('android', 'i386', ['i686-linux-android-gcc'], ['i386']),
+                                     RemoteConfig('android', 'arm', ['arm-linux-androideabi-gcc'], ['arm']),
+                                     RemoteConfig('android', 'aarch64', ['aarch64-linux-android-gcc'], ['aarch64'])
+                                    ],
+                    env={'SHELL':"/bin/bash"})},
        ]
 
 # Offline.
 {'name': "lldb-x86_64-linux",
  'slavenames': ["gcc20"],
  'builddir': "lldb-x86_64",
  'factory': LLDBBuilder.getLLDBBuildFactory(triple="x86_64-pc-linux-gnu",
                                             env={'CXXFLAGS' : '-std=c++0x'})},

zorg/trunk/buildbot/osuosl/master/config/slaves.py

32},
         # Ubuntu x86-64, 51GiB System memory Intel(R) Xeon(R) CPU @ 2.60GHz
         create_slave("lldb-build1-ubuntu-1404", properties={'jobs': 16, 'loadaverage':
 32},
             max_builds=1),
         # Darwin 13.4.0, x86_64
         create_slave("lldb-x86_64-darwin-13.4", properties={'jobs': 16, 'loadaverage':32}, max_builds=1),
         # Ubuntu 14.04 x86_64, Intel(R) Xeon(R) CPU @ 2.30GHz
         create_slave("llgo-builder", properties={'jobs': 2}, max_builds=1),
+        # Ubuntu 14.04 x86_64, Intel(R) Xeon(R) CPU E5-2680 v2 @ 2.80GHz
+        create_slave("lldb-lab-linux01", properties={'jobs': 40}, max_builds=1),
         # Defunct.
         # Intel(R) Pentium(R) CPU G620 @ 2.60GHz, Ubuntu i686
         #create_slave("botether", properties={'jobs': 2}, max_builds=1),
 
         # Intel(R) Core(TM)2 CPU 6420  @ 2.13GHz, Ubuntu Oneiric x86_64
         #create_slave("arxan_davinci", properties={'jobs': 4}, max_builds=1),
 
         # Intel(R) Core(TM)2 CPU 6420  @ 2.13GHz, Ubuntu Oneiric x86_64

zorg/trunk/zorg/buildbot/builders/LLDBBuilder.py

 import os
 import json
-
+import collections
 import buildbot
 import buildbot.process.factory
 from buildbot.steps.source import SVN
 from buildbot.steps.shell import Configure, SetProperty
 from buildbot.steps.shell import ShellCommand, WarningCountingShellCommand
 from buildbot.steps.slave import RemoveDirectory
 from buildbot.process.properties import WithProperties, Property
 import zorg.buildbot.commands.BatchFileDownload as batch_file_download
f.addStep(LitTestCommand(name="test lldb",
                                       make],
                              description="test lldb",
                              env=env,
                              workdir='%s/tools/lldb/test' % llvm_objdir))
 
     return f
 # Add test steps from list of compilers and archs
 def getLLDBTestSteps(f,
-                     isRemoteTest,
                      bindir,
                      test_archs,
                      test_compilers,
+                     remote_platform=None,
                      remote_host=None,
                      remote_port=None,
                      remote_dir=None,
                      env=None):
     # Skip test steps if no test compiler or arch is specified
     if None in (test_archs, test_compilers):
         return f
     llvm_srcdir = "llvm"
     llvm_builddir = "build"
+    if env is None:
+        env = {}
+    extraTestFlag = ''
+    # TODO: for now, run tests with 8 threads and without mi tests on android
+    # come back when those issues are addressed
+    testenv=dict(env)
     for compiler in test_compilers:
         # find full path for top of tree clang
         if compiler=='totclang':
-            compilerPath=bindir+'/clang'
+            compilerPath=bindir + '/clang'
+        elif remote_platform is 'android':
+            compilerPath = '%(toolchain)s' + '/bin/' + compiler
         else:
             compilerPath = compiler
         for arch in test_archs:
             DOTEST_OPTS=''.join(['--executable ' + bindir + '/lldb ',
                                  '-A %s ' % arch,
                                  '-C %s ' % compilerPath,
                                  '-s lldb-test-traces-%s-%s ' % (compiler, arch),
                                  '-u CXXFLAGS ',
                                  '-u CFLAGS'])
             testname = "local"
-            if(isRemoteTest):
-                DOTEST_OPTS+=''.join([' --platform-name remote-linux ',
-                                      '--platform-url connect://%(remote_host)s:%(remote_port)s ',
-                                      '--platform-working-dir %(remote_dir)s'])
-                testname = "remote"
+            if remote_platform is not None:
+                urlStr='connect://%(remote_host)s:%(remote_port)s'
+                if remote_platform is 'android':
+                    testenv['LLDB_TEST_THREADS'] = '8'
+                    extraTestFlag = ' -m'
+                    urlStr = 'adb://%(deviceid)s:%(remote_port)s'
+                DOTEST_OPTS += ''.join([' --platform-name remote-' + remote_platform,
+                                        ' --platform-url ' + urlStr,
+                                        ' --platform-working-dir %(remote_dir)s',
+                                        ' --env OS=' + remote_platform.title()])
+                testname = "remote-" + remote_platform
+            DOTEST_OPTS += extraTestFlag
             f.addStep(LitTestCommand(name="test lldb %s (%s-%s)" % (testname, compiler, arch),
                                      command=['../%s/tools/lldb/test/dosep.py' % llvm_srcdir,
                                               '--options',
                                               WithProperties(DOTEST_OPTS)],
                                      description="test lldb",
                                      parseSummaryOnly=True,
-                                     workdir='%s' % llvm_builddir))
+                                     workdir='%s' % llvm_builddir,
+                                     env=testenv))
             f=cleanSVNSourceTree(f, '%s/tools/lldb' % llvm_srcdir)
     return f
 
+# Define a structure to describe remote target
+# For example, RemoteConfig('linux','x86_64',['gcc4.8.2','clang'],['i386'])
+RemoteConfig = collections.namedtuple("RemoteConfig", ["platform", "host_arch", "test_compilers", "test_archs"])
+
 # Add steps to run lldb test on remote target
 def getLLDBRemoteTestSteps(f,
                            bindir,
-                           remote_test_archs,
-                           remote_test_compilers,
+                           build_type,
+                           remote_config,
                            env):
-
-    if None in (remote_test_archs, remote_test_compilers):
+    if None in (remote_config.test_archs, remote_config.test_compilers):
+        return f
+    # only supports linux and android as remote target at this time
+    if remote_config.platform not in ('linux', 'android'):
         return f
     llvm_srcdir = "llvm"
     llvm_builddir = "build"
+    stepDesc = remote_config.platform + "-" + remote_config.host_arch
     # get hostname
-    slave_hostname=None
+    slave_hostname = None
     f.addStep(SetProperty(name="get hostname",
                           command=["hostname"],
                           property="slave_hostname",
                           description="set slave hostname",
                           workdir="."))
     # get configuration of remote target
     # config file should be placed under builddir on builder machine
     # file name: remote_cfg.json
-    # content: json format with keys "remote_host", "remote_port", and "remote_dir"
-    # example: {"remote_host":"remotehostname","remote_port":"1234","remote_dir":"/path/to/dir"}
+    # content: json format with keys [remote_platform]-[remote_arch]
+    # the value for each key defines "remote_host", "remote_port", "remote_dir", "toolchain", "deviceId"
+    # example: {"android-i386": {"remote_host":"localhost",
+    #                            "remote_port":"5430",
+    #                            "remote_dir":"/data/local/tmp/lldb",
+    #                            "toolchain":"/home/lldb_build/Toolchains/i386-android-toolchain",
+    #                            "deviceid":"XXXXXXX"},
+
     def getRemoteCfg(rc, stdout, stderr):
-       return json.loads(stdout)
-    f.addStep(SetProperty(name="get remote target",
+        return json.loads(stdout)[stepDesc]
+    f.addStep(SetProperty(name="get remote target " + stepDesc,
                           command="cat remote_cfg.json",
                           extract_fn=getRemoteCfg,
                           description="get remote target",
                           workdir="."))
     # rsync
+    if remote_config.platform is 'linux':
+        shellcmd = ['ssh',
+                    WithProperties('%(remote_host)s')]
+        hostname = '%(slave_hostname)s'
+        launchcmd = shellcmd + ['screen', '-d', '-m']
+        terminatecmd = shellcmd + ['pkill', 'lldb-server']
+        cleandircmd = WithProperties('ssh %(remote_host)s rm -rf %(remote_dir)s/*')
         f.addStep(ShellCommand(name="rsync lldb-server",
-                           command=WithProperties("rsync -hav bin/lldb-server* %(remote_host)s:%(remote_dir)s"),
-                           description="rsync lldb-server",
+                               command=['rsync',
+                                        '-havL',
+                                        'bin/lldb-server',
+                                        WithProperties('%(remote_host)s:%(remote_dir)s')],
+                               description="rsync lldb-server " + stepDesc,
                                haltOnFailure=True,
                                env=env,
                                workdir='%s' % llvm_builddir))
         f.addStep(ShellCommand(name="rsync python2.7",
-                           command=WithProperties("rsync -havL lib/python2.7 %(remote_host)s:%(remote_dir)s"),
-                           description="rsync python2.7",
+                               command=['rsync',
+                                        '-havL',
+                                        'lib/python2.7',
+                                        WithProperties('%(remote_host)s:%(remote_dir)s')],
+                               description="rsync python2.7 " + stepDesc,
                                haltOnFailure=True,
                                env=env,
                                workdir='%s' % llvm_builddir))
+    elif remote_config.platform is 'android':
+        shellcmd = ['adb',
+                    '-s',
+                    WithProperties('%(deviceid)s'),
+                    'shell']
+        hostname = 'localhost'
+        launchcmd = ['screen', '-d', '-m']  + shellcmd
+        terminatecmd = 'ps | grep lldb-server | awk \'{print $2}\' | xargs'
+        terminatecmd = WithProperties('adb -s %(deviceid)s shell ' + terminatecmd + ' adb -s %(deviceid)s shell kill')
+        cleandircmd = WithProperties('adb -s %(deviceid)s shell rm -rf %(remote_dir)s/*')
+        # compile lldb-server for target platform
+        f = getLLDBCmakeAndCompileSteps(f,
+                                        'gcc',
+                                        build_type,
+                                        ['lldb-server'],
+                                        bindir,
+                                        remote_config.platform,
+                                        remote_config.host_arch,
+                                        env)
+
+        f.addStep(ShellCommand(name="adb push lldb-server " + stepDesc,
+                               command=['adb',
+                                        '-s',
+                                        WithProperties('%(deviceid)s'),
+                                        'push',
+                                        remote_config.platform+'-' + remote_config.host_arch + '/bin/lldb-server',
+                                        WithProperties('%(remote_dir)s/')],
+                               description="lldb-server",
+                               env=env,
+                               haltOnFailure=True,
+                               workdir='%s' % llvm_builddir))
     # launch lldb-server
-    f.addStep(ShellCommand(name="launch lldb-server",
-                           command=WithProperties("ssh %(remote_host)s screen -d -m %(remote_dir)s/lldb-server platform --listen %(slave_hostname)s:%(remote_port)s --server"),
+    f.addStep(ShellCommand(name="launch lldb-server " + stepDesc,
+                           command=launchcmd +
+                                   [WithProperties('%(remote_dir)s/lldb-server'),
+                                    'platform',
+                                    '--listen',
+                                    WithProperties(hostname + ':%(remote_port)s'),
+                                    '--server'],
                            description="launch lldb-server on remote host",
                            env=env,
                            haltOnFailure=True,
                            workdir='%s' % llvm_builddir))
     # test steps
     f = getLLDBTestSteps(f,
-                         True,
                          bindir,
-                         remote_test_archs,
-                         remote_test_compilers,
+                         remote_config.test_archs,
+                         remote_config.test_compilers,
+                         remote_config.platform,
                          '%(remote_host)s',
                          '%(remote_port)s',
                          '%(remote_dir)s',
                          env)
     # terminate lldb-server on remote host
-    f.addStep(ShellCommand(name="terminate lldb-server remote",
-                           command=WithProperties("ssh %(remote_host)s pkill lldb-server"),
+    f.addStep(ShellCommand(name="terminate lldb-server " + stepDesc,
+                           command=terminatecmd,
                            description="terminate lldb-server",
                            env=env,
                            workdir='%s' % llvm_builddir))
+    # clean remote test directory
+    f.addStep(ShellCommand(name="clean remote dir " + stepDesc,
+                           command=cleandircmd,
+                           description="clean remote dir",
+                           env=env))
     return f
 
 # Cmake bulid on Ubuntu
 # Build command sequence - cmake, ninja, ./dosep
 # Note: If test_archs or test_compilers is not specified, lldb-test will not be added to build factory
 def getLLDBUbuntuCMakeBuildFactory(build_compiler,
                                    build_type,
-                                   test_archs=None,
-                                   test_compilers=None,
-                                   remote_test_archs=None,
-                                   remote_test_compilers=None,
+                                   local_test_archs=None,
+                                   local_test_compilers=None,
+                                   remote_configs=None,
                                    jobs='%(jobs)s',
-                                   env=None,
-                                   *args,
-                                   **kwargs):
+                                   env=None):
+    """Generate factory steps for ubuntu cmake builder
 
+       Arguments:
+       build_compiler       -- string of compile name, example 'clang',
+                               the compiler will be used to build binaries for host platform
+       build_type           -- 'Debug' or 'Release',
+                               used to define build type for host platform as well as remote platform if any
+       local_test_archs     -- list of architectures, example ['i386','x86_64'],
+                               defines architectures to run local tests against, if None, local tests won't be executed
+       local_test_compiler  -- list of compilers, example ['clang','gcc4.8.2'],
+                               definds compilers to run local tests with, if None, local tests won't be executed
+       remote_configs       -- list of RemoteConfig objects, example [RemoteConfig(...)], if None, remote tests won't be executed
+       jobs                 -- number of threads for compilation step, example 40
+                               default value is jobs number defined during slave creation
+       env                  -- environment variables passed to shell commands
+
+    """
     if env is None:
-        env={}
+        env = {}
 
     llvm_srcdir = "llvm"
     llvm_builddir = "build"
     bindir='%(builddir)s/' + llvm_builddir + '/bin'
 
     f = buildbot.process.factory.BuildFactory()
 
     # Determine the build directory.
     f.addStep(SetProperty(name="get_builddir",
                           command=["pwd"],
                           property="builddir",
                           description="set build dir",
                           workdir="."))
     # Get source code
     f = getLLDBSource(f,llvm_srcdir)
 
-    # Construct cmake
-    cmake_args = ["cmake", "-GNinja"]
-    if build_compiler == "clang":
-        cmake_args.append("-DCMAKE_C_COMPILER=clang")
-        cmake_args.append("-DCMAKE_CXX_COMPILER=clang++")
-    elif build_compiler == "gcc":
-        cmake_args.append("-DCMAKE_C_COMPILER=gcc")
-        cmake_args.append("-DCMAKE_CXX_COMPILER=g++")
-
-    cmake_args.append(WithProperties("-DCMAKE_BUILD_TYPE=%s" % build_type))
-    cmake_args.append(WithProperties("../%s" % llvm_srcdir))
-
     # Clean Build Folder
     f.addStep(ShellCommand(name="clean",
                            command="rm -rf *",
                            description="clear build folder",
                            env=env,
                            workdir='%s' % llvm_builddir))
-    # Configure
-    f.addStep(Configure(name='configure/cmake',
-                        command=cmake_args,
-                        env=env,
-                        workdir=llvm_builddir))
-    # Compile
-    f.addStep(WarningCountingShellCommand(name="compile/ninja",
-                                          command=['nice', '-n', '10',
-                                                   'ninja', WithProperties("-j%s" % jobs)],
-                                          env=env,
-                                          haltOnFailure=True,
-                                          workdir=llvm_builddir))
+
+    f = getLLDBCmakeAndCompileSteps(f,
+                                    build_compiler,
+                                    build_type,
+                                    [],
+                                    bindir,
+                                    'linux',
+                                    'x86_64',
+                                    env)
 
     # TODO: it will be good to check that architectures listed in test_archs are compatible with host architecture
     # For now, the caller of this function should make sure that each target architecture is supported by builder machine
 
     # Add local test steps
     f = getLLDBTestSteps(f,
-                         False,
                          bindir,
-                         test_archs,
-                         test_compilers)
-    # Remote test
+                         local_test_archs,
+                         local_test_compilers)
+    # Remote test steps
+    if remote_configs is not None:
+        for config in remote_configs:
             f = getLLDBRemoteTestSteps(f,
                                        bindir,
-                               remote_test_archs,
-                               remote_test_compilers,
+                                       build_type,
+                                       config,
                                        env)
+
+    return f
+
+# for cmake and compile
+def getLLDBCmakeAndCompileSteps(f,
+                                build_compiler,
+                                build_type,
+                                ninja_target,
+                                bindir,
+                                target_platform,
+                                target_arch,
+                                env=None):
+
+    if env is None:
+        env={}
+    llvm_builddir = 'build'
+    if target_platform is 'android':
+        llvm_builddir = 'build/android-' + target_arch
+    # Configure
+    f = getLLDBCMakeStep(f,
+                         build_compiler,
+                         build_type,
+                         bindir,
+                         target_platform,
+                         target_arch,
+                         env)
+    # Compile
+    f.addStep(WarningCountingShellCommand(name='ninja-%s-%s'%(target_platform, target_arch),
+                                          command=['nice','-n', '10',
+                                                   'ninja',
+                                                   WithProperties('-j%(jobs)s')] + ninja_target,
+                                          env=env,
+                                          haltOnFailure=True,
+                                          workdir=llvm_builddir))
+    return f
+
+def getLLDBCMakeStep(f,
+                     build_compiler,
+                     build_type,
+                     bindir,
+                     target_platform,
+                     target_arch,
+                     env=None):
+    if target_platform is 'linux':
+        return getLLDBLinuxCMakeStep(f,
+                                     build_compiler,
+                                     build_type,
+                                     target_arch,
+                                     env)
+    elif target_platform is 'android':
+        return getLLDBAndroidCMakeStep(f,
+                                       build_compiler,
+                                       build_type,
+                                       bindir,
+                                       target_arch,
+                                       env)
+
+def getCCompilerCmd(compiler):
+  if compiler == "clang":
+    return "clang"
+  elif compiler == "gcc":
+    return "gcc"
+
+def getCxxCompilerCmd(compiler):
+  if compiler == "clang":
+    return "clang++"
+  elif compiler == "gcc":
+    return "g++"
+
+def getLLDBLinuxCMakeStep(f,
+                          build_compiler,
+                          build_type,
+                          target_arch,
+                          env=None):
+    if env is None:
+        env = {}
+    llvm_srcdir = 'llvm'
+    llvm_builddir = 'build'
+    # Construct cmake
+    cmake_args = ["cmake", "-GNinja"]
+    cmake_args.append(WithProperties("-DCMAKE_BUILD_TYPE=%s" % build_type))
+    cmake_args.append(WithProperties('%(builddir)s/' + llvm_srcdir))
+    cmake_args.append("-DCMAKE_C_COMPILER=%s" % getCCompilerCmd(build_compiler))
+    cmake_args.append("-DCMAKE_CXX_COMPILER=%s" % getCxxCompilerCmd(build_compiler))
+
+    f.addStep(Configure(name='cmake-linux-%s' % (target_arch),
+                        command=cmake_args,
+                        env=env,
+                        haltOnFailure=True,
+                        workdir=llvm_builddir))
+    return f
+
+def getLLDBAndroidCMakeStep(f,
+                            build_compiler,
+                            build_type,
+                            bindir,
+                            target_arch,
+                            env):
+    if env is None:
+        env = {}
+    llvm_srcdir = 'llvm'
+    llvm_builddir = 'build/android-' + target_arch
+    abiMap={
+            'i386':'x86',
+            'arm':'armeabi',
+            'aarch64':'aarch64'
+           }
+    # Construct cmake
+    cmake_args = ["cmake", "-GNinja"]
+    cmake_args.append(WithProperties("-DCMAKE_BUILD_TYPE=%s" % build_type))
+    cmake_args.append(WithProperties('%(builddir)s/' + llvm_srcdir))
+    cmake_args.append(WithProperties('-DCMAKE_TOOLCHAIN_FILE=' + '%(builddir)s/' + llvm_srcdir + '/tools/lldb/cmake/platforms/Android.cmake'))
+    cmake_args.append(WithProperties('-DANDROID_TOOLCHAIN_DIR=' + '%(toolchain)s'))
+    cmake_args.append('-DANDROID_ABI=' + abiMap[target_arch])
+    cmake_args.append('-DCMAKE_CXX_COMPILER_VERSION=4.9')
+    cmake_args.append('-DLLVM_TARGET_ARCH=' + target_arch)
+    cmake_args.append('-DLLVM_HOST_TRIPLE=' + target_arch + '-unknown-linux-android')
+    cmake_args.append(WithProperties('-DLLVM_TABLEGEN=' + bindir + '/llvm-tblgen'))
+    cmake_args.append(WithProperties('-DCLANG_TABLEGEN=' + bindir + '/clang-tblgen'))
+
+    f.addStep(Configure(name='cmake-android-%s' % target_arch,
+                        command=cmake_args,
+                        env=env,
+                        haltOnFailure=True,
+                        workdir=llvm_builddir))
     return f
 
 def getLLDBxcodebuildFactory(use_cc=None):
     f = buildbot.process.factory.BuildFactory()
     f.addStep(SetProperty(name='get_builddir',
                           command=['pwd'],
                           property='builddir',
                           description='set build dir',