home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / binutils-2.7-src.tgz / tar.out / fsf / binutils / ld / testsuite / ld-empic / empic.exp next >
Text File  |  1996-09-28  |  8KB  |  264 lines
  1. # Expect script for ld-empic tests
  2. #   Copyright (C) 1994,1995 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 Ian Lance Taylor (ian@cygnus.com)
  19. #
  20.  
  21. # Test the handling of MIPS embedded PIC code.  This test essentially
  22. # tests the compiler and assembler as well as the linker, since MIPS
  23. # embedded PIC is a GNU enhancement to standard MIPS tools.
  24.  
  25. # Embedded PIC is only supported for MIPS ECOFF targets.
  26. if ![istarget mips*-*-ecoff*] {
  27.     return
  28. }
  29.  
  30. set testname relax
  31.  
  32. if { [which $CC] == 0 } {
  33.     untested $testname
  34.     return
  35. }
  36.  
  37. # Test that relaxation works correctly.  This testsuite was composed
  38. # (by experimentation) to force the linker to relax twice--that is,
  39. # the first relaxation pass will force another call to be out of
  40. # range, requiring a second relaxation pass.
  41. if { ![ld_compile "$CC $CFLAGS -membedded-pic" $srcdir$subdir/relax1.c tmpdir/relax1.o]
  42.      || ![ld_compile "$CC $CFLAGS -membedded-pic" $srcdir$subdir/relax2.c tmpdir/relax2.o]
  43.      || ![ld_compile "$CC $CFLAGS -membedded-pic" $srcdir$subdir/relax3.c tmpdir/relax3.o]
  44.      || ![ld_compile "$CC $CFLAGS -membedded-pic" $srcdir$subdir/relax4.c tmpdir/relax4.o] } {
  45.     unresolved $testname
  46.     return
  47. }
  48.  
  49. if ![ld_simple_link $ld tmpdir/relax "--relax -T $srcdir$subdir/relax.t tmpdir/relax1.o tmpdir/relax2.o tmpdir/relax3.o tmpdir/relax4.o"] {
  50.     fail $testname
  51. } else {
  52.     # Check that the relaxation produced the correct result.  Check
  53.     # each bal instruction.  Some will go directly to the start of a
  54.     # function, which is OK.  Some will form part of the five
  55.     # instruction expanded call sequence, in which case we compute the
  56.     # real destination and make sure it is the start of a function.
  57.     # Some bal instructions are used to locate the start of the
  58.     # function in order to do position independent addressing into the
  59.     # text section, in which case we just check that it correctly
  60.     # computes the start of the function.
  61.  
  62.     # Get the symbol table.
  63.     if ![ld_nm $nm tmpdir/relax] {
  64.     unresolved $testname
  65.     return
  66.     }
  67.  
  68.     # Get a disassembly.
  69.     send_log "$objdump -d tmpdir/relax >tmpdir/relax.dis\n"
  70.     verbose "$objdump -d tmpdir/relax >tmpdir/relax.dis"
  71.     catch "exec $objdump -d tmpdir/relax >tmpdir/relax.dis" exec_output
  72.     if ![string match "" $exec_output] {
  73.     send_log "$exec_output\n"
  74.     verbose $exec_output
  75.     unresolved $testname
  76.     return
  77.     }
  78.  
  79.     set balcnt 0
  80.     set file [open tmpdir/relax.dis r]
  81.     while { [gets $file line] != -1 } {
  82.     verbose "$line" 2
  83.  
  84.     if ![string match "*bal*" $line] {
  85.         continue
  86.     }
  87.  
  88.     verbose "$line"
  89.  
  90.     incr balcnt
  91.  
  92.     if ![regexp "^(\[0-9a-fA-F\]+) (<\[a-z+0-9A-Z.\]+>)? bal (\[0-9a-fA-F\]+)" $line whole addr label dest] {
  93.         perror "unrecognized format for $line"
  94.         unresolved $testname
  95.         return
  96.     }
  97.  
  98.     if "0x$addr + 8 != 0x$dest" {
  99.         # This is a straight function call.  All function calls in
  100.         # this example are to either foo or bar.
  101.         if "0x$dest != $nm_output(foo) && 0x$dest != $nm_output(bar)" {
  102.         send_log "fail 1\n"
  103.         send_log "$line\n"
  104.         fail $testname
  105.         return
  106.         }
  107.     } else {
  108.         # Pick up the next line.  If it is sll, this is a switch
  109.         # prologue, and there is not much we can do to test it.
  110.         # Otherwise, it should be lui, and the next instruction
  111.         # should be an addiu, followed by an addu to $31.
  112.         if { [gets $file l] == -1 } {
  113.         send_log "fail 2\n"
  114.         send_log "$line\n"
  115.         fail $testname
  116.         return
  117.         }
  118.         verbose $l
  119.  
  120.         if [string match "*sll*" $l] {
  121.         continue
  122.         }
  123.         if ![regexp "lui (\[\$a-z0-9\]+),(\[0-9a-fA-Fx\]+)" $l whole reg upper] {
  124.         send_log "fail 3\n"
  125.         send_log "$line\n"
  126.         send_log "$l\n"
  127.         fail $testname
  128.         return
  129.         }
  130.  
  131.         if { [gets $file l] == -1 } {
  132.         send_log "fail 4\n"
  133.         send_log "$line\n"
  134.         fail $testname
  135.         return
  136.         }
  137.         verbose "$l"
  138.         if ![regexp "addiu \\$reg,\\$reg,(\[-0-9\]+)" $l whole lower] {
  139.         send_log "fail 5\n"
  140.         send_log "$line\n"
  141.         send_log "$l\n"
  142.         send_log "addiu \\$reg,\\$reg,(\[-0-9\]+)\n"
  143.         fail $testname
  144.         return
  145.         }
  146.  
  147.         if { [gets $file l] == -1 } {
  148.         send_log "fail 6\n"
  149.         send_log "$line\n"
  150.         fail $testname
  151.         return
  152.         }
  153.         verbose "$l"
  154.         if ![regexp "addu \\$reg,\\$reg,\\\$ra" $l] {
  155.         send_log "fail 7\n"
  156.         send_log "$line\n"
  157.         send_log "$l\n"
  158.         fail $testname
  159.         return
  160.         }
  161.  
  162.         # The next line will be jalr in the case of an expanded
  163.         # call.  Otherwise, the code is getting the start of the
  164.         # function, and the next line can be anything.
  165.  
  166.         if { [gets $file l] == -1 } {
  167.         send_log "fail 8\n"
  168.         send_log "$line\n"
  169.         fail $testname
  170.         return
  171.         }
  172.         verbose "$l"    
  173.         if [string match "*jalr*" $l] {
  174.         set dest [expr 0x$addr + 8 + ($upper << 16) + $lower]
  175.         if { $dest != $nm_output(foo) && $dest != $nm_output(bar) } {
  176.             send_log "fail 9\n"
  177.             send_log "$line\n"
  178.             fail $testname
  179.             return
  180.         }
  181.         } else {
  182.         set dest [expr ($upper << 16) + $lower]
  183.         if ![regexp "<(\[.a-z\]+)\\+(\[0-9a-fA-F\]+)>" $label whole base offset] {
  184.             send_log "fail 10\n"
  185.             send_log "$line\n"
  186.             fail $testname
  187.             return
  188.         }
  189.         set offset 0x$offset
  190.         if { $base == ".foo" } {
  191.             set offset [expr $offset - ($nm_output(foo) - 0x30)]
  192.         }
  193.         if { $offset + 8 != - $dest } {
  194.             send_log "fail 11\n"
  195.             send_log "$line\n"
  196.             fail $testname
  197.             return
  198.         }
  199.         }
  200.     }
  201.     }
  202.  
  203.     close $file
  204.  
  205.     if {$balcnt < 10} {
  206.     send_log "fail 12\n"
  207.     fail $testname
  208.     } else {
  209.     verbose "$balcnt bal instructions"
  210.     pass $testname
  211.     }
  212. }
  213.  
  214. # We now test actually running embedded MIPS PIC code.  This can only
  215. # be done on a MIPS host with the same endianness as our target.
  216. if [istarget mipsel-*-*] {
  217.     if ![ishost mips*-*-ultrix*] {
  218.     return
  219.     }
  220. } else {
  221.     if ![ishost mips*-*-irix*] {
  222.     return
  223.     }
  224. }
  225.  
  226. set testname "run embedded PIC code"
  227.  
  228. # Compile the program which will run the test.  This code must be
  229. # compiled for the host, not the target.
  230. send_log "$CC_FOR_HOST $CFLAGS_FOR_HOST -o tmpdir/run $srcdir$subdir/run.c\n"
  231. verbose "$CC_FOR_HOST $CFLAGS_FOR_HOST -o tmpdir/run $srcdir$subdir/run.c"
  232. catch "exec $CC_FOR_HOST $CFLAGS_FOR_HOST -o tmpdir/run $srcdir$subdir/run.c" exec_output
  233. if ![string match "" $exec_output] {
  234.     send_log "$exec_output\n"
  235.     verbose "$exec_output"
  236.     unresolved $testname
  237.     return
  238. }
  239.  
  240. # Compile and link the test.
  241. if { ![ld_compile "$CC $CFLAGS -membedded-pic" $srcdir$subdir/runtesti.s tmpdir/runtesti.o]
  242.      || ![ld_compile "$CC $CFLAGS -membedded-pic" $srcdir$subdir/runtest1.c tmpdir/runtest1.o]
  243.      || ![ld_compile "$CC $CFLAGS -membedded-pic" $srcdir$subdir/runtest2.c tmpdir/runtest2.o] } {
  244.     unresolved $testname
  245.     return
  246. }
  247. if ![ld_simple_link $ld tmpdir/runtest "--embedded-relocs tmpdir/runtesti.o tmpdir/runtest1.o tmpdir/runtest2.o"] {
  248.     fail $testname
  249. } else {
  250.     # Now run the test.
  251.     send_log "tmpdir/run tmpdir/runtest\n"
  252.     verbose "tmpdir/run tmpdir/runtest"
  253.     catch "exec tmpdir/run tmpdir/runtest" exec_output
  254.     if [string match "*ran and returned 0*" $exec_output] {
  255.     send_log "$exec_output\n"
  256.     verbose "$exec_output"
  257.     pass $testname
  258.     } else {
  259.     send_log "$exec_output\n"
  260.     verbose "$exec_output"
  261.     fail $testname
  262.     }
  263. }
  264.