1#! @PERL@
2
3# This script handles linking the tool executables on Linux,
4# statically and at an alternative load address.
5#
6# Linking statically sidesteps all sorts of complications to do with
7# having two copies of the dynamic linker (valgrind's and the
8# client's) coexisting in the same process.  The alternative load
9# address is needed because Valgrind itself will load the client at
10# whatever address it specifies, which is almost invariably the
11# default load address.  Hence we can't allow Valgrind itself (viz,
12# the tool executable) to be loaded at that address.
13#
14# Unfortunately there's no standard way to do 'static link at
15# alternative address', so these link_tool_exe_*.in scripts handle
16# the per-platform hoop-jumping.
17#
18# What we get passed here is:
19#   first arg
20#      the alternative load address
21#   all the rest of the args
22#      the gcc invocation to do the final link, that
23#      the build system would have done, left to itself
24#
25# We just let the script 'die' if something is wrong, rather than do
26# proper error reporting.  We don't expect the users to run this
27# directly.  It is only run as part of the build process, with
28# carefully constrained inputs.
29#
30#
31# So: what we actually do is:
32#
33# Look at the specified gcc invocation.  Ignore all parts of it except
34# the *.a, *.o and -o outfile parts.  Wrap them up in a new command
35# which looks (eg) as follows:
36#
37#   (64-bit):
38#
39#   /usr/bin/ld -static -arch x86_64 -macosx_version_min 10.6 \
40#      -o memcheck-amd64-darwin -u __start -e __start \
41#      -image_base 0x158000000 -stack_addr 0x13c000000 \
42#      -stack_size 0x800000 \
43#      memcheck_amd*.o \
44#      ../coregrind/libcoregrind-amd64-darwin.a \
45#      ../VEX/libvex-amd64-darwin.a
46#
47#   (32-bit)
48#
49#   /usr/bin/ld -static -arch i386 -macosx_version_min 10.6 \
50#      -o memcheck-x86-darwin -u __start -e __start \
51#      -image_base 0x58000000 -stack_addr 0x3c000000 \
52#      -stack_size 0x800000 \
53#      memcheck_x86*.o \
54#      ../coregrind/libcoregrind-x86-darwin.a \
55#      ../VEX/libvex-x86-darwin.a
56#
57# The addresses shown above will actually work, although "for real" we
58# of course need to take it from argv[1].  In these examples the stack
59# is placed 64M after the executable start.  It is probably safer to
60# place it 64M before the executable's start point, so the executable
61# + data + bss can grow arbitrarily in future without colliding with
62# the stack.
63#
64# There's one more twist: we need to know the word size of the
65# executable for which we are linking.  We need to know this because
66# we must tell the linker that, by handing it either "-arch x86_64" or
67# "-arch i386".  Fortunately we can figure this out by scanning the
68# gcc invocation, which itself must contain either "-arch x86_64" or
69# "-arch i386".
70
71use warnings;
72use strict;
73# we need to be able to do 64-bit arithmetic:
74use Math::BigInt;
75
76
77# User configurable constants: how far before the exe should we
78# place the stack?
79my $TX_STACK_OFFSET_BEFORE_TEXT = 64 * 1024 * 1024;
80
81# and how big should the stack be?
82my $TX_STACK_SIZE = 8 * 1024 * 1024;
83
84
85# string -> bool
86sub is_dota_or_doto($)
87{
88   my ($str) = @_;
89   if ($str =~ /.\.a$/ || $str =~ /.\.o$/) {
90      return 1;
91   } else {
92      return 0;
93   }
94}
95
96
97# expect at least: alt-load-address gcc -o foo bar.o
98die "Not enough arguments"
99    if (($#ARGV + 1) < 5);
100
101my $ala = $ARGV[0];  # the load address to use
102my $cc  = $ARGV[1];  # the C compiler in use
103
104# check for plausible-ish alt load address
105die "Bogus alt-load address (1)"
106    if (length($ala) < 3 || index($ala, "0x") != 0);
107
108die "Bogus alt-load address (2)"
109    if ($ala !~ /^0x[0-9a-fA-F]+$/);
110
111
112# get hold of the outfile name (following "-o")
113my $outname = "";
114
115foreach my $n (2 .. $#ARGV - 1) {
116    my $str = $ARGV[$n];
117    if ($str eq "-o" && $outname eq "") {
118        $outname = $ARGV[$n + 1];
119    }
120}
121
122die "Can't find '-o outfilename' in command line"
123    if ($outname eq "");
124
125
126# get hold of the string following "-arch"
127my $archstr = "";
128
129foreach my $n (2 .. $#ARGV - 1) {
130    my $str = $ARGV[$n];
131    if ($str eq "-arch" && $archstr eq "") {
132        $archstr = $ARGV[$n + 1];
133    }
134}
135
136die "Can't find '-arch archstr' in command line"
137    if ($archstr eq "");
138
139
140# build the command line
141my $cmd = "/usr/bin/ld";
142
143$cmd = "$cmd -static";
144
145# If we're building with clang (viz, the C compiler as specified
146# by the 2nd arg ends in "clang"), we also need -new_linker.  See
147# https://bugs.kde.org/show_bug.cgi?id=295427
148if ("$cc" =~ /clang$/) {
149    $cmd = "$cmd -new_linker";
150}
151
152$cmd = "$cmd -arch $archstr";
153$cmd = "$cmd -macosx_version_min 10.6";
154$cmd = "$cmd -o $outname";
155$cmd = "$cmd -u __start -e __start";
156
157my $stack_addr = Math::BigInt->new( $ala ) - $TX_STACK_OFFSET_BEFORE_TEXT;
158my $stack_addr_str = $stack_addr->as_hex();
159my $stack_size_str = Math::BigInt::as_hex($TX_STACK_SIZE);
160
161$cmd = "$cmd -image_base $ala";
162$cmd = "$cmd -stack_addr $stack_addr_str";
163$cmd = "$cmd -stack_size $stack_size_str";
164
165foreach my $n (2 .. $#ARGV) {
166    my $str = $ARGV[$n];
167    if (is_dota_or_doto($str)) {
168        $cmd = "$cmd $str";
169    }
170}
171
172print "link_tool_exe_darwin: $cmd\n";
173
174# Execute the command:
175my $r = system("$cmd");
176
177if ($r != 0) {
178   exit 1;
179}
180
181
182# and now kludge the tool exe
183# see bug 267997
184
185$cmd = "../coregrind/fixup_macho_loadcmds";
186$cmd = "$cmd $stack_addr_str $stack_size_str $outname";
187
188print "link_tool_exe_darwin: $cmd\n";
189
190$r = system("$cmd");
191
192if ($r != 0) {
193   exit 1;
194}
195
196
197
198
199exit 0;
200