run_yasm.py

#!/usr/bin/python
# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""A wrapper to run yasm.

Its main job is to provide a Python wrapper for GN integration, and to write
the makefile-style output yasm generates in stdout to a .d file for dependency
management of .inc files.

Run with:
  python run_yasm.py [options] <yasm_binary_path> <yasm args>

Options:
  --ignore-preprocess-only-errors: Ignore errors that occur during passes that
                                   only preprocess the input and do not assemble
                                   it.

Note that <all other yasm args> must include an explicit output file (-o). This
script will append a ".d" to this and write the dependencies there. This script
will add "-M" to cause yasm to write the deps to stdout, so you don't need to
specify that.

If your preprocessor code references symbols defined in asm a preprocess only
pass may yield errors. If the stdout for `-M` is the correct makefile deps,
provide `--ignore-preprocess-only-errors` by adding
`yasm_ignore_preprocess_only_errors = true` to your `yasm_assemble` target
options.
"""

import argparse
import sys
import subprocess

# Extract the output file name from the yasm command line so we can generate a
# .d file with the same base name.
parser = argparse.ArgumentParser()
parser.add_argument("-o", dest="objfile")
parser.add_argument("--ignore-preprocess-only-errors", action='store_true', dest="ignore_preprocess_only_errors")
options, _ = parser.parse_known_args()

invocation_start = 1
if options.ignore_preprocess_only_errors:
  invocation_start += 1

objfile = options.objfile
depfile = objfile + '.d'

# Assemble.
result_code = subprocess.call(sys.argv[invocation_start:])
if result_code != 0:
  sys.exit(result_code)

# Now generate the .d file listing the dependencies. The -M option makes yasm
# write the Makefile-style dependencies to stdout, but it seems that inhibits
# generating any compiled output so we need to do this in a separate pass.
# However, outputting deps seems faster than actually assembling, and yasm is
# so fast anyway this is not a big deal.
#
# This guarantees proper dependency management for assembly files. Otherwise,
# we would have to require people to manually specify the .inc files they
# depend on in the build file, which will surely be wrong or out-of-date in
# some cases.
proc = subprocess.Popen(sys.argv[invocation_start:] + ['-M'],
                        stdout=subprocess.PIPE,
                        stderr=subprocess.PIPE)
deps, err = proc.communicate()
if proc.returncode != 0 and not options.ignore_preprocess_only_errors:
  print(err)
  exit(proc.returncode)
with open(depfile, "wb") as f:
  f.write(deps)