From patchwork Thu Mar 26 13:21:47 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jonathan Wakely X-Patchwork-Id: 455055 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]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 7793B1400A0 for ; Fri, 27 Mar 2015 00:22:10 +1100 (AEDT) Authentication-Results: ozlabs.org; dkim=pass reason="1024-bit key; unprotected key" header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b=RH0tyXDi; dkim-adsp=none (unprotected policy); dkim-atps=neutral DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:cc:subject:message-id:references:mime-version :content-type:in-reply-to; q=dns; s=default; b=X6I5Pux6m16vEgBAv 238Bup4N0NJkx6TOS+y8bYd9Qa+aADf8R3fYnJMAalFlj1inLN7FUPKEG+EGhT0J vwOsxdUiJpeJ2nAcjNEOTtJtRHUGpWviNissHW8bgeksDTs+mDSoXNb+WL6MH662 2V/TcOR07fXTyVsa3AR1tPl4Rc= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:cc:subject:message-id:references:mime-version :content-type:in-reply-to; s=default; bh=TS3MwJzgQsKJu5DpHjX2181 ag4Y=; b=RH0tyXDiTTXuwksJzuYaNHxSIi6IlHZPqardAscGdumoKN1bJ+prV/v TO9vhxRFd5LALT+GatrhDbwtXUl8OFXEvMTQT+FiZxtRNssB+Z5oU+borL7I2LDs eIiRZda2e8phrr+7XX9U4bXBOwBjpRqg3kAMmScSk/XFqF1LqhG4= Received: (qmail 126663 invoked by alias); 26 Mar 2015 13:21:54 -0000 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 Received: (qmail 126640 invoked by uid 89); 26 Mar 2015 13:21:53 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.0 required=5.0 tests=AWL, BAYES_00, SPF_HELO_PASS, SPF_PASS, T_RP_MATCHES_RCVD autolearn=ham version=3.3.2 X-Spam-User: qpsmtpd, 2 recipients X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-GCM-SHA384 encrypted) ESMTPS; Thu, 26 Mar 2015 13:21:51 +0000 Received: from int-mx10.intmail.prod.int.phx2.redhat.com (int-mx10.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id t2QDLnm5004815 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL); Thu, 26 Mar 2015 09:21:49 -0400 Received: from localhost (ovpn-116-96.ams2.redhat.com [10.36.116.96]) by int-mx10.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id t2QDLmij000713; Thu, 26 Mar 2015 09:21:49 -0400 Date: Thu, 26 Mar 2015 13:21:47 +0000 From: Jonathan Wakely To: Richard Henderson Cc: libstdc++@gcc.gnu.org, gcc-patches@gcc.gnu.org, Andrew MacLeod Subject: Re: [libstdc++/65033] Give alignment info to libatomic Message-ID: <20150326132147.GL9755@redhat.com> References: <54DD19B7.6060401@redhat.com> <20150218121512.GI3360@redhat.com> <20150325162244.GF9755@redhat.com> <5513003D.3040107@redhat.com> <20150325184913.GH9755@redhat.com> <551306C1.6060702@redhat.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <551306C1.6060702@redhat.com> User-Agent: Mutt/1.5.23 (2014-03-12) On 25/03/15 12:04 -0700, Richard Henderson wrote: >On 03/25/2015 11:49 AM, Jonathan Wakely wrote: >> On 25/03/15 11:36 -0700, Richard Henderson wrote: >>> On 03/25/2015 09:22 AM, Jonathan Wakely wrote: >> On 25/03/15 11:39 -0700, Richard Henderson wrote: >>> On 03/25/2015 09:22 AM, Jonathan Wakely wrote: >>>> +static_assert( alignof(std::atomic) > alignof(int), >>>> + "std::atomic not suitably aligned" ); >>> >>> This is only true if int64_t has alignment larger than int32_t, >>> which is unfortunately not always the case. >> >> Huh, didn't realise that. I could change the tests to check it's >> alignof(std::int64_t) as the next assertion does, but is it safe to >> assume that struct twoints { int a; int b; } is exactly 64 bits >> everywhere? > >Certainly not. But if you're going to explicitly use int64_t elsewhere, you >might as well explicitly use int32_t as well. Then I believe you can >reasonably assert > > alignof(twoint32) == alignof(int64_t) Yes, that makes sense, thanks. Here's what I plan to commit then. This includes your fix to avoid decreasing alignment, but I didn't add a test for that as I couldn't make it fail on any of the targets I test on. commit f796769ad20c0353490b9f1a7e019e2f0c1771fb Author: Jonathan Wakely Date: Wed Sep 3 15:39:53 2014 +0100 PR libstdc++/62259 PR libstdc++/65147 * include/std/atomic (atomic): Increase alignment for types with the same size as one of the integral types. * testsuite/29_atomics/atomic/60695.cc: Adjust dg-error line number. * testsuite/29_atomics/atomic/62259.cc: New. diff --git a/libstdc++-v3/include/std/atomic b/libstdc++-v3/include/std/atomic index 1a17427..42244bd 100644 --- a/libstdc++-v3/include/std/atomic +++ b/libstdc++-v3/include/std/atomic @@ -165,7 +165,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION struct atomic { private: - _Tp _M_i; + // Align 1/2/4/8/16-byte types the same as integer types of that size. + // This matches the alignment effects of the C11 _Atomic qualifier. + static constexpr int _S_min_alignment + = sizeof(_Tp) == sizeof(char) ? alignof(char) + : sizeof(_Tp) == sizeof(short) ? alignof(short) + : sizeof(_Tp) == sizeof(int) ? alignof(int) + : sizeof(_Tp) == sizeof(long) ? alignof(long) + : sizeof(_Tp) == sizeof(long long) ? alignof(long long) +#ifdef _GLIBCXX_USE_INT128 + : sizeof(_Tp) == sizeof(__int128) ? alignof(__int128) +#endif + : 0; + + static constexpr int _S_alignment + = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp); + + alignas(_S_alignment) _Tp _M_i; static_assert(__is_trivially_copyable(_Tp), "std::atomic requires a trivially copyable type"); diff --git a/libstdc++-v3/testsuite/29_atomics/atomic/60695.cc b/libstdc++-v3/testsuite/29_atomics/atomic/60695.cc index b59c6ba..6f618a0 100644 --- a/libstdc++-v3/testsuite/29_atomics/atomic/60695.cc +++ b/libstdc++-v3/testsuite/29_atomics/atomic/60695.cc @@ -27,4 +27,4 @@ struct X { char stuff[0]; // GNU extension, type has zero size }; -std::atomic a; // { dg-error "not supported" "" { target *-*-* } 173 } +std::atomic a; // { dg-error "not supported" "" { target *-*-* } 189 } diff --git a/libstdc++-v3/testsuite/29_atomics/atomic/62259.cc b/libstdc++-v3/testsuite/29_atomics/atomic/62259.cc new file mode 100644 index 0000000..cf5423a --- /dev/null +++ b/libstdc++-v3/testsuite/29_atomics/atomic/62259.cc @@ -0,0 +1,58 @@ +// Copyright (C) 2015 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library 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, or (at your option) +// any later version. + +// This library 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 library; see the file COPYING3. If not see +// . + +// { dg-require-atomic-builtins "" } +// { dg-require-cstdint "" } +// { dg-options "-std=gnu++11" } +// { dg-do compile } + +#include +#include + +using std::int32_t; +using std::int64_t; + +// libstdc++/62259 + +struct twoints { + int32_t a; + int32_t b; +}; + +static_assert( alignof(std::atomic) == alignof(int64_t), + "std::atomic not suitably aligned" ); + +// libstdc++/65147 + +struct power_of_two_obj { + char c [8]; +}; + +std::atomic obj1; + +static_assert( alignof(obj1) == alignof(int64_t), + "std::atomic not suitably aligned" ); + +struct container_struct { + char c[1]; + std::atomic ao; +}; + +container_struct obj2; + +static_assert( alignof(obj2.ao) == alignof(int64_t), + "std::atomic not suitably aligned" );