l4/pkg/valgrind/src/valgrind-3.6.0-svn/coregrind/link_tool_exe_darwin.in

   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 invokation 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 invokation.  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.5 \
  40 #      -o memcheck-amd64-darwin -u __start -e __start \
  41 #      -image_base 0x138000000 -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.5 \
  50 #      -o memcheck-x86-darwin -u __start -e __start \
  51 #      -image_base 0x38000000 -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 invokation, which itself must contain either "-arch x86_64" or
  69 # "-arch i386".
  70
  71 use warnings;
  72 use strict;
  73 # we need to be able to do 64-bit arithmetic:
  74 use Math::BigInt;
  75
  76
  77 # User configurable constants: how far before the exe should we
  78 # place the stack?
  79 my $TX_STACK_OFFSET_BEFORE_TEXT = 64 * 1024 * 1024;
  80
  81 # and how big should the stack be?
  82 my $TX_STACK_SIZE = 8 * 1024 * 1024;
  83
  84
  85 # string -> bool
  86 sub 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
  98 die "Not enough arguments"
  99     if (($#ARGV + 1) < 5);
 100
 101 my $ala = $ARGV[0];
 102
 103 # check for plausible-ish alt load address
 104 die "Bogus alt-load address (1)"
 105     if (length($ala) < 3 || index($ala, "0x") != 0);
 106
 107 die "Bogus alt-load address (2)"
 108     if ($ala !~ /^0x[0-9a-fA-F]+$/);
 109
 110
 111 # get hold of the outfile name (following "-o")
 112 my $outname = "";
 113
 114 foreach my $n (2 .. $#ARGV - 1) {
 115     my $str = $ARGV[$n];
 116     if ($str eq "-o" && $outname eq "") {
 117         $outname = $ARGV[$n + 1];
 118     }
 119 }
 120
 121 die "Can't find '-o outfilename' in command line"
 122     if ($outname eq "");
 123
 124
 125 # get hold of the string following "-arch"
 126 my $archstr = "";
 127
 128 foreach my $n (2 .. $#ARGV - 1) {
 129     my $str = $ARGV[$n];
 130     if ($str eq "-arch" && $archstr eq "") {
 131         $archstr = $ARGV[$n + 1];
 132     }
 133 }
 134
 135 die "Can't find '-arch archstr' in command line"
 136     if ($archstr eq "");
 137
 138
 139 # build the command line
 140 my $cmd = "/usr/bin/ld";
 141
 142 $cmd = "$cmd -static";
 143 $cmd = "$cmd -arch $archstr";
 144 $cmd = "$cmd -macosx_version_min 10.5";
 145 $cmd = "$cmd -o $outname";
 146 $cmd = "$cmd -u __start -e __start";
 147
 148 my $stack_addr = Math::BigInt->new( $ala ) - $TX_STACK_OFFSET_BEFORE_TEXT;
 149 my $stack_addr_str = $stack_addr->as_hex();
 150 my $stack_size_str = Math::BigInt::as_hex($TX_STACK_SIZE);
 151
 152 $cmd = "$cmd -image_base $ala";
 153 $cmd = "$cmd -stack_addr $stack_addr_str";
 154 $cmd = "$cmd -stack_size $stack_size_str";
 155
 156 foreach my $n (2 .. $#ARGV) {
 157     my $str = $ARGV[$n];
 158     if (is_dota_or_doto($str)) {
 159         $cmd = "$cmd $str";
 160     }
 161 }
 162
 163 print "link_tool_exe_darwin: $cmd\n";
 164
 165 # Execute the command:
 166 my $r = system("$cmd");
 167
 168 if ($r != 0) {
 169    exit 1;
 170 }
 171
 172
 173 # and now kludge the tool exe
 174 # see bug 267997
 175
 176 $cmd = "../coregrind/fixup_macho_loadcmds";
 177 $cmd = "$cmd $stack_addr_str $stack_size_str $outname";
 178
 179 print "link_tool_exe_darwin: $cmd\n";
 180
 181 $r = system("$cmd");
 182
 183 if ($r != 0) {
 184    exit 1;
 185 }
 186
 187
 188
 189
 190 exit 0;