blob: bf483a9b8275d2f80c46da0a1b029a4cb009db94 [file] [log] [blame]
#! @PERL@
# This script handles linking the tool executables on Linux,
# statically and at an alternative load address.
#
# Linking statically sidesteps all sorts of complications to do with
# having two copies of the dynamic linker (valgrind's and the
# client's) coexisting in the same process. The alternative load
# address is needed because Valgrind itself will load the client at
# whatever address it specifies, which is almost invariably the
# default load address. Hence we can't allow Valgrind itself (viz,
# the tool executable) to be loaded at that address.
#
# Unfortunately there's no standard way to do 'static link at
# alternative address', so these link_tool_exe_*.in scripts handle
# the per-platform hoop-jumping.
#
# What we get passed here is:
# first arg
# the alternative load address
# all the rest of the args
# the gcc invokation to do the final link, that
# the build system would have done, left to itself
#
# We just let the script 'die' if something is wrong, rather than do
# proper error reporting. We don't expect the users to run this
# directly. It is only run as part of the build process, with
# carefully constrained inputs.
#
#
# So: what we actually do is:
#
# Look at the specified gcc invokation. Ignore all parts of it except
# the *.a, *.o and -o outfile parts. Wrap them up in a new command
# which looks (eg) as follows:
#
# (64-bit):
#
# /usr/bin/ld -static -arch x86_64 -macosx_version_min 10.5 \
# -o memcheck-amd64-darwin -u __start -e __start \
# -image_base 0x138000000 -stack_addr 0x13c000000 \
# -stack_size 0x800000 \
# memcheck_amd*.o \
# ../coregrind/libcoregrind-amd64-darwin.a \
# ../VEX/libvex-amd64-darwin.a
#
# (32-bit)
#
# /usr/bin/ld -static -arch i386 -macosx_version_min 10.5 \
# -o memcheck-x86-darwin -u __start -e __start \
# -image_base 0x38000000 -stack_addr 0x3c000000 \
# -stack_size 0x800000 \
# memcheck_x86*.o \
# ../coregrind/libcoregrind-x86-darwin.a \
# ../VEX/libvex-x86-darwin.a
#
# The addresses shown above will actually work, although "for real" we
# of course need to take it from argv[1]. In these examples the stack
# is placed 64M after the executable start. It is probably safer to
# place it 64M before the executable's start point, so the executable
# + data + bss can grow arbitrarily in future without colliding with
# the stack.
#
# There's one more twist: we need to know the word size of the
# executable for which we are linking. We need to know this because
# we must tell the linker that, by handing it either "-arch x86_64" or
# "-arch i386". Fortunately we can figure this out by scanning the
# gcc invokation, which itself must contain either "-arch x86_64" or
# "-arch i386".
use warnings;
use strict;
# we need to be able to do 64-bit arithmetic:
use Math::BigInt;
# User configurable constants: how far before the exe should we
# place the stack?
my $TX_STACK_OFFSET_BEFORE_TEXT = 64 * 1024 * 1024;
# and how big should the stack be?
my $TX_STACK_SIZE = 8 * 1024 * 1024;
# string -> bool
sub is_dota_or_doto($)
{
my ($str) = @_;
if ($str =~ /.\.a$/ || $str =~ /.\.o$/) {
return 1;
} else {
return 0;
}
}
# expect at least: alt-load-address gcc -o foo bar.o
die "Not enough arguments"
if (($#ARGV + 1) < 5);
my $ala = $ARGV[0]; # the load address to use
my $cc = $ARGV[1]; # the C compiler in use
# check for plausible-ish alt load address
die "Bogus alt-load address (1)"
if (length($ala) < 3 || index($ala, "0x") != 0);
die "Bogus alt-load address (2)"
if ($ala !~ /^0x[0-9a-fA-F]+$/);
# get hold of the outfile name (following "-o")
my $outname = "";
foreach my $n (2 .. $#ARGV - 1) {
my $str = $ARGV[$n];
if ($str eq "-o" && $outname eq "") {
$outname = $ARGV[$n + 1];
}
}
die "Can't find '-o outfilename' in command line"
if ($outname eq "");
# get hold of the string following "-arch"
my $archstr = "";
foreach my $n (2 .. $#ARGV - 1) {
my $str = $ARGV[$n];
if ($str eq "-arch" && $archstr eq "") {
$archstr = $ARGV[$n + 1];
}
}
die "Can't find '-arch archstr' in command line"
if ($archstr eq "");
# build the command line
my $cmd = "/usr/bin/ld";
$cmd = "$cmd -static";
# If we're building with clang (viz, the C compiler as specified
# by the 2nd arg ends in "clang"), we also need -new_linker. See
# https://bugs.kde.org/show_bug.cgi?id=295427
if ("$cc" =~ /clang$/) {
$cmd = "$cmd -new_linker";
}
$cmd = "$cmd -arch $archstr";
$cmd = "$cmd -macosx_version_min 10.5";
$cmd = "$cmd -o $outname";
$cmd = "$cmd -u __start -e __start";
my $stack_addr = Math::BigInt->new( $ala ) - $TX_STACK_OFFSET_BEFORE_TEXT;
my $stack_addr_str = $stack_addr->as_hex();
my $stack_size_str = Math::BigInt::as_hex($TX_STACK_SIZE);
$cmd = "$cmd -image_base $ala";
$cmd = "$cmd -stack_addr $stack_addr_str";
$cmd = "$cmd -stack_size $stack_size_str";
foreach my $n (2 .. $#ARGV) {
my $str = $ARGV[$n];
if (is_dota_or_doto($str)) {
$cmd = "$cmd $str";
}
}
print "link_tool_exe_darwin: $cmd\n";
# Execute the command:
my $r = system("$cmd");
if ($r != 0) {
exit 1;
}
# and now kludge the tool exe
# see bug 267997
$cmd = "../coregrind/fixup_macho_loadcmds";
$cmd = "$cmd $stack_addr_str $stack_size_str $outname";
print "link_tool_exe_darwin: $cmd\n";
$r = system("$cmd");
if ($r != 0) {
exit 1;
}
exit 0;