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 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]; # the load address to use 102 my $cc = $ARGV[1]; # the C compiler in use 103 104 # check for plausible-ish alt load address 105 die "Bogus alt-load address (1)" 106 if (length($ala) < 3 || index($ala, "0x") != 0); 107 108 die "Bogus alt-load address (2)" 109 if ($ala !~ /^0x[0-9a-fA-F]+$/); 110 111 112 # get hold of the outfile name (following "-o") 113 my $outname = ""; 114 115 foreach 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 122 die "Can't find '-o outfilename' in command line" 123 if ($outname eq ""); 124 125 126 # get hold of the string following "-arch" 127 my $archstr = ""; 128 129 foreach 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 136 die "Can't find '-arch archstr' in command line" 137 if ($archstr eq ""); 138 139 140 # build the command line 141 my $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 148 if ("$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 157 my $stack_addr = Math::BigInt->new( $ala ) - $TX_STACK_OFFSET_BEFORE_TEXT; 158 my $stack_addr_str = $stack_addr->as_hex(); 159 my $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 165 foreach my $n (2 .. $#ARGV) { 166 my $str = $ARGV[$n]; 167 if (is_dota_or_doto($str)) { 168 $cmd = "$cmd $str"; 169 } 170 } 171 172 print "link_tool_exe_darwin: $cmd\n"; 173 174 # Execute the command: 175 my $r = system("$cmd"); 176 177 if ($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 188 print "link_tool_exe_darwin: $cmd\n"; 189 190 $r = system("$cmd"); 191 192 if ($r != 0) { 193 exit 1; 194 } 195 196 197 198 199 exit 0; 200
