ld/testsuite/ld-elfvers/vers.exp

   1 # Expect script for ld-version tests
   2 #   Copyright (C) 1997 Free Software Foundation
   3 #
   4 # This file is free software; you can redistribute it and/or modify
   5 # it under the terms of the GNU General Public License as published by
   6 # the Free Software Foundation; either version 2 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17 #
  18 # Written by Eric Youngdale (eric@andante.jic.com)
  19
  20 #
  21
  22 # This test can only be run if ld generates native executables.
  23 if ![isnative] then {return}
  24
  25 # This test can only be run on a couple of ELF platforms.
  26 # Square bracket expressions seem to confuse istarget.
  27 # This is the same test that is used in ld-shared, BTW.
  28 if { ![istarget i386-*-sysv4*] \
  29      && ![istarget i486-*-sysv4*] \
  30      && ![istarget i586-*-sysv4*] \
  31      && ![istarget i386-*-unixware] \
  32      && ![istarget i486-*-unixware] \
  33      && ![istarget i586-*-unixware] \
  34      && ![istarget i386-*-elf*] \
  35      && ![istarget i486-*-elf*] \
  36      && ![istarget i586-*-elf*] \
  37      && ![istarget i386-*-linux*] \
  38      && ![istarget i486-*-linux*] \
  39      && ![istarget i586-*-linux*] \
  40      && ![istarget m68k-*-linux*] \
  41      && ![istarget mips*-*-irix5*] \
  42      && ![istarget sparc*-*-elf] \
  43      && ![istarget sparc*-*-solaris2*] \
  44      && ![istarget sparc*-*-sunos4*] \
  45      && ![istarget rs6000*-*-aix*] \
  46      && ![istarget powerpc*-*-aix*] } {
  47     return
  48 }
  49
  50 if { [istarget i386-*-linuxaout*] \
  51      || [istarget i486-*-linuxaout*] \
  52      || [istarget i586-*-linuxaout*] \
  53      || [istarget i386-*-linuxoldld*] \
  54      || [istarget i486-*-linuxoldld*] \
  55      || [istarget i586-*-linuxoldld*] \
  56      || [istarget m68k-*-linuxaout*] } {
  57     return
  58 }
  59
  60 if { [istarget rs6000*-*-aix*] || [istarget powerpc*-*-aix*] } {
  61     return
  62 }
  63
  64 set diff diff
  65 set tmpdir tmpdir
  66 set VOBJDUMP_FLAGS --private-headers
  67 set DOBJDUMP_FLAGS --dynamic-syms
  68 set SOBJDUMP_FLAGS --syms
  69 set shared --shared
  70 set script --version-script
  71
  72 proc test_ar { test lib object expect } {
  73     global ar
  74     global nm
  75     global tmpdir
  76     global srcdir
  77     global subdir
  78     global diff
  79
  80     verbose -log "$ar -cr $tmpdir/$lib $tmpdir/$object"
  81     catch "exec $ar -cr $tmpdir/$lib $tmpdir/$object" exec_output
  82     set exec_output [prune_warnings $exec_output]
  83     if ![string match "" $exec_output] {
  84         verbose -log "$exec_output"
  85         unresolved "$test"
  86         return
  87     }
  88
  89     verbose -log "$nm --print-armap $tmpdir/$lib | grep \" in \" | grep \"VERS\\|bar\\|foo\" | sort > $tmpdir/nm.out"
  90
  91     catch "exec $nm --print-armap $tmpdir/$lib | grep \\\ in\\\  | grep VERS\\\\|bar\\\\|foo | sort > $tmpdir/nm.out" exec_output
  92     if [string match "" $exec_output] then {
  93         catch "exec $diff -q $tmpdir/nm.out $srcdir/$subdir/$expect" exec_output
  94         set exec_output [prune_warnings $exec_output]
  95         if [string match "" $exec_output] then {
  96             pass $test
  97             return
  98         } else {
  99             verbose -log "$exec_output"
 100             fail "$test"
 101             return
 102         }
 103     } else {
 104         verbose -log "$exec_output"
 105         fail "$test"
 106     }
 107 }
 108
 109 #
 110 # objdump_emptysymstuff
 111 #       Check non-dynamic symbols and make sure there are none with '@'.
 112 #
 113 proc objdump_emptysymstuff { objdump object } {
 114     global SOBJDUMP_FLAGS
 115     global version_output
 116     global diff
 117
 118     if ![info exists SOBJDUMP_FLAGS] { set SOBJDUMP_FLAGS "" }
 119
 120     verbose -log "$objdump $SOBJDUMP_FLAGS $object | sed -n /\@/p"
 121
 122     catch "exec $objdump $SOBJDUMP_FLAGS $object | sed -n /\@/p" exec_output
 123     set exec_output [prune_warnings $exec_output]
 124     if [string match "" $exec_output] then {
 125 # We shouldn't get anything here.
 126         return 1
 127     } else {
 128 # it is not normal to come here - we have no output to compare.
 129         verbose -log "$exec_output"
 130         verbose -log "objdump_emptysymstuff: did not expect any output from objdump"
 131         return 0
 132     }
 133
 134 }
 135
 136 #
 137 # objdump_emptydynsymstuff
 138 #       Check dynamic symbols and make sure there are none with '@'.
 139 #
 140 proc objdump_emptydynsymstuff { objdump object } {
 141     global DOBJDUMP_FLAGS
 142     global version_output
 143     global diff
 144
 145     if ![info exists VOBJDUMP_FLAGS] { set VOBJDUMP_FLAGS "" }
 146
 147     verbose -log "$objdump $DOBJDUMP_FLAGS $object | sed -n /VERS/p\\\;/show/p"
 148
 149     catch "exec $objdump $DOBJDUMP_FLAGS $object | sed -n /VERS/p\\\;/show/p" exec_output
 150     set exec_output [prune_warnings $exec_output]
 151     if [string match "" $exec_output] then {
 152 # We shouldn't get anything here.
 153         return 1
 154     } else { if [string match "*objdump: *: not a dynamic object" $exec_output] then {
 155         return 1
 156     } else {
 157 # it is not normal to come here - we have no output to compare.
 158         verbose -log "$exec_output"
 159         verbose -log "objdump_emptydynsymstuff: did not expect any output from objdump"
 160         return 0
 161     } }
 162 }
 163
 164 #
 165 # objdump_emptyverstuff
 166 #       Make sure there is no version information
 167 #
 168 proc objdump_emptyverstuff { objdump object } {
 169     global VOBJDUMP_FLAGS
 170     global version_output
 171     global diff
 172     global tmpdir
 173
 174     if {[which $objdump] == 0} then {
 175         perror "$objdump does not exist"
 176         return 0
 177     }
 178
 179     if ![info exists VOBJDUMP_FLAGS] { set VOBJDUMP_FLAGS "" }
 180
 181     verbose -log "$objdump $VOBJDUMP_FLAGS $object | sed -n /Version/,\\\$p > $tmpdir/objdump.out"
 182
 183     catch "exec $objdump $VOBJDUMP_FLAGS $object | sed -n /Version/,\\\$p" exec_output
 184     set exec_output [prune_warnings $exec_output]
 185     if [string match "" $exec_output] then {
 186 # it is normal to fail here - we have no output to compare.
 187         return 1
 188     } else {
 189         verbose -log "$exec_output"
 190         verbose -log "objdump_emptyverstuff: did not expect any output from objdump"
 191         return 0
 192     }
 193
 194 }
 195
 196 #
 197 # objdump_symstuff
 198 #       Dump non-dynamic symbol stuff and make sure that it is sane.
 199 #
 200 proc objdump_symstuff { objdump object expectfile } {
 201     global SOBJDUMP_FLAGS
 202     global version_output
 203     global diff
 204     global tmpdir
 205
 206     if ![info exists SOBJDUMP_FLAGS] { set SOBJDUMP_FLAGS "" }
 207
 208     verbose -log "$objdump $SOBJDUMP_FLAGS $object | grep \@ | sort  > $tmpdir/objdump.out"
 209
 210     catch "exec $objdump $SOBJDUMP_FLAGS $object | grep \@ | sort  > $tmpdir/objdump.out" exec_output
 211     set exec_output [prune_warnings $exec_output]
 212     if [string match "" $exec_output] then {
 213
 214 # Now do a line-by-line comparison to effectively diff the darned things
 215 # The stuff coming from the expectfile is actually a regex, so we can
 216 # skip over the actual addresses and so forth.  This is currently very
 217 # simpleminded - it expects a one-to-one correspondence in terms of line
 218 # numbers.
 219
 220         if [file exists $expectfile] then {
 221             set file_a [open $expectfile r]
 222         } else {
 223             perror "$expectfile doesn't exist"
 224             return 0
 225         }
 226
 227         if [file exists $tmpdir/objdump.out] then {
 228             set file_b [open $tmpdir/objdump.out r]
 229         } else {
 230             perror "$tmpdir/objdump.out doesn't exist"
 231             return 0
 232         }
 233
 234         verbose "# Diff'ing: $expectfile $tmpdir/objdump.out" 2
 235
 236         set eof -1
 237         set differences 0
 238
 239         while { [gets $file_a line] != $eof } {
 240             if [regexp "^#.*$" $line] then {
 241                 continue
 242             } else {
 243                 lappend list_a $line
 244             }
 245         }
 246         close $file_a
 247
 248         while { [gets $file_b line] != $eof } {
 249             if [regexp "^#.*$" $line] then {
 250                 continue
 251             } else {
 252                 lappend list_b $line
 253             }
 254         }
 255         close $file_b
 256
 257         for { set i 0 } { $i < [llength $list_a] } { incr i } {
 258             set line_a [lindex $list_a $i]
 259             set line_b [lindex $list_b $i]
 260
 261
 262             verbose "\t$expectfile: $i: $line_a" 3
 263             verbose "\t/tmp/objdump.out: $i: $line_b" 3
 264             if [regexp $line_a $line_b] then {
 265                 continue
 266             } else {
 267                 verbose -log "\t$expectfile: $i: $line_a"
 268                 verbose -log "\t$tmpdir/objdump.out: $i: $line_b"
 269
 270                 return 0
 271             }
 272         }
 273
 274         if { [llength $list_a] != [llength $list_b] } {
 275             verbose -log "Line count"
 276             return 0
 277         }
 278
 279         if $differences<1 then {
 280             return 1
 281         }
 282
 283         return 0
 284     } else {
 285         verbose -log "$exec_output"
 286         return 0
 287     }
 288
 289 }
 290
 291 #
 292 # objdump_dymsymstuff
 293 #       Dump dynamic symbol stuff and make sure that it is sane.
 294 #
 295 proc objdump_dynsymstuff { objdump object expectfile } {
 296     global DOBJDUMP_FLAGS
 297     global version_output
 298     global diff
 299     global tmpdir
 300
 301     if ![info exists DOBJDUMP_FLAGS] { set DOBJDUMP_FLAGS "" }
 302
 303     verbose -log "$objdump $DOBJDUMP_FLAGS $object | sed -n /VERS/p\\\;/show/p | sort | uniq  > $tmpdir/objdump.out"
 304
 305     catch "exec $objdump $DOBJDUMP_FLAGS $object | sed -n /VERS/p\\\;/show/p | sort | uniq  > $tmpdir/objdump.out" exec_output
 306     set exec_output [prune_warnings $exec_output]
 307     if [string match "" $exec_output] then {
 308
 309 # Now do a line-by-line comparison to effectively diff the darned things
 310 # The stuff coming from the expectfile is actually a regex, so we can
 311 # skip over the actual addresses and so forth.  This is currently very
 312 # simpleminded - it expects a one-to-one correspondence in terms of line
 313 # numbers.
 314
 315         if [file exists $expectfile] then {
 316             set file_a [open $expectfile r]
 317         } else {
 318             warning "$expectfile doesn't exist"
 319             return 0
 320         }
 321
 322         if [file exists $tmpdir/objdump.out] then {
 323             set file_b [open $tmpdir/objdump.out r]
 324         } else {
 325             fail "$tmpdir/objdump.out doesn't exist"
 326             return 0
 327         }
 328
 329         verbose "# Diff'ing: $expectfile $tmpdir/objdump.out" 2
 330
 331         set eof -1
 332         set differences 0
 333
 334         while { [gets $file_a line] != $eof } {
 335             if [regexp "^#.*$" $line] then {
 336                 continue
 337             } else {
 338                 lappend list_a $line
 339             }
 340         }
 341         close $file_a
 342
 343         while { [gets $file_b line] != $eof } {
 344             if [regexp "^#.*$" $line] then {
 345                 continue
 346             } else {
 347                 lappend list_b $line
 348             }
 349         }
 350         close $file_b
 351
 352         for { set i 0 } { $i < [llength $list_b] } { incr i } {
 353             set line_b [lindex $list_b $i]
 354
 355 # The tests are rigged so that we should never export a symbol with the
 356 # word 'hide' in it.  Thus we just search for it, and bail if we find it.
 357             if [regexp "hide" $line_b] then {
 358                 verbose -log "\t$tmpdir/objdump.out: $i: $line_b"
 359
 360                 return 0
 361             }
 362
 363             verbose "\t$expectfile: $i: $line_b" 3
 364
 365             # We can't assume that the sort is consistent across
 366             # systems, so we must check each regexp.  When we find a
 367             # regexp, we null it out, so we don't match it twice.
 368             for { set j 0 } { $j < [llength $list_a] } { incr j } {
 369                 set line_a [lindex $list_a $j]
 370
 371                 if [regexp $line_a $line_b] then {
 372                     lreplace $list_a $j $j "CAN NOT MATCH"
 373                     break
 374                 }
 375             }
 376
 377             if { $j >= [llength $list_a] } {
 378                 verbose -log "\t$tmpdir/objdump.out: $i: $line_b"
 379
 380                 return 0
 381             }
 382         }
 383
 384         if { [llength $list_a] != [llength $list_b] } {
 385             verbose -log "Line count"
 386             return 0
 387         }
 388
 389         if $differences<1 then {
 390             return 1
 391         }
 392
 393         return 0
 394     } else {
 395         verbose -log "$exec_output"
 396         return 0
 397     }
 398
 399 }
 400
 401 #
 402 # objdump_versionstuff
 403 #       Dump version definitions/references and make sure that it is sane.
 404 #
 405 proc objdump_versionstuff { objdump object expectfile } {
 406     global VOBJDUMP_FLAGS
 407     global version_output
 408     global diff
 409     global tmpdir
 410
 411     if {[which $objdump] == 0} then {
 412         perror "$objdump does not exist"
 413         return 0
 414     }
 415
 416     if ![info exists VOBJDUMP_FLAGS] { set VOBJDUMP_FLAGS "" }
 417
 418     verbose -log "$objdump $VOBJDUMP_FLAGS $object | sed -n /Version/,\\\$p > $tmpdir/objdump.out"
 419
 420     catch "exec $objdump $VOBJDUMP_FLAGS $object | sed -n /Version/,\\\$p > $tmpdir/objdump.out" exec_output
 421     set exec_output [prune_warnings $exec_output]
 422     if [string match "" $exec_output] then {
 423
 424 # now perform differences against the expected output.
 425         verbose -log "$diff -q $tmpdir/objdump.out $expectfile"
 426         catch "exec $diff -q $tmpdir/objdump.out $expectfile" exec_output
 427         set exec_output [prune_warnings $exec_output]
 428         if [string match "" $exec_output] then {
 429             return 1
 430         } else {
 431             verbose -log "$exec_output"
 432             return 0
 433         }
 434
 435         return 1
 436     } else {
 437         verbose -log "$exec_output"
 438         return 0
 439     }
 440 }
 441
 442 proc build_vers_lib { test source libname other mapfile verexp versymexp symexp } {
 443     global ld
 444     global srcdir
 445     global subdir
 446     global exec_output
 447     global host_triplet
 448     global tmpdir
 449     global as
 450     global objdump
 451     global CC
 452     global CFLAGS
 453     global shared
 454     global script
 455
 456     if ![ld_compile "$CC -S $CFLAGS" $srcdir/$subdir/$source $tmpdir/$libname.s]     {
 457         unresolved "$test"
 458         return
 459     }
 460
 461     if ![ld_assemble $as $tmpdir/$libname.s $tmpdir/$libname.o ]     {
 462         unresolved "$test"
 463         return
 464     }
 465
 466     if [string match "" $other] then {
 467         set other_lib ""
 468     } else {
 469         set other_lib $tmpdir/$other
 470     }
 471
 472     if [string match "" $mapfile] then {
 473         set script_arg ""
 474     } else {
 475         set script_arg "$script $srcdir/$subdir/$mapfile"
 476     }
 477
 478     if {![ld_simple_link $ld $tmpdir/$libname.so "$shared $tmpdir/$libname.o $other_lib $script_arg"]}     {
 479         fail "$test"
 480         return
 481     }
 482
 483     if {![objdump_versionstuff $objdump $tmpdir/$libname.so $srcdir/$subdir/$verexp ]}     {
 484         fail "$test"
 485         return
 486     }
 487
 488     if {![objdump_dynsymstuff $objdump $tmpdir/$libname.so $srcdir/$subdir/$versymexp ]}     {
 489         fail "$test"
 490         return
 491     }
 492
 493     if [string match "" $symexp] then {
 494         if {![objdump_emptysymstuff $objdump $tmpdir/$libname.o ]}     {
 495             fail "$test"
 496             return
 497         }
 498     } else {
 499         if {![objdump_symstuff $objdump $tmpdir/$libname.o $srcdir/$subdir/$symexp ]}     {
 500             fail "$test"
 501             return
 502         }
 503     }
 504
 505     pass $test
 506
 507 }
 508
 509 proc test_ldfail { test flag source execname other mapfile whyfail } {
 510     global ld
 511     global srcdir
 512     global subdir
 513     global exec_output
 514     global host_triplet
 515     global tmpdir
 516     global as
 517     global objdump
 518     global CC
 519     global CFLAGS
 520     global script
 521
 522     if [string match "" $other] then {
 523         set other_lib ""
 524     } else {
 525         set other_lib $tmpdir/$other
 526     }
 527
 528     if ![ld_compile "$CC -S $flag $CFLAGS" $srcdir/$subdir/$source $tmpdir/$execname.s]     {
 529         unresolved "$test"
 530         return
 531     }
 532
 533     if ![ld_assemble $as $tmpdir/$execname.s $tmpdir/$execname.o ]     {
 534         unresolved "$test"
 535         return
 536     }
 537
 538     verbose -log "This link should fail because of $whyfail"
 539
 540     if [string match "" $mapfile] then {
 541         set script_arg ""
 542     } else {
 543         set script_arg "$script $srcdir/$subdir/$mapfile"
 544     }
 545
 546     if {![ld_link $ld $tmpdir/$execname "$tmpdir/$execname.o $other_lib $script_arg"]}     {
 547         pass "$test"
 548         return
 549     }
 550     fail "$test"
 551 }
 552
 553 proc test_asfail { test flag source execname whyfail } {
 554     global srcdir
 555     global subdir
 556     global tmpdir
 557     global as
 558     global CC
 559     global CFLAGS
 560
 561     if ![ld_compile "$CC -S $flag $CFLAGS" $srcdir/$subdir/$source $tmpdir/$execname.s]     {
 562         unresolved "$test"
 563         return
 564     }
 565
 566     verbose -log "This assemble should fail because of $whyfail"
 567     catch "exec $as -o $tmpdir/$execname.o $tmpdir/$execname.s" exec_output
 568     set exec_output [prune_warnings $exec_output]
 569     if [string match "" $exec_output] then {
 570         fail "$test"
 571         return
 572     }
 573     verbose -log "$exec_output"
 574     pass "$test"
 575 }
 576
 577 proc test_strip_vers_lib { test srclib libname verexp versymexp } {
 578     global strip
 579     global srcdir
 580     global subdir
 581     global exec_output
 582     global host_triplet
 583     global tmpdir
 584     global objdump
 585
 586     verbose -log "cp $tmpdir/$srclib $tmpdir/$libname.so"
 587     exec cp $tmpdir/$srclib $tmpdir/$libname.so
 588
 589     verbose -log "$strip $tmpdir/$libname.so"
 590     catch "exec $strip $tmpdir/$libname.so" exec_output
 591     if [string match "" $exec_output] then {
 592
 593 # If strip went OK, then run the usual tests on the thing to make sure that
 594 # it is sane.
 595         if {![objdump_versionstuff $objdump $tmpdir/$libname.so $srcdir/$subdir/$verexp ]}     {
 596             fail "$test"
 597             return
 598         }
 599
 600         if {![objdump_dynsymstuff $objdump $tmpdir/$libname.so $srcdir/$subdir/$versymexp ]}     {
 601             fail "$test"
 602             return
 603         }
 604
 605     } else {
 606         verbose -log "$exec_output"
 607         fail "$test"
 608         return
 609     }
 610     pass $test
 611 }
 612
 613
 614 proc build_exec { test source execname flags solibname verexp versymexp symexp } {
 615     global ld
 616     global srcdir
 617     global subdir
 618     global exec_output
 619     global host_triplet
 620     global tmpdir
 621     global as
 622     global objdump
 623     global CC
 624     global CFLAGS
 625
 626     set shared --shared
 627     set script --version-script
 628     if ![ld_compile "$CC -S $CFLAGS" $srcdir/$subdir/$source $tmpdir/$execname.s]     {
 629         unresolved "$test"
 630         return
 631     }
 632
 633     if ![ld_assemble $as $tmpdir/$execname.s $tmpdir/$execname.o ]     {
 634         unresolved "$test"
 635         return
 636     }
 637
 638     if [string match "" $solibname] then {
 639         set solibname_lib ""
 640     } else {
 641         set solibname_lib $tmpdir/$solibname
 642     }
 643
 644     if {![ld_link $ld $tmpdir/$execname "$flags $tmpdir/$execname.o $solibname_lib"]}     {
 645         fail "$test"
 646         return
 647     }
 648
 649     if [string match "" $verexp] then {
 650 #
 651 # Make sure we get nothing back.
 652 #
 653         if {![objdump_emptyverstuff $objdump $tmpdir/$execname ]}     {
 654             fail "$test"
 655             return
 656         }
 657     } else {
 658         if {![objdump_versionstuff $objdump $tmpdir/$execname $srcdir/$subdir/$verexp ]}     {
 659             fail "$test"
 660             return
 661         }
 662     }
 663
 664     if [string match "" $versymexp] then {
 665         if {![objdump_emptydynsymstuff $objdump $tmpdir/$execname ]}     {
 666             fail "$test"
 667             return
 668         }
 669     } else {
 670         if {![objdump_dynsymstuff $objdump $tmpdir/$execname $srcdir/$subdir/$versymexp ]}     {
 671             fail "$test"
 672             return
 673         }
 674     }
 675
 676     if [string match "" $symexp] then {
 677         if {![objdump_emptysymstuff $objdump $tmpdir/$execname.o ]}     {
 678             fail "$test"
 679             return
 680         }
 681     } else {
 682         if {![objdump_symstuff $objdump $tmpdir/$execname.o $srcdir/$subdir/$symexp ]}     {
 683             fail "$test"
 684             return
 685         }
 686     }
 687
 688     pass $test
 689 }
 690
 691
 692 #
 693 # Basic test - build a library with versioned symbols.
 694 #
 695 build_vers_lib "vers1" vers1.c vers1 "" vers1.map vers1.ver vers1.dsym vers1.sym
 696
 697
 698 #
 699 # Test #2 - build a library, and link it against the library we built in step
 700 # 1.
 701 #
 702 build_vers_lib "vers2" vers2.c vers2 vers1.so vers2.map vers2.ver vers2.dsym ""
 703
 704 #
 705 # Test #3 - build an executable, and link it against vers1.so.
 706 #
 707 build_exec "vers3" vers3.c vers3 "" vers1.so vers3.ver vers3.dsym ""
 708
 709 #
 710 # Test #4 - Make sure a version implicitly defined in an executable
 711 # causes a version node to be created.  Verify this both with and without
 712 # --export-dynamic.
 713 #
 714
 715 # This test fails on MIPS.  On the MIPS we must put foo in the dynamic
 716 # symbol table, which the test does not expect.
 717 setup_xfail "mips*-*-*"
 718 build_exec "vers4" vers4.c vers4 "" "" "" "" vers4.sym
 719
 720 build_exec "vers4a" vers4.c vers4a "-export-dynamic" "" vers4a.ver vers4a.dsym vers4a.sym
 721
 722
 723 #
 724 # Try multiple definitions foo@BAR and foo@@BAR and make sure the linker
 725 # complains.
 726 #
 727 test_ldfail "vers5" "" vers5.c vers5 "" "" "multiple definition of foo@VERS_1.2"
 728
 729 #
 730 #
 731 # Now build a test that should reference a bunch of versioned symbols.
 732 # All of them should be correctly referenced.
 733 #
 734 build_exec "vers6" vers6.c vers6 "" vers1.so vers6.ver vers6.dsym vers6.sym
 735
 736 #
 737 # Another test to verify that something made local via 'local' is truly not
 738 # accessible.
 739 #
 740 build_vers_lib "vers7a" vers7a.c vers7a "" vers7.map vers7a.ver vers7a.dsym vers7a.sym
 741
 742 test_ldfail "vers7" "" vers7.c vers7 vers7a.so "" "undefined reference to hide_a"
 743
 744
 745 #
 746 # This test is designed to verify that we can pass a linker script on the
 747 # command line as if it were a normal .o file.
 748 #
 749 catch "exec cp $srcdir/$subdir/vers8.map $tmpdir/" ignore_output
 750 build_vers_lib "vers8" vers1.c vers8 vers8.map "" vers8.ver vers1.dsym vers1.sym
 751
 752 #
 753 # This test tries to make sure that version references to versioned symbols
 754 # don't collide with default definitions with the same symbol.
 755 #
 756 build_exec "vers9" vers9.c vers9 "-export-dynamic" "" vers9.ver vers9.dsym vers9.sym
 757
 758
 759 #
 760 # Try and use a non-existant version node.  The linker should fail with
 761 # an error message.
 762 #
 763 test_ldfail "vers10" "-DDO_TEST10" vers1.c vers10 "" "vers1.map --shared" "invalid version"
 764
 765 #
 766 # Try and some things the assembler should complain about.
 767 #
 768 test_asfail "vers11" "-DDO_TEST11" vers1.c vers11 "no @ in symver"
 769
 770 test_asfail "vers12" "-DDO_TEST12" vers1.c vers12 "extern version definition"
 771
 772 #
 773 # Put a shared library in an archive library, and make sure the global
 774 # archive symbol table is sane.
 775 #
 776 test_ar "ar with versioned solib" vers13.a vers1.so vers13.asym
 777
 778 #
 779 # Strip a shared library, and make sure we didn't screw something up in there.
 780 #
 781 test_strip_vers_lib "vers14" vers1.so vers14 vers1.ver vers1.dsym
 782
 783
 784 #
 785 # Build another test with some versioned symbols.  Here we are going to
 786 # try and override something from the library, and we shouldn't get
 787 # any errors.
 788 #
 789 build_exec "vers15" vers15.c vers15 "" vers1.so vers15.ver vers15.dsym vers15.sym