Wrapper script that needs paths to in-project executable

[LunarLambda]

My project has a wrapper script that uses objcopy to strip an executable to a raw binary, and then runs a locally-built 'fixup' program on it, meant for use with custom_target. Looks like this:

meson.build:

objcopy = find_program('objcopy')

gbafix = executable('gbafix', 'gbafix.c', native: true)

makerom = configure_file(
  input: 'makerom.in',
  output: 'makerom',
  configuration: {
    'OBJCOPY': objcopy.full_path(),
    'GBAFIX': gbafix.full_path(),
  })

exe = executable(...)

custom_target(
  'rom',
  input: exe,
  output: exe.name() + '.rom',
  command: [makerom, '@INPUT@', '@OUTPUT@'],
  build_by_default: true)

makerom.in:

#!/usr/bin/env python3

OBJCOPY = '@OBJCOPY@'
GBAFIX = '@GBAFIX@'

import subprocess
from sys import argv

subprocess.call([OBJCOPY, '-O', 'binary'] + argv[1:3])
subprocess.call([GBAFIX] + argv[2:])

However, this can lead to build failures when the custom_target is built before gbafix is, depending on what order ninja compiles things in (multithreading issue).

Is there a way to solve this? I would find combining meson.override_find_program() and find_program() as a workaround quite hacky.

[eli-schwartz]

You could add gbafix as one of the inputs to 'rom', or list it in the depends: kwarg.

[LunarLambda]

What would a theoretical script_target do exactly?

When you pass a custom_target as a command:, the target's output is run.

This is an extra build step that's not needed, because the script is already "built" (either by already existing in the source tree, or as the result of being generated with configure_file or similar)

Instead all we care about is specifying the script file to run, and it's runtime dependencies. run_target is basically that, except that it cannot be used to create outputs, and therefore cannot be passed as a command:.

i.e. I want something like the following to "just work"

gbafix = executable(...)

script = configure_file(...)

# the makerom script already exists, but needs gbafix to run
# bikeshedded syntax
makerom = script_target('makerom', command: [script], depends: [gbafix])

# "downstream" build definitions should just be able to use makerom
# without needing to specify its dependencies

custom_target('rom', command: [makerom, '@INPUT@', '@OUTPUT@'], ...)

[eli-schwartz]

But run_target is literally nothing like that?

[LunarLambda]

In my mind it's similar insofar that the goal is to run the script without introducing another build step for it. Apologies if that was a confusing comparison.

[eli-schwartz]

But run_target() does add another build step for running the script.

The only difference between it and custom_target is that run_target's outputs are:

• a terminating node on the build graph, whose outputs permanently and irrevocably leave -- they are e.g. flashed to another device over a serial console, or copied to another machine via ssh, or they are something like clang-format that modifies source files.
• always considered stale / out of date, so rerunning the run_target will always, always, re-execute the command, and if you were allowed to depend on it, it would cause your makerom custom_target to be rebuilt on every single compilation attempt.

In a Makefile, this would be called a ".PHONY" target: https://www.gnu.org/software/make/manual/html_node/Phony-Targets.html

Internally, the "clean" target is a run_target, as is "test", "install", "uninstall", etc.

[LunarLambda]

Okay well, nevermind that then. Still, as said, I'd like something akin to the above snippet.

Guess I'll make my own subsitution script with custom_target and env:, or make the custom_target make a copy of the file.

[LunarLambda]

Ended up solving it like so:

tools/copy

#!/usr/bin/env python3

import shutil
from sys import argv

shutil.copy(argv[1], argv[2])

tools/meson.build

objcopy = find_program('objcopy')

gbafix = executable('gbafix', 'gbafix.c', native: true)

makerom = configure_file(
  input: 'makerom.in',
  output: 'makerom.in',
  configuration: {
    'OBJCOPY': objcopy.full_path(),
    'GBAFIX': gbafix.full_path(),
  })

makerom = custom_target('makerom',
  input: makerom,
  output: 'makerom',
  command: ['copy', '@INPUT@', '@OUTPUT@'],
  depends: [gbafix],
  build_by_default: true)

It's a hack, but it's the only reasonable way to let downstream projects use makerom without needing to worry about the implementation details.