From patchwork Fri Oct 7 21:52:43 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Aldy Hernandez X-Patchwork-Id: 118375 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id 28621B70BF for ; Sat, 8 Oct 2011 08:53:11 +1100 (EST) Received: (qmail 24277 invoked by alias); 7 Oct 2011 21:53:09 -0000 Received: (qmail 24265 invoked by uid 22791); 7 Oct 2011 21:53:06 -0000 X-SWARE-Spam-Status: No, hits=-6.6 required=5.0 tests=AWL, BAYES_00, RCVD_IN_DNSWL_HI, RP_MATCHES_RCVD, SPF_HELO_PASS X-Spam-Check-By: sourceware.org Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Fri, 07 Oct 2011 21:52:46 +0000 Received: from int-mx12.intmail.prod.int.phx2.redhat.com (int-mx12.intmail.prod.int.phx2.redhat.com [10.5.11.25]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id p97LqiqA026527 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Fri, 7 Oct 2011 17:52:44 -0400 Received: from houston.quesejoda.com (vpn-236-62.phx2.redhat.com [10.3.236.62]) by int-mx12.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id p97Lqi9P014204; Fri, 7 Oct 2011 17:52:44 -0400 Message-ID: <4E8F74AB.2000800@redhat.com> Date: Fri, 07 Oct 2011 16:52:43 -0500 From: Aldy Hernandez User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:6.0.2) Gecko/20110906 Thunderbird/6.0.2 MIME-Version: 1.0 To: Jeff Law CC: gcc-patches Subject: Re: patch ping: thread testing infrastructure References: <4E8B1B77.7040204@redhat.com> <4E8B5354.8030703@redhat.com> In-Reply-To: <4E8B5354.8030703@redhat.com> Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org First, thanks so much for tackling this review. I don't think anyone's overly enthusiastic about reviewing dejagnu crap^H^H^H^Hcode. > > On 10/04/11 08:43, Aldy Hernandez wrote: >> http://gcc.gnu.org/ml/gcc-patches/2011-09/msg01272.html > So others have already mentioned the name "memmodel" as being > unsatisfactory... From the list, I liked simulate-thread (before > looking at your message where you voted for simulate-thread). Done. > in memmodel-gdb-test, is there any reasonable way to detect if we're > not exactly 3 frames down from dg-test and that the local variable > "name" holds the filename of hte testcase? Are these requirements > documented anywhere? I have no idea. To be honest, I just copied what every other dg* kludge was doing. > In the same code, don't you want to use somethign other than > GUALITY_GDB_NAME? Clearly we've got two gcc testing frameworks that > need gdb. A generic name might work better GDB_FOR_GCC_TESTING? Or > something like that. Ok, I got rid of the entire dependence on the guality infrastructure. It was overkill to begin with. I just used it because it was there. All we really want is the path to a gdb. And if it exists, we can fail the tests themselves if the gdb isn't working as expected. I have added a generic function gdb-exists() that can test the presence of a gdb in the path, and then it'll be up to the consumer to determine if it's working as desired. This function can use/set GDB_FOR_GCC_TESTING in a generic way as you have suggested. With the current revamp, the tests will fail if the given gdb does not work. > In remote_expect_target, don't you need to reorder the cases to have > the too-old-gdb case first. Otherwise you can get inconsistent > results due to the way matching works in tcl/expect. On a larger > note, can you use the routines from gcc-gdb-test.exp rather than > duplicating it? The order was what the guality harness had. I have swapped them as you suggested. The bits in gcc-simulate-thread.exp are sufficiently different to make abstracting the common bits with gcc-gdb-test.exp a bit uncomfortable. If you feel strongly about it, I can think harder. > Do we have allow-store-data-races as a parameter in GCC right now? If > not you'll need to do something about the tests themselves. It's already there in mainline. It was part of the original C++ memory model bitfield patch that has caused so much grief. Which reminds me, I need to continue on that... How do you like this approach? It's a lot cleaner, has less dependencies and shorter to boot! testsuite/ * lib/gcc-simulate-thread.exp: New. * gcc.dg/simulate-thread/guality.h: New. * gcc.dg/simulate-thread/simulate-thread.h: New. * gcc.dg/simulate-thread/simulate-thread.exp: New. * gcc.dg/simulate-thread/simulate-thread.gdb: New. * gcc.dg/simulate-thread/README: New. * g++.dg/simulate-thread/guality.h: New. * g++.dg/simulate-thread/simulate-thread.h: New. * g++.dg/simulate-thread/simulate-thread.exp: New. * g++.dg/simulate-thread/simulate-thread.gdb: New. * c-c++-common/cxxbitfields-2.c: Remove. * c-c++-common/cxxbitfields.c: Remove. * c-c++-common/cxxbitfields-4.c: Remove. * c-c++-common/cxxbitfields-5.c: Remove. * c-c++-common/simulate-thread/bitfields-1.c: New. * c-c++-common/simulate-thread/bitfields-2.c: New. * c-c++-common/simulate-thread/bitfields-3.c: New. * c-c++-common/simulate-thread/bitfields-4.c: New. Index: testsuite/lib/gcc-dg.exp =================================================================== --- testsuite/lib/gcc-dg.exp (revision 178608) +++ testsuite/lib/gcc-dg.exp (working copy) @@ -747,4 +747,26 @@ proc dg-message { args } { process-message saved-dg-warning "" $args } +# Check the existence of a gdb in the path, and return true if there +# is one. +# +# Set env(GDB_FOR_GCC_TESTING) accordingly. + +proc gdb-exists { args } { + if ![info exists ::env(GDB_FOR_GCC_TESTING)] { + global GDB + if ![info exists ::env(GDB_FOR_GCC_TESTING)] { + if [info exists GDB] { + setenv GDB_FOR_GCC_TESTING "$GDB" + } else { + setenv GDB_FOR_GCC_TESTING "[transform gdb]" + } + } + } + if { [which $::env(GDB_FOR_GCC_TESTING)] != 0 } { + return 1; + } + return 0; +} + set additional_prunes "" Index: testsuite/lib/gcc-simulate-thread.exp =================================================================== --- testsuite/lib/gcc-simulate-thread.exp (revision 0) +++ testsuite/lib/gcc-simulate-thread.exp (revision 0) @@ -0,0 +1,90 @@ +# Copyright (C) 2011 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 GCC; see the file COPYING3. If not see +# . + +# Utility for running a given test through the simulate-thread harness +# using gdb. This is invoked via dg-final. +# +# Adapted from the guality harness. +# +# Call 'fail' if a given test printed "FAIL:", otherwise call 'pass'. + +proc simulate-thread { args } { + if { ![isnative] || [is_remote target] } { return } + + if { [llength $args] == 1 } { + switch [dg-process-target [lindex $args 0]] { + "F" { setup_xfail "*-*-*" } + } + } + + # This assumes that we are three frames down from dg-test, and that + # it still stores the filename of the testcase in a local variable "name". + # A cleaner solution would require a new DejaGnu release. + upvar 2 name testcase + upvar 2 prog prog + upvar 2 srcdir testsuite_dir + + set gdb_name $::env(GDB_FOR_GCC_TESTING) + set exec_file "[file rootname [file tail $prog]].exe" + set cmd_file "$testsuite_dir/gcc.dg/simulate-thread/simulate-thread.gdb" + + if ![file exists $exec_file] { + return + } + + send_log "Spawning: $gdb_name -nx -nw -quiet -x $cmd_file ./$exec_file\n" + set res [remote_spawn target "$gdb_name -nx -nw -x $cmd_file ./$exec_file"] + if { $res < 0 || $res == "" } { + unsupported "$testcase" + return + } + + set gdb_worked 0 + remote_expect target [timeout_value] { + # Too old GDB + -re "Unhandled dwarf expression|Error in sourced command file" { + unsupported "$testcase" + remote_close target + return + } + -re "FAIL:" { + fail "$testcase" + remote_close target + return + } + # If the gdb output contained simulate_thread_main, assume + # that at the very least, we had a working gdb that was able + # to break in simulate_thread_main. + -re "simulate_thread_main" { + set gdb_worked 1 + exp_continue + } + timeout { + unsupported "$testcase" + remote_close target + return + } + } + + remote_close target + if {$gdb_worked} { + pass "$testcase" + } else { + # Fail in the absence of a sane GDB. + fail "$testcase" + } + return +} Index: testsuite/gcc.dg/simulate-thread/simulate-thread.exp =================================================================== --- testsuite/gcc.dg/simulate-thread/simulate-thread.exp (revision 0) +++ testsuite/gcc.dg/simulate-thread/simulate-thread.exp (revision 0) @@ -0,0 +1,38 @@ +# Copyright (C) 2011 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 GCC; see the file COPYING3. If not see +# . + +# Your run of the mill dg test, but verify that we have a working GDB first. + +load_lib gcc-dg.exp +load_lib gcc-simulate-thread.exp +load_lib torture-options.exp + +dg-init +torture-init +set-torture-options [list \ + { -O0 -g } \ + { -O1 -g } \ + { -O2 -g } \ + { -O3 -g } \ + { -Os -g } ] + +if [gdb-exists] { + gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.c]] "" + gcc-dg-runtest [lsort [glob $srcdir/c-c++-common/simulate-thread/*.c]] "" +} + +torture-finish +dg-finish Index: testsuite/gcc.dg/simulate-thread/simulate-thread.gdb =================================================================== --- testsuite/gcc.dg/simulate-thread/simulate-thread.gdb (revision 0) +++ testsuite/gcc.dg/simulate-thread/simulate-thread.gdb (revision 0) @@ -0,0 +1,17 @@ +set height 0 +break simulate_thread_main +disp/i $pc +run + +set $ret = 0 +while (simulate_thread_fini != 1) && (! $ret) + call simulate_thread_other_threads() + stepi + set $ret |= simulate_thread_step_verify() +end + +if (! $ret) + set $ret |= simulate_thread_final_verify() +end +continue +quit $ret Index: testsuite/gcc.dg/simulate-thread/README =================================================================== --- testsuite/gcc.dg/simulate-thread/README (revision 0) +++ testsuite/gcc.dg/simulate-thread/README (revision 0) @@ -0,0 +1,118 @@ +OVERVIEW +-------- + +This is a harness to test the atomicity of certain operations, and to +make sure the compiler does not introduce data races in a +multi-threaded environment. + +The basic premise is that we set up testcases such that the thing we +want test, say an atomic instruction which stores a double word is in +a function of its own. We then run this testcase within GDB, +controlled by a gdb script (simulate-thread.gdb). The gdb script will +break on the function to be tested, and then single step through every +machine instruction in the function. We set this up so GDB can make a +couple of inferior function calls before and after each of these +single step instructions for a couple of purposes: + + 1. One of the calls simulates another thread running in the + process which changes or access memory. + + 2. The other calls are used to verify that we always get the + expected behavior. + +For example, in the case of an atomic store, anyone looking at the +memory associated with an atomic variable should never see any in +between states. If you have an atomic long long int, and it starts +with the value 0, and you write the value MAX_LONG_LONG, any other +thread looking at that variable should never see anything other than 0 +or MAX_LONG_LONG. If you implement the atomic write as a sequence of +2 stores, it is possible for another thread to read the location after +the first store, but before the second one is complete. That thread +would then see an in-between state (one word would still be 0). + +We simulate this in the testcase by having GDB step through the +program, instruction by instruction, and after each step, making an +inferior function call which looks at the value of the atomic variable +and verifies that it sees either 0 or MAX_LONG_LONG. If it sees any +other value, it fails the testcase. + +This way, we are *sure* there is no in between state because we +effectively acted like an OS and switched to another thread after +every single instruction of the routine is executed and looked at the +results each time. + +We use the same idea to test for data races to see if an illegal load +has been hoisted, or that two parallel bitfield writes don't overlap +in a data race. + +Below is a skeleton of how a test should look like. For more details, +look at the tests themselves. + +ANATOMY OF A TEST +----------------- + +/* { dg-do link } */ +/* { dg-options "-some-flags" } */ +/* { dg-final { simulate-thread } } */ + +/* NOTE: Any failure must be indicated by displaying "FAIL:". */ + +#include "simulate-thread.h" + +/* Called before each instruction, simulating another thread executing. */ +void simulate_thread_other_threads() +{ +} + +/* Called after each instruction. Returns 1 if any inconsistency is + found, 0 otherwise. */ +int simulate_thread_step_verify() +{ + if (some_problem) + { + printf("FAIL: reason\n"); + return 1; + } + return 0; +} + +/* Called at the end of the program (simulate_thread_fini == 1). Verifies + the state of the program and returns 1 if any inconsistency is + found, 0 otherwise. */ +int simulate_thread_final_verify() +{ + if (some_problem) + { + printf("FAIL: reason\n"); + return 1; + } + return 0; +} + +/* The gdb script will break on simulate_thread_main(), so make sure + GCC does not inline it, thus making the break point fail. */ +__attribute__((noinline)) +void simulate_thread_main() +{ + /* Do stuff. */ +} + +int main() +{ + + /* Perform any setup code that will run outside of the testing + harness. Put code here that you do NOT want to be interrupted on + an instruction basis. E.g., setup code, and system library + calls. */ + + /* Do un-instrumented stuff. */ + /* ... */ + + /* Start the instrumented show. */ + simulate_thread_main(); + + /* Must be called at the end of the test. */ + simulate_thread_done(); + + return 0; +} Index: testsuite/gcc.dg/simulate-thread/simulate-thread.h =================================================================== --- testsuite/gcc.dg/simulate-thread/simulate-thread.h (revision 0) +++ testsuite/gcc.dg/simulate-thread/simulate-thread.h (revision 0) @@ -0,0 +1,7 @@ +int simulate_thread_fini = 0; + +void __attribute__((noinline)) +simulate_thread_done () +{ + simulate_thread_fini = 1; +} Index: testsuite/g++.dg/simulate-thread/simulate-thread.exp =================================================================== --- testsuite/g++.dg/simulate-thread/simulate-thread.exp (revision 0) +++ testsuite/g++.dg/simulate-thread/simulate-thread.exp (revision 0) @@ -0,0 +1,39 @@ +# Copyright (C) 2011 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 GCC; see the file COPYING3. If not see +# . + + +# Your run of the mill dg test, but verify that we have a working GDB first. + +load_lib g++-dg.exp +load_lib gcc-simulate-thread.exp +load_lib torture-options.exp + +dg-init +torture-init +set-torture-options [list \ + { -O0 -g } \ + { -O1 -g } \ + { -O2 -g } \ + { -O3 -g } \ + { -Os -g } ] + +if [gdb-exists] { + gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.C]] "" + gcc-dg-runtest [lsort [glob $srcdir/c-c++-common/simulate-thread/*.c]] "" +} + +torture-finish +dg-finish Index: testsuite/g++.dg/simulate-thread/simulate-thread.gdb =================================================================== --- testsuite/g++.dg/simulate-thread/simulate-thread.gdb (revision 0) +++ testsuite/g++.dg/simulate-thread/simulate-thread.gdb (revision 0) @@ -0,0 +1 @@ +source ../../gcc.dg/simulate-thread/simulate-thread.gdb Index: testsuite/g++.dg/simulate-thread/simulate-thread.h =================================================================== --- testsuite/g++.dg/simulate-thread/simulate-thread.h (revision 0) +++ testsuite/g++.dg/simulate-thread/simulate-thread.h (revision 0) @@ -0,0 +1 @@ +#include "../../gcc.dg/simulate-thread/simulate-thread.h" Index: testsuite/c-c++-common/simulate-thread/bitfields-1.c =================================================================== --- testsuite/c-c++-common/simulate-thread/bitfields-1.c (revision 0) +++ testsuite/c-c++-common/simulate-thread/bitfields-1.c (revision 0) @@ -0,0 +1,71 @@ +/* { dg-do link } */ +/* { dg-options "--param allow-store-data-races=0" } */ +/* { dg-final { simulate-thread } } */ + +#include +#include "../../gcc.dg/simulate-thread/simulate-thread.h" + +/* Test that we don't store past VAR.A. */ + +struct S +{ + volatile unsigned int a : 4; + unsigned char b; + unsigned int c : 6; +} var = { 1, 2, 3 }; + +static int global = 0; + +/* Called before each instruction, simulating another thread + executing. */ +void simulate_thread_other_threads() +{ + global++; + var.b = global; + /* Don't go past the 6 bits var.c can hold. */ + var.c = global % 64; +} + +/* Called after each instruction. Returns 1 if any inconsistency is + found, 0 otherwise. */ +int simulate_thread_step_verify() +{ + int ret = 0; + if (var.b != global) + { + printf("FAIL: invalid intermediate value for .\n"); + ret = 1; + } + if (var.c != global % 64) + { + printf("FAIL: invalid intermediate value for .\n"); + ret = 1; + } + return ret; +} + +/* Called at the end of the program (simulate_thread_fini == 1). Verifies + the state of the program and returns 1 if any inconsistency is + found, 0 otherwise. */ +int simulate_thread_final_verify() +{ + if (var.a != 12) + { + printf("FAIL: invalid final result for .\n"); + return 1; + } + return 0; +} + +__attribute__((noinline)) +void simulate_thread_main() +{ + var.a = 12; +} + +int main() +{ + simulate_thread_main(); + simulate_thread_done(); + return 0; +} Index: testsuite/c-c++-common/simulate-thread/bitfields-2.c =================================================================== --- testsuite/c-c++-common/simulate-thread/bitfields-2.c (revision 0) +++ testsuite/c-c++-common/simulate-thread/bitfields-2.c (revision 0) @@ -0,0 +1,59 @@ +/* { dg-do link } */ +/* { dg-options "--param allow-store-data-races=0" } */ +/* { dg-final { simulate-thread } } */ + +#include +#include "../../gcc.dg/simulate-thread/simulate-thread.h" + +/* Test that we don't store past VAR.K. */ + +struct S +{ + volatile int i; + volatile int j: 32; + volatile int k: 15; + volatile unsigned char c[2]; +} var; + +static int global = 0; + +void simulate_thread_other_threads() +{ + global++; + var.c[0] = global % 256; + var.c[1] = global % 256; +} + +int simulate_thread_step_verify() +{ + if (var.c[0] != global % 256 + || var.c[1] != global % 256) + { + printf("FAIL: invalid intermediate result for .\n"); + return 1; + } + return 0; +} + +int simulate_thread_final_verify() +{ + if (var.k != 13) + { + printf("FAIL: invalid final result\n"); + return 1; + } + return 0; +} + +__attribute__((noinline)) +void simulate_thread_main() +{ + var.k = 13; +} + +int main() +{ + simulate_thread_main(); + simulate_thread_done(); + return 0; +} Index: testsuite/c-c++-common/simulate-thread/bitfields-3.c =================================================================== --- testsuite/c-c++-common/simulate-thread/bitfields-3.c (revision 0) +++ testsuite/c-c++-common/simulate-thread/bitfields-3.c (revision 0) @@ -0,0 +1,63 @@ +/* { dg-do link } */ +/* { dg-options "--param allow-store-data-races=0" } */ +/* { dg-final { simulate-thread } } */ + +#include +#include "../../gcc.dg/simulate-thread/simulate-thread.h" + +/* Store into should not clobber . */ + +struct bits +{ + char a; + int b:7; + int c:9; + unsigned char d; +} var; + +static int global = 0; + +void simulate_thread_other_threads() +{ + global++; + var.d = global; +} + +int simulate_thread_step_verify() +{ + if (var.d != global) + { + printf("FAIL: invalid intermediate result\n"); + return 1; + } + return 0; +} + +int simulate_thread_final_verify() +{ + if (var.c != 5) + { + printf("FAIL: invalid final result\n"); + return 1; + } + return 0; +} + +__attribute__((noinline)) +void update_c(struct bits *p, int val) +{ + p -> c = val; +} + +__attribute__((noinline)) +void simulate_thread_main() +{ + update_c(&var, 5); +} + +int main() +{ + simulate_thread_main(); + simulate_thread_done(); + return 0; +} Index: testsuite/c-c++-common/simulate-thread/bitfields-4.c =================================================================== --- testsuite/c-c++-common/simulate-thread/bitfields-4.c (revision 0) +++ testsuite/c-c++-common/simulate-thread/bitfields-4.c (revision 0) @@ -0,0 +1,60 @@ +/* { dg-do link } */ +/* { dg-options "--param allow-store-data-races=0" } */ +/* { dg-final { simulate-thread } } */ + +#include +#include +#include "../../gcc.dg/simulate-thread/simulate-thread.h" + +struct bits +{ + char a; + int b:7; + int c:9; + unsigned char d; +} *p; + +static int global = 0; + +void simulate_thread_other_threads() +{ + global++; + p->d = global % 256; +} + +int simulate_thread_step_verify() +{ + if (p->d != global % 256) + { + printf("FAIL: invalid intermediate result\n"); + return 1; + } + return 0; +} + +int simulate_thread_final_verify() +{ + if (p->c != 55) + { + printf("FAIL: invalid final result\n"); + return 1; + } + return 0; +} + +/* Store into should not clobber . */ +/* We should not use a 32-bit move to store into p->, but a smaller move. */ +__attribute__((noinline)) +void simulate_thread_main() +{ + p -> c = 55; +} + + +int main() +{ + p = (struct bits *) calloc (1, sizeof (struct bits)); + simulate_thread_main(); + simulate_thread_done(); + return 0; +} Index: testsuite/c-c++-common/cxxbitfields-2.c =================================================================== --- testsuite/c-c++-common/cxxbitfields-2.c (revision 178608) +++ testsuite/c-c++-common/cxxbitfields-2.c (working copy) @@ -1,19 +0,0 @@ -/* { dg-do compile { target i?86-*-* x86_64-*-* } } */ -/* { dg-options "-O2 --param allow-store-data-races=0" } */ - -/* Test that we don't store past VAR.K. */ - -struct S -{ - volatile int i; - volatile int j: 32; - volatile int k: 15; - volatile char c[2]; -} var; - -void setit() -{ - var.k = 13; -} - -/* { dg-final { scan-assembler-not "movl.*, var" } } */ Index: testsuite/c-c++-common/cxxbitfields.c =================================================================== --- testsuite/c-c++-common/cxxbitfields.c (revision 178608) +++ testsuite/c-c++-common/cxxbitfields.c (working copy) @@ -1,18 +0,0 @@ -/* { dg-do compile { target i?86-*-* x86_64-*-* } } */ -/* { dg-options "-O2 --param allow-store-data-races=0" } */ - -/* Test that we don't store past VAR.A. */ - -struct S -{ - volatile unsigned int a : 4; - unsigned char b; - unsigned int c : 6; -} var; - -void set_a() -{ - var.a = 12; -} - -/* { dg-final { scan-assembler-not "movl.*, var" } } */ Index: testsuite/c-c++-common/cxxbitfields-4.c =================================================================== --- testsuite/c-c++-common/cxxbitfields-4.c (revision 178608) +++ testsuite/c-c++-common/cxxbitfields-4.c (working copy) @@ -1,18 +0,0 @@ -/* { dg-do compile { target i?86-*-* x86_64-*-* } } */ -/* { dg-options "-O2 --param allow-store-data-races=0" } */ - -struct bits -{ - char a; - int b:7; - int c:9; - unsigned char d; -} x; - -/* Store into should not clobber . */ -void update_c(struct bits *p, int val) -{ - p -> c = val; -} - -/* { dg-final { scan-assembler "mov\[bw\]" } } */ Index: testsuite/c-c++-common/cxxbitfields-5.c =================================================================== --- testsuite/c-c++-common/cxxbitfields-5.c (revision 178608) +++ testsuite/c-c++-common/cxxbitfields-5.c (working copy) @@ -1,29 +0,0 @@ -/* { dg-do compile { target i?86-*-* x86_64-*-* } } */ -/* { dg-options "-O2 --param allow-store-data-races=0" } */ - -#include - -struct bits -{ - char a; - int b:7; - int c:9; - unsigned char d; -} x; - -struct bits *p; - -static void allocit() -{ - p = (struct bits *) malloc (sizeof (struct bits)); -} - -/* Store into should not clobber . */ -/* We should not use a 32-bit move to store into p->, but a smaller move. */ -void foo() -{ - allocit(); - p -> c = 55; -} - -/* { dg-final { scan-assembler "mov\[bw\]" } } */