gdb/testsuite/lib/prelink-support.exp

   1 # Copyright (C) 2010-2014 Free Software Foundation, Inc.
   2
   3 # This program is free software; you can redistribute it and/or modify
   4 # it under the terms of the GNU General Public License as published by
   5 # the Free Software Foundation; either version 3 of the License, or
   6 # (at your option) any later version.
   7 #
   8 # This program is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 # GNU General Public License for more details.
  12 #
  13 # You should have received a copy of the GNU General Public License
  14 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15
  16 # Return nul-terminated string read from section SECTION of EXEC.  Return ""
  17 # if no such section or nul-terminated string was found.  Function is useful
  18 # for sections ".interp" or ".gnu_debuglink".
  19
  20 proc section_get {exec section} {
  21     global subdir
  22     set tmp [standard_output_file section_get.tmp]
  23     set objcopy_program [gdb_find_objcopy]
  24
  25     set command "exec $objcopy_program -O binary --set-section-flags $section=A --change-section-address $section=0 -j $section $exec $tmp"
  26     verbose -log "command is $command"
  27     set result [catch $command output]
  28     verbose -log "result is $result"
  29     verbose -log "output is $output"
  30     if {$result == 1} {
  31         return ""
  32     }
  33     set fi [open $tmp]
  34     fconfigure $fi -translation binary
  35     set data [read $fi]
  36     close $fi
  37     file delete $tmp
  38     # .interp has size $len + 1 but .gnu_debuglink contains garbage after \000.
  39     set len [string first \000 $data]
  40     if {$len < 0} {
  41         verbose -log "section $section not found"
  42         return ""
  43     }
  44     set retval [string range $data 0 [expr $len - 1]]
  45     verbose -log "section $section is <$retval>"
  46     return $retval
  47 }
  48
  49 # Resolve symlinks.
  50
  51 proc symlink_resolve {file} {
  52     set loop 0
  53     while {[file type $file] == "link"} {
  54         set target [file readlink $file]
  55         if {[file pathtype $target] == "relative"} {
  56             set src2 [file dirname $file]/$target
  57         } else {
  58             set src2 $target
  59         }
  60         verbose -log "Resolved symlink $file targetting $target as $src2"
  61         set file $src2
  62
  63         set loop [expr $loop + 1]
  64         if {$loop > 30} {
  65             fail "Looping symlink resolution for $file"
  66             return ""
  67         }
  68     }
  69     return $file
  70 }
  71
  72 # Copy SRC to DEST, resolving any symlinks in SRC.  Return nonzero iff
  73 # the copy was succesful.
  74 #
  75 # This function is guaranteed to never raise any exception, even when the copy
  76 # fails.
  77
  78 proc file_copy {src dest} {
  79     set src [symlink_resolve $src]
  80     # Test name would contain unstable directory name for symlink-unresolved
  81     # $src.
  82     set test "copy [file tail $src] to [file tail $dest]"
  83     set command "file copy -force -- $src $dest"
  84     verbose -log "command is $command"
  85     if [catch $command] {
  86         fail $test
  87         return 0
  88     } else {
  89         pass $test
  90         return 1
  91     }
  92 }
  93
  94 # Wrap function build_executable so that the resulting executable is fully
  95 # self-sufficient (without dependencies on system libraries).  Parameter
  96 # INTERP may be used to specify a loader (ld.so) to be used that is
  97 # different from the default system one.  INTERP can be set to "no" if no ld.so
  98 # copy should be made.  Libraries on which the executable depends are copied
  99 # into directory DIR.  Default DIR value to
 100 # `${objdir}/${subdir}/${EXECUTABLE}.d'.
 101 #
 102 # In case of success, return a string containing the arguments to be used
 103 # in order to perform a prelink of the executable obtained.  Return the
 104 # empty string in case of failure.
 105 #
 106 # This can be useful when trying to prelink an executable which might
 107 # depend on system libraries.  To properly prelink an executable, all
 108 # of its dynamically linked libraries must be prelinked as well.  If
 109 # the executable depends on some system libraries, we may not have
 110 # sufficient write priviledges on these files to perform the prelink.
 111 # This is why we make a copy of these shared libraries, and link the
 112 # executable against these copies instead.
 113 #
 114 # Function recognizes only libraries listed by `ldd' after
 115 # its ` => ' separator.  That means $INTERP and any libraries not being linked
 116 # with -Wl,-soname,NAME.so are not copied.
 117
 118 proc build_executable_own_libs {testname executable sources options {interp ""} {dir ""}} {
 119     global subdir
 120
 121     if {[build_executable $testname $executable $sources $options] == -1} {
 122         return ""
 123     }
 124     set binfile [standard_output_file ${executable}]
 125
 126     set ldd [gdb_find_ldd]
 127     set command "$ldd $binfile"
 128     set test "ldd $executable"
 129     set result [catch "exec $command" output]
 130     verbose -log "result of $command is $result"
 131     verbose -log "output of $command is $output"
 132     if {$result != 0 || $output == ""} {
 133         fail $test
 134     } else {
 135         pass $test
 136     }
 137
 138     # gdb testsuite will put there also needless -lm.
 139     set test "$test output contains libs"
 140     set libs [regexp -all -inline -line {^.* => (/[^ ]+).*$} $output]
 141     if {[llength $libs] == 0} {
 142         fail $test
 143     } else {
 144         pass $test
 145     }
 146
 147     if {$dir == ""} {
 148         set dir ${binfile}.d
 149     }
 150     file delete -force -- $dir
 151     file mkdir $dir
 152
 153     if {$interp == ""} {
 154         set interp_system [section_get $binfile .interp]
 155         if {$interp_system == ""} {
 156             fail "$test could not find .interp"
 157         } else {
 158             set interp ${dir}/[file tail $interp_system]
 159             file_copy $interp_system $interp
 160         }
 161     }
 162     if {$interp == "no"} {
 163         set interp ""
 164     }
 165
 166     set dests {}
 167     foreach {trash abspath} $libs {
 168         set dest "$dir/[file tail $abspath]"
 169         file_copy $abspath $dest
 170         lappend dests $dest
 171     }
 172
 173     # Do not lappend it so that "-rpath $dir" overrides any possible "-rpath"s
 174     # specified by the caller to be able to link it for ldd" above.
 175     set options [linsert $options 0 "ldflags=-Wl,-rpath,$dir"]
 176     if {$interp != ""} {
 177         set options [linsert $options 0 "ldflags=-Wl,--dynamic-linker,$interp"]
 178     }
 179
 180     if {[build_executable $testname $executable $sources $options] == -1} {
 181         return ""
 182     }
 183
 184     set prelink_args "--ld-library-path=$dir $binfile [concat $dests]"
 185     if {$interp != ""} {
 186         set prelink_args "--dynamic-linker=$interp $prelink_args $interp"
 187     }
 188     return $prelink_args
 189 }
 190
 191 # Unprelink ARG.  Reported test name can be specified by NAME.  Return non-zero
 192 # on success, zero on failure.
 193
 194 proc prelink_no {arg {name {}}} {
 195     if {$name == ""} {
 196         set name [file tail $arg]
 197     }
 198     set test "unprelink $name"
 199     set command "exec /usr/sbin/prelink -uN $arg"
 200     verbose -log "command is $command"
 201     set result [catch $command output]
 202     verbose -log "result is $result"
 203     verbose -log "output is $output"
 204     if {$result == 1 && [regexp {^(couldn't execute "/usr/sbin/prelink[^\r\n]*": no such file or directory\n?)*$} $output]} {
 205         # Without prelink, at least verify that all the binaries do not
 206         # contain the  ".gnu.prelink_undo" section (which would mean that they
 207         # have already been prelinked).
 208         set test "$test (missing /usr/sbin/prelink)"
 209         foreach bin [split $arg] {
 210             if [string match "-*" $bin] {
 211                 # Skip prelink options.
 212                 continue
 213             }
 214             set readelf_program [gdb_find_readelf]
 215             set command "exec $readelf_program -WS $bin"
 216             verbose -log "command is $command"
 217             set result [catch $command output]
 218             verbose -log "result is $result"
 219             verbose -log "output is $output"
 220             if {$result != 0 || [string match {* .gnu.prelink_undo *} $output]} {
 221                 fail "$test ($bin is already prelinked)"
 222                 return 0
 223             }
 224         }
 225         pass $test
 226         return 1
 227     }
 228     if {$result == 0 && $output == ""} {
 229         verbose -log "$name has been now unprelinked"
 230         set command "exec /usr/sbin/prelink -uN $arg"
 231         verbose -log "command is $command"
 232         set result [catch $command output]
 233         verbose -log "result is $result"
 234         verbose -log "output is $output"
 235     }
 236     # Last line does miss the trailing \n.  There can be multiple such messages
 237     # as ARG may list multiple files.
 238     if {$result == 1 && [regexp {^([^\r\n]*prelink[^\r\n]*: [^ ]* does not have .gnu.prelink_undo section\n?)*$} $output]} {
 239         pass $test
 240         return 1
 241     } else {
 242         fail $test
 243         return 0
 244     }
 245 }
 246
 247 # Prelink ARG.  Reported test name can be specified by NAME.  Return non-zero
 248 # on success, zero on failure.
 249
 250 proc prelink_yes {arg {name ""}} {
 251     if {$name == ""} {
 252         set name [file tail $arg]
 253     }
 254
 255     # Try to unprelink it first so that, if it has been already prelinked
 256     # before, we get a different address now, making the new result unaffected
 257     # by any previous prelinking.
 258     if ![prelink_no $arg "$name pre-unprelink"] {
 259         return 0
 260     }
 261
 262     set test "prelink $name"
 263
 264     # `--no-exec-shield' is for i386, where prelink in the exec-shield mode is
 265     # forced to push all the libraries tight together, in order to fit into
 266     # the first two memory areas (either the ASCII Shield area or at least
 267     # below the executable).  If the prelink was performed in exec-shield
 268     # mode, prelink could have no choice on how to randomize the single new
 269     # unprelinked library address without wasting space in the first one/two
 270     # memory areas.  In such case prelink could place $ARG repeatedly at the
 271     # same place and we could have false prelink results on
 272     # gdb.base/prelink.exp and others.  To prevent this from happening, we use
 273     # the --no-exec-shield switch.  This may have some consequences in terms
 274     # of security, but we do not care in our case.
 275
 276     set command "exec /usr/sbin/prelink -qNR --no-exec-shield $arg"
 277
 278     verbose -log "command is $command"
 279     set result [catch $command output]
 280     verbose -log "result is $result"
 281     verbose -log "output is $output"
 282     if {$result == 1 && [regexp {^(couldn't execute "/usr/sbin/prelink[^\r\n]*": no such file or directory\n?)*$} $output]} {
 283         set test "$test (missing /usr/sbin/prelink)"
 284
 285         # We could not find prelink.  We could check whether $args is already
 286         # prelinked but we don't, because:
 287         #   - It is unlikely that someone uninstalls prelink after having
 288         #     prelinked the system ld.so;
 289         #   - We still cannot change its prelinked address.
 290         # Therefore, we just skip the test.
 291
 292         xfail $test
 293         return 0
 294     }
 295     if {$result == 1 && [regexp {DWARF [^\r\n]* unhandled} $output]} {
 296         # Prelink didn't understand the version of dwarf present.
 297         unsupported "$test (dwarf version unhandled)"
 298         return 0
 299     }
 300     if {$result == 0 && $output == ""} {
 301         pass $test
 302         return 1
 303     } elseif {$result == 1 \
 304               && [string match -nocase "*: Not enough room to add .dynamic entry" $output]} {
 305         # Linker should have reserved some entries for prelink.
 306         xfail $test
 307         return 0
 308     } else {
 309         fail $test
 310         return 0
 311     }
 312 }