Allows building debian packages for ARM.

tools/create_debian_packages.py

 #!/usr/bin/env python
 #
 # Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 #
 
 # Script to build a Debian packages from a Dart tarball. The script
 # will build a source package and a 32-bit (i386) and 64-bit (amd64)
 # binary packages.
@@ skipping 15 matching lines @@
 def BuildOptions():
   result = optparse.OptionParser()
   result.add_option("--tar_filename",
                     default=None,
                     help="The tar file to build from.")
   result.add_option("--out_dir",
                     default=None,
                     help="Where to put the packages.")
   result.add_option("-a", "--arch",
       help='Target architectures (comma-separated).',
-      metavar='[all,ia32,x64]',
+      metavar='[all,ia32,x64,arm]',
       default='x64')
+  result.add_option("-t", "--toolchain",
+      help='Cross-compilation toolchain prefix',
+      default=None)
 
   return result
 
-def RunBuildPackage(opt, cwd):
+def RunBuildPackage(opt, cwd, toolchain=None):
+  env = os.environ.copy()
+  if toolchain != None:
+    env["TOOLCHAIN"] = '--toolchain=' + toolchain
   cmd = ['dpkg-buildpackage', '-j%d' % HOST_CPUS]
   cmd.extend(opt)
   process = subprocess.Popen(cmd,
                              stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                             cwd=cwd)
+                             cwd=cwd, env=env)
   (stdout, stderr) = process.communicate()
   if process.returncode != 0:
     raise Exception('Command \'%s\' failed: %s\nSTDOUT: %s' %
                     (' '.join(cmd), stderr, stdout))
 
-def BuildDebianPackage(tarball, out_dir, arch):
+def BuildDebianPackage(tarball, out_dir, arch, toolchain):
   version = utils.GetVersion()
   tarroot = 'dart-%s' % version
   origtarname = 'dart_%s.orig.tar.gz' % version
 
   if not exists(tarball):
     print 'Source tarball not found'
     return -1
 
   with utils.TempDir() as temp_dir:
     origtarball = join(temp_dir, origtarname)
     copyfile(tarball, origtarball)
 
     with tarfile.open(origtarball) as tar:
       tar.extractall(path=temp_dir)
 
     # Build source package.
     print "Building source package"
     RunBuildPackage(['-S', '-us', '-uc'], join(temp_dir, tarroot));
 
     # Build 32-bit binary package.
     if ('ia32' in arch):
       print "Building i386 package"
-      RunBuildPackage(['-B', '-ai386', '-us', '-uc'], join(temp_dir, tarroot));
+      RunBuildPackage(['-B', '-ai386', '-us', '-uc'], join(temp_dir, tarroot))
 
     # Build 64-bit binary package.
     if ('x64' in arch):
       print "Building amd64 package"
-      RunBuildPackage(['-B', '-aamd64', '-us', '-uc'], join(temp_dir, tarroot));
+      RunBuildPackage(['-B', '-aamd64', '-us', '-uc'], join(temp_dir, tarroot))
+
+    # Build armv binary package.

[Søren Gjesse, 2014/08/05 15:20:29]

armv -> arm?

[zra, 2014/08/14 20:42:52]

Done.

+    if ('arm' in arch):
+      print "Building arm package"
+      RunBuildPackage(
+          ['-B', '-aarm', '-us', '-uc'], join(temp_dir, tarroot), toolchain)

[Søren Gjesse, 2014/08/05 15:20:29]

Is arm the right architectue here? Shouldn't it be armhf? AFAIK we do use
hard-float. It is a bit difficult to figure this out, but running
'dpkg-architecture -L' shows all known architectures (see
http://www.debian.org/doc/debian-policy/ch-customized-programs.html#s-arch-spec)

[zra, 2014/08/14 20:42:52]

We currently support both hard and soft fp, which would be armhf and armel in
the debian naming scheme, respectively. The appropriate one to select depends on
the host or cross toolchain being used. I've updated to allow specifying either
armhf or armel, but we probably can't detect which is the right one to use
without dumping and parsing compiler predefined macros. I've setup the 'all'
target here to select armhf, which when run on linux will do a hardfp ARMv7
build.

 
     # Copy the Debian package files to the build directory.
     debbase = 'dart_%s' % version
     source_package = [
       '%s-1.dsc' % debbase,
       '%s.orig.tar.gz' % debbase,
       '%s-1.debian.tar.gz' % debbase
     ]
     i386_package = [
       '%s-1_i386.deb' % debbase
     ]
     amd64_package = [
       '%s-1_amd64.deb' % debbase
     ]
+    arm_package = [
+      '%s-1_arm.deb' % debbase

[Søren Gjesse, 2014/08/05 15:20:29]

armhf here as well?

[zra, 2014/08/14 20:42:52]

Acknowledged.

+    ]
 
     for name in source_package:
       copyfile(join(temp_dir, name), join(out_dir, name))
     if ('ia32' in arch):
       for name in i386_package:
         copyfile(join(temp_dir, name), join(out_dir, name))
     if ('x64' in arch):
       for name in amd64_package:
         copyfile(join(temp_dir, name), join(out_dir, name))
+    if ('arm' in arch):
+      for name in arm_package:
+        copyfile(join(temp_dir, name), join(out_dir, name))
+
 
 def Main():
   if HOST_OS != 'linux':
     print 'Debian build only supported on linux'
     return -1
 
   options, args = BuildOptions().parse_args()
   out_dir = options.out_dir
   tar_filename = options.tar_filename
   if options.arch == 'all':
-    options.arch = 'ia32,x64'
+    options.arch = 'ia32,x64,arm'
   arch = options.arch.split(',')
 
   if not options.out_dir:
     out_dir = join(DART_DIR, utils.GetBuildDir(HOST_OS, HOST_OS))
 
   if not tar_filename:
     tar_filename = join(DART_DIR,
                         utils.GetBuildDir(HOST_OS, HOST_OS),
                         'dart-%s.tar.gz' % utils.GetVersion())
 
-  BuildDebianPackage(tar_filename, out_dir, arch)
+  BuildDebianPackage(tar_filename, out_dir, arch, options.toolchain)
 
 if __name__ == '__main__':
   sys.exit(Main())