GDB 7.6.50

gdb/testsuite/gdb.base/bitfields2.exp

-# Copyright 1992, 1994-1995, 1997, 2004, 2007-2012 Free Software
-# Foundation, Inc.
+# Copyright 1992-2013 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 # This file was adapted from bitfields.exp by Paul Hilfinger 
 # (Hilfinger@gnat.com)
 
 #
 # Tests for bit-fields that do not fit in type (unsigned) int, but do fit 
 # in type (unsigned) long long.  We perform essentially the same tests as
 # in bitfields.c, which considers only bit-fields that are <= 9 bits long.
 #
 
 
-set testfile "bitfields2"
-set srcfile ${testfile}.c
-set binfile ${objdir}/${subdir}/${testfile}
+standard_testfile .c
+
 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
     untested bitfields2.exp
     return -1
 }
 
 set has_signed_bitfields 1
 
 #
 # Continue to expected breakpoint at FUNCTION.  Append TAG to make pass/fail 
 # messages (to make them unique).  Suppress tests on failure.
@@ skipping 32 matching lines @@
 
 proc bitfield_uniqueness {} {
     global decimal
     global hex
     global gdb_prompt
     global srcfile
 
     start_test break1
         
     if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 0, s1 = 1, s2 = 0, s3 = 0.*" "bitfield uniqueness; flags.s1 = 1"] {
-        gdb_suppress_tests;
+        gdb_suppress_tests
     }
     continue_test break1 "#1"
     if [gdb_test "print flags" ".*u1 = 1, u2 = 0, u3 = 0, s1 = 0, s2 = 0, s3 = 0.*" "bitfield uniqueness; flags.u1 = 1"] {
-        gdb_suppress_tests;
+        gdb_suppress_tests
     }
     continue_test break1 "#2"
     if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 0, s1 = 0, s2 = 1, s3 = 0.*" "bitfield uniqueness; flags.s2 = 1"] {
-        gdb_suppress_tests;
+        gdb_suppress_tests
     }
     continue_test break1 "#3"
     if [gdb_test "print flags" ".*u1 = 0, u2 = 1, u3 = 0, s1 = 0, s2 = 0, s3 = 0.*" "bitfield uniqueness; flags.u2 = 1"] {
-        gdb_suppress_tests;
+        gdb_suppress_tests
     }
     continue_test break1 "#4"
     if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 0, s1 = 0, s2 = 0, s3 = 1.*" "bitfield uniqueness; flags.s3 = 1"] {
-        gdb_suppress_tests;
+        gdb_suppress_tests
     }
     continue_test break1 "#5"
     if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 1, s1 = 0, s2 = 0, s3 = 0.*" "bitfield uniqueness; flags.u3 = 1"] {
         gdb_suppress_tests
     }
-    gdb_stop_suppressing_tests;
+    gdb_stop_suppressing_tests
 }
 
 
 #
 # Test bitfield containment.
 # Fill alternating fields with all 1's and verify that none of the bits
 # "bleed over" to the other fields.
 #
 
 proc bitfield_containment {} {
     global decimal
     global hex
     global gdb_prompt
     global srcfile
 
     start_test break2
 
     # If program is compiled with Sun CC, signed fields print out as their
     # actual sizes; if compiled with gcc, they print out as 0xffffffff.
     if [gdb_test "print/x flags" "= {u1 = 0x7fff, u2 = 0x0, u3 = 0xffff, s1 = 0x0, s2 = 0x(1ffffffff|f*), s3 = 0x0}" "bitfield containment; flags.u1, flags.u3, and flags.s3 to all 1s"] {
         gdb_suppress_tests
     }
 
     continue_test break2 "#1"
 
     if [gdb_test "print/x flags" "= {u1 = 0x0, u2 = 0x1ffffffff, u3 = 0x0, s1 = 0x(7fff|f*), s2 = 0x0, s3 = 0xf*}" "bitfield containment; flags.u2, flags.s1, flags.s2 to all 1s"] {
         gdb_suppress_tests
     }
-    gdb_stop_suppressing_tests;
+    gdb_stop_suppressing_tests
 }
 
 # Test unsigned bitfields for unsignedness and range.
 # Fill the unsigned fields with the maximum positive value and verify that
 # the values are printed correctly.
 
 proc bitfield_unsignedness {} {
     global decimal
     global hex
     global gdb_prompt
     global srcfile
 
     start_test break3
 
     if [gdb_test "print flags" ".*u1 = 32767, u2 = 8589934591, u3 = 65535, s1 = 0, s2 = 0, s3 = 0.*" "maximum unsigned bitfield values"] {
         gdb_suppress_tests
     }
-    gdb_stop_suppressing_tests;
+    gdb_stop_suppressing_tests
 }
 
 #
 # Test signed bitfields for signedness and range.
 # Fill the signed fields with the maximum positive value, then the maximally
 # negative value, then -1, and verify in each case that the values are
 # printed correctly.
 #
 
 proc bitfield_signedness {} {
@@ skipping 42 matching lines @@
 
     set test "signed bitfields containing -1"
     if $has_signed_bitfields then {
         if [gdb_test "print flags" "u1 = 0, u2 = 0, u3 = 0, s1 = -1, s2 = -1, s3 = -1.*" $test ] {
             gdb_suppress_tests
         }
     } else {
         unsupported $test
     }
 
-    gdb_stop_suppressing_tests;
+    gdb_stop_suppressing_tests
 }
 
 
 # Test setting of long long bit fields from within GDB.
 
 proc bitfield_set {} {
     global decimal
     global hex
     global gdb_prompt
     global srcfile
@@ skipping 45 matching lines @@
 
     set test  "long long bitfield values after set negative"
     if $has_signed_bitfields then {
         if [gdb_test "print flags" "u1 = 0, u2 = 4294967296, u3 = 0, s1 = 0, s2 = -1, s3 = 0.*" $test] {
             gdb_suppress_tests
         }
     } else {
         unsupported $test
     }
 
-    gdb_stop_suppressing_tests;
+    gdb_stop_suppressing_tests
 }
 
-gdb_start
-gdb_reinitialize_dir $srcdir/$subdir
-gdb_load ${binfile}
+clean_restart ${binfile}
 
 gdb_test_no_output "set print sevenbit-strings"
 runto_main
 
 bitfield_uniqueness
 bitfield_containment
 bitfield_unsignedness
 bitfield_signedness
 bitfield_set