#!/usr/bin/env ruby
# Copyright (C) 2020 Igalia S. L.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
# THE POSSIBILITY OF SUCH DAMAGE.
# Wrapper for a .cpp -> .o compilation command. It
# 1. converts the command to generate a `.s' file
# 2. runs the ASM postprocessor on it to generate the final `.s` file
# 3. assembles the `.s` file to a `.o` file
$asm_suffix_pre = ".pre.s"
$asm_suffix = ".s"
$postprocessor = "#{File.dirname($0)}/resolve-asm-file-conflicts.rb"
$intermediate_paths = []
# We need to work with indices a lot and unfortunately 'getoptlong' in
# the standard library doesn't expose optind, so we're going with
# array searches for simplicity.
def index_nofail(ary, f, errmsg)
idx = ary.index { |el|
f.call(el)
}
if idx.nil?
$stderr.puts(errmsg)
exit(3)
end
idx
end
# Find and return the source file for this compilation command,
# removing it from the args. Note that the path (A) as it appears here
# (coming from a cmake rule) is likely to be different to the
# anonymous argument (B) to the compilation command. However, A will
# be a suffix of B.
#
# Exit with an error if the argument is not there. This has already
# been checked by `cxx-wrapper`, otherwise we wouldn't be running.
def extract_input!(args)
prefix = '-DPOSTPROCESS_ASM='
idx = index_nofail(args, Proc.new { |arg|
arg.start_with?(prefix)
}, "No `-DPOSTPROCESS_ASM` argument`")
path = args[idx][prefix.size..-1]
if path.size == 0
$stderr.puts("Empty path in -DPOSTPROCESS_ASM=")
exit(3)
end
# We only need this to be defined for the preprocessor (not any
# wrapper) from now on.
args[idx] = "-DPOSTPROCESS_ASM"
return path
end
# Get the index of the first argument ending in this suffix.
#
# Exit with an error if the argument isn't there. We're only ever
# called with arguments we know are being passed in by the build
# system.
def get_arg_idx_suffix(args, wanted)
index_nofail(args, Proc.new { |arg|
arg.end_with?(wanted)
}, "No argument ends with #{wanted}")
end
# Get index of a given argument. Die if it's not there.
def get_arg_idx(args, wanted)
index_nofail(args, Proc.new { |arg|
arg == wanted
}, "No `#{wanted}` argument")
end
# Get the index of `-o` and verify that an argument follows.
# Both are guaranteed to exist (from our build system).
def get_o_idx(args)
i = get_arg_idx(args, '-o')
if (i + 1) >= args.size
$stderr.puts("No argument to `-o`")
exit(3)
end
i
end
# Run command and die if it fails, propagating the exit code.
def run_cmd(cmd)
pid = Process.spawn(*cmd)
Process.waitpid(pid)
ret = $?
if not ret.success?
$stderr.puts("Error running cmd: #{ret}")
exit(ret.exitstatus)
end
end
# Convert
# cxx -o blah.o -c blah.cpp
# to
# cxx -o blah.s -S blah.cpp
def build_cxx_cmd(args)
c_idx = get_arg_idx(args, '-c')
o_idx = get_o_idx(args)
cxx_args = args.clone
cxx_args[c_idx] = '-S'
o_path = cxx_args[o_idx + 1]
cxx_args[o_idx + 1] = o_path.sub(/[.]o$/, $asm_suffix)
$intermediate_paths << cxx_args[o_idx + 1]
if cxx_args[o_idx + 1] == o_path
$stderr.puts("Output file name not an object file: `#{o_path}`")
exit(3)
end
cxx_args
end
# Do
# mv blah.S blah.pre.S
# The reason we do a rename instead of directly generating the .pre.s
# file when compiling is so that the corresponding .dwo file will have
# the correct name embedded.
def rename_s_file(args)
o_path = args[get_o_idx(args) + 1]
File.rename(o_path.sub(/[.]o$/, $asm_suffix),
o_path.sub(/[.]o$/, $asm_suffix_pre))
end
# Build
# postprocessor blah.pre.S blah.S
def build_postprocessor_cmd(args)
o_path = args[get_o_idx(args) + 1]
pp_args = [
$postprocessor,
o_path.sub(/[.]o$/, $asm_suffix_pre), # input
o_path.sub(/[.]o$/, $asm_suffix) # output
]
$intermediate_paths << pp_args[-2]
$intermediate_paths << pp_args[-1]
pp_args
end
# Build
# cxx -o blah.o -c blah.S
def build_as_cmd(args, i_path)
i_idx = get_arg_idx_suffix(args, i_path)
o_path = args[get_o_idx(args) + 1]
as_args = args.clone
i_path = as_args[i_idx]
as_args[i_idx] = o_path.sub(/[.]o$/, $asm_suffix)
as_args
end
args = ARGV.to_a
i_path = extract_input!(args)
begin
run_cmd(build_cxx_cmd(args))
rename_s_file(args)
run_cmd(build_postprocessor_cmd(args))
run_cmd(build_as_cmd(args, i_path))
ensure
$intermediate_paths.each { |p|
if File.exist?(p)
File.delete(p)
end
}
end