Home | History | Annotate | Download | only in coregrind 
      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 
    166 # Execute the command:
    167 my $r = system("$cmd");
    168 
    169 if ($r == 0) {
    170     exit 0;
    171 } else {
    172     exit 1;
    173 }
    174