From patchwork Thu Dec 13 19:10:41 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Martin Sebor X-Patchwork-Id: 1013079 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=gcc.gnu.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=gcc-patches-return-492394-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="MyVjMyrO"; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.b="N5vqLqeM"; dkim-atps=neutral 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 43G3Dn41g4z9s3Z for ; Fri, 14 Dec 2018 06:11:05 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:to :from:subject:message-id:date:mime-version:content-type; q=dns; s=default; b=UqXE0aJU14MdS3xs/OVSjOLLbmLC7t6PrftZzZsuNNHLk4affJ IzyYs0/TpjvW2bBXIMVNaWH8lx3hnJwVT88ofgyUA3P59V3Bh6rJ4Ss0W3wGKqbu NYVQmJTyzzuL6Wpm4HYmAWHJWvkYItv2/a2dtvpf/9RCluhx7oJ0rkEBk= 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:to :from:subject:message-id:date:mime-version:content-type; s= default; bh=VRToacTaSa2xwTNu0SRXblbNJYM=; b=MyVjMyrO/LfGNaayWmOJ /MhOlwKbYjXtD6GW4GAEUq7TBlycjWY8jiaCiQQZ19zbeFVAcDH3v5d8PDo6ojMh PFdSFyJCO5TJVgdO+zBUN8LOx/JAFnMZ2QMtbHROJ1clQ1OwiB0TSpzoxL4//Gwf a2/TNXBjpanUi4Qh6VVw2Yc= Received: (qmail 44911 invoked by alias); 13 Dec 2018 19:10:57 -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 44896 invoked by uid 89); 13 Dec 2018 19:10:56 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-11.9 required=5.0 tests=BAYES_00, FREEMAIL_FROM, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.2 spammy=sta, guidelines, decimal, cv-qualifiers X-HELO: mail-qt1-f174.google.com Received: from mail-qt1-f174.google.com (HELO mail-qt1-f174.google.com) (209.85.160.174) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 13 Dec 2018 19:10:47 +0000 Received: by mail-qt1-f174.google.com with SMTP id l12so1530164qtf.8 for ; Thu, 13 Dec 2018 11:10:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=to:from:subject:message-id:date:user-agent:mime-version :content-language; bh=R25sECyFt5jfrvSZnGMQG2zEaRKk0tSWpKzmL16ZksI=; b=N5vqLqeMU/GSfZuoARm2cqCgl/8mtS9/iAocS/P6h78v84DdgPEHQtzHQIxCpxJyL4 5hHiWAb9cD/lHk7EE81Yi8LbsiZnUn0uqguM+f2ljZN6JbJe2ZHpxg7V/OTm0Ue5qCY9 Eb2Ao816c2l72LzFEGlWCUVIlsyqd9nmkHvpVjcO8maTrZhmYD2ySyavewQcDQ7Le7cA e10Lobwyrc5lWoEBNpWtZbGUryteiLpjKIyj5NmE8sjOGMcH52q+Poknpru+9e9Mavhl stLTa7ObrPNnxs+WGtolM40SyO318w8t6mmWsxMvzzw9Ls3dgDoK5s0Kw4rGDYyxsdtz /yHQ== Received: from localhost.localdomain ([97.118.99.160]) by smtp.gmail.com with ESMTPSA id k38sm1841089qkh.72.2018.12.13.11.10.43 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 13 Dec 2018 11:10:44 -0800 (PST) To: Sandra Loosemore , Gcc Patch List From: Martin Sebor Subject: [PATCH/doc] consistently use @code for const and volatile qualifiers Message-ID: <995449f4-2920-4f48-835b-57218ff338c9@gmail.com> Date: Thu, 13 Dec 2018 12:10:41 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.3.1 MIME-Version: 1.0 X-IsSubscribed: yes As we discussed, the manual isn't completely consistent in its use of @code for const and volatile qualifiers. I made a pass through extend.texi and added @code wherever it seemed to be missing. This doesn't mean all uses but only those that specifically refer to the qualifiers. In terms like "const function" or "volatile object" the terms "const" and "volatile" do not specifically refer to the qualifiers and so they don't get the @code. AFAICS, this is in line with existing usage in the manual and also in the C and C++ standard (though none is 100% consistent). While doing this, I also noticed similar inconsistencies in the quoting of the values true and false, and in references to the asm statement. There too the manual tends to use @code more often than not, so I made similar changes there. Here too I've left unchanged uses of the ordinary English words true or false. I made no other changes here so the churn is only the result of maintaining the 80 characters per line limit. If we're happy with this as the general rule of thumb to use in these cases I'll propose an update to the Coding Guidelines to capture it. Martin gcc/ChangeLog: * doc/extend.texi: Consistemtly use @code for const and volatile qualifiers and asm statements. Index: gcc/doc/extend.texi =================================================================== --- gcc/doc/extend.texi (revision 267103) +++ gcc/doc/extend.texi (working copy) @@ -8483,7 +8483,8 @@ All basic @code{asm} blocks are implicitly volatil @item inline If you use the @code{inline} qualifier, then for inlining purposes the size -of the asm is taken as the smallest size possible (@pxref{Size of an asm}). +of the @code{asm} statement is taken as the smallest size possible (@pxref{Size +of an asm}). @end table @subsubheading Parameters @@ -8629,7 +8630,8 @@ qualifier to disable certain optimizations. @xref{ @item inline If you use the @code{inline} qualifier, then for inlining purposes the size -of the asm is taken as the smallest size possible (@pxref{Size of an asm}). +of the @code{asm} statement is taken as the smallest size possible +(@pxref{Size of an asm}). @item goto This qualifier informs the compiler that the @code{asm} statement may @@ -8741,7 +8743,7 @@ void DoCheck(uint32_t dwSomeValue) The next example shows a case where the optimizers can recognize that the input (@code{dwSomeValue}) never changes during the execution of the function and can therefore move the @code{asm} outside the loop to produce more efficient code. -Again, using @code{volatile} disables this type of optimization. +Again, using the @code{volatile} qualifier disables this type of optimization. @example void do_print(uint32_t dwSomeValue) @@ -8797,11 +8799,11 @@ GCC's optimizers do not treat this code like the n earlier examples. They do not move it out of loops or omit it on the assumption that the result from a previous call is still valid. -Note that the compiler can move even volatile @code{asm} instructions relative +Note that the compiler can move even @code{volatile asm} instructions relative to other code, including across jump instructions. For example, on many targets there is a system register that controls the rounding mode of -floating-point operations. Setting it with a volatile @code{asm}, as in the -following PowerPC example, does not work reliably. +floating-point operations. Setting it with a @code{volatile asm} statement, +as in the following PowerPC example, does not work reliably. @example asm volatile("mtfsf 255, %0" : : "f" (fpenv)); @@ -8808,9 +8810,10 @@ asm volatile("mtfsf 255, %0" : : "f" (fpenv)); sum = x + y; @end example -The compiler may move the addition back before the volatile @code{asm}. To -make it work as expected, add an artificial dependency to the @code{asm} by -referencing a variable in the subsequent code, for example: +The compiler may move the addition back before the @code{volatile asm} +statement. To make it work as expected, add an artificial dependency to +the @code{asm} by referencing a variable in the subsequent code, for +example: @example asm volatile ("mtfsf 255,%1" : "=X" (sum) : "f" (fpenv)); @@ -8819,7 +8822,7 @@ sum = x + y; Under certain circumstances, GCC may duplicate (or remove duplicates of) your assembly code when optimizing. This can lead to unexpected duplicate symbol -errors during compilation if your asm code defines symbols or labels. +errors during compilation if your @code{asm} code defines symbols or labels. Using @samp{%=} (@pxref{AssemblerTemplate}) may help resolve this problem. @@ -8848,7 +8851,7 @@ that some assembler dialects use semicolons to sta Do not expect a sequence of @code{asm} statements to remain perfectly consecutive after compilation, even when you are using the @code{volatile} qualifier. If certain instructions need to remain consecutive in the output, -put them in a single multi-instruction asm statement. +put them in a single multi-instruction @code{asm} statement. Accessing data from C programs without using input/output operands (such as by using global symbols directly from the assembler template) may not work as @@ -9041,7 +9044,8 @@ The code generated by GCC to access the memory add registers which @emph{might} be shared by @var{a}, and GCC considers those registers to be inputs to the asm. As above, GCC assumes that such input registers are consumed before any outputs are written. This assumption may -result in incorrect behavior if the asm writes to @var{a} before using +result in incorrect behavior if the @code{asm} statement writes to @var{a} +before using @var{b}. Combining the @samp{&} modifier with the register constraint on @var{a} ensures that modifying @var{a} does not affect the address referenced by @var{b}. Otherwise, the location of @var{b} @@ -9123,8 +9127,8 @@ for @code{d} by specifying both constraints. Some targets have a special register that holds the ``flags'' for the result of an operation or comparison. Normally, the contents of that -register are either unmodifed by the asm, or the asm is considered to -clobber the contents. +register are either unmodifed by the asm, or the @code{asm} statement is +considered to clobber the contents. On some targets, a special form of output operand exists by which conditions in the flags register may be outputs of the asm. The set of @@ -10630,7 +10634,7 @@ That is, if the current value of @code{*@var{ptr}} is @var{oldval}, then write @var{newval} into @code{*@var{ptr}}. -The ``bool'' version returns true if the comparison is successful and +The ``bool'' version returns @code{true} if the comparison is successful and @var{newval} is written. The ``val'' version returns the contents of @code{*@var{ptr}} before the operation. @@ -10831,18 +10835,18 @@ This compares the contents of @code{*@var{ptr}} wi @code{*@var{expected}}. If equal, the operation is a @emph{read-modify-write} operation that writes @var{desired} into @code{*@var{ptr}}. If they are not equal, the operation is a @emph{read} and the current contents of -@code{*@var{ptr}} are written into @code{*@var{expected}}. @var{weak} is true -for weak compare_exchange, which may fail spuriously, and false for +@code{*@var{ptr}} are written into @code{*@var{expected}}. @var{weak} is @code{true} +for weak compare_exchange, which may fail spuriously, and @code{false} for the strong variation, which never fails spuriously. Many targets only offer the strong variation and ignore the parameter. When in doubt, use the strong variation. -If @var{desired} is written into @code{*@var{ptr}} then true is returned +If @var{desired} is written into @code{*@var{ptr}} then @code{true} is returned and memory is affected according to the memory order specified by @var{success_memorder}. There are no restrictions on what memory order can be used here. -Otherwise, false is returned and memory is affected according +Otherwise, @code{false} is returned and memory is affected according to @var{failure_memorder}. This memory order cannot be @code{__ATOMIC_RELEASE} nor @code{__ATOMIC_ACQ_REL}. It also cannot be a stronger order than that specified by @var{success_memorder}. @@ -10946,7 +10950,7 @@ All memory orders are valid. @deftypefn {Built-in Function} bool __atomic_always_lock_free (size_t size, void *ptr) -This built-in function returns true if objects of @var{size} bytes always +This built-in function returns @code{true} if objects of @var{size} bytes always generate lock-free atomic instructions for the target architecture. @var{size} must resolve to a compile-time constant and the result also resolves to a compile-time constant. @@ -10963,7 +10967,7 @@ if (__atomic_always_lock_free (sizeof (long long), @deftypefn {Built-in Function} bool __atomic_is_lock_free (size_t size, void *ptr) -This built-in function returns true if objects of @var{size} bytes always +This built-in function returns @code{true} if objects of @var{size} bytes always generate lock-free atomic instructions for the target architecture. If the built-in function is not known to be lock-free, a call is made to a runtime routine named @code{__atomic_is_lock_free}. @@ -10991,7 +10995,7 @@ These built-in functions promote the first two ope type and perform addition on those promoted operands. The result is then cast to the type the third pointer argument points to and stored there. If the stored result is equal to the infinite precision result, the built-in -functions return false, otherwise they return true. As the addition is +functions return @code{false}, otherwise they return @code{true}. As the addition is performed in infinite signed precision, these built-in functions have fully defined behavior for all argument values. @@ -11048,7 +11052,7 @@ than enumerated or boolean type. The built-in functions promote the first two operands into infinite precision signed type and perform addition on those promoted operands. The result is then cast to the type of the third argument. If the cast result is equal to the infinite -precision result, the built-in functions return false, otherwise they return true. +precision result, the built-in functions return @code{false}, otherwise they return @code{true}. The value of the third argument is ignored, just the side effects in the third argument are evaluated, and no integral argument promotions are performed on the last argument. If the third argument is a bit-field, the type used for the result cast has the @@ -12120,7 +12124,7 @@ integer constant expression, is nonzero. Otherwis This built-in function is analogous to the @samp{? :} operator in C, except that the expression returned has its type unaltered by promotion rules. Also, the built-in function does not evaluate the expression -that is not chosen. For example, if @var{const_exp} evaluates to true, +that is not chosen. For example, if @var{const_exp} evaluates to @code{true}, @var{exp2} is not evaluated even if it has side effects. This built-in function can return an lvalue if the chosen argument is an @@ -12306,7 +12310,7 @@ if (__builtin_expect (ptr != NULL, 1)) when testing pointer or floating-point values. For the purposes of branch prediction optimizations, the probability that -a @code{__builtin_expect} expression is true is controlled by GCC's +a @code{__builtin_expect} expression is @code{true} is controlled by GCC's @code{builtin-expect-probability} parameter, which defaults to 90%. You can also use @code{__builtin_expect_with_probability} to explicitly assign a probability value to individual expressions. @@ -14934,8 +14938,8 @@ Comparison of two paired-single values @code{bc1any2t}/@code{bc1any2f}). These functions compare @var{a} and @var{b} using @code{c.@var{cond}.ps} -or @code{cabs.@var{cond}.ps}. The @code{any} forms return true if either -result is true and the @code{all} forms return true if both results are true. +or @code{cabs.@var{cond}.ps}. The @code{any} forms return @code{true} if either +result is @code{true} and the @code{all} forms return @code{true} if both results are @code{true}. For example: @smallexample @@ -14961,8 +14965,8 @@ Comparison of four paired-single values These functions use @code{c.@var{cond}.ps} or @code{cabs.@var{cond}.ps} to compare @var{a} with @var{b} and to compare @var{c} with @var{d}. -The @code{any} forms return true if any of the four results are true -and the @code{all} forms return true if all four results are true. +The @code{any} forms return @code{true} if any of the four results are @code{true} +and the @code{all} forms return @code{true} if all four results are @code{true}. For example: @smallexample @@ -16126,7 +16130,8 @@ add 32. Hence these instructions only modify the changing the specified bit to a zero or one respectively. The @code{__builtin_set_fpscr_rn} builtin allows changing both of the floating point rounding mode bits. The argument is a 2-bit value. The argument can -either be a const int or stored in a variable. The builtin uses the ISA 3.0 +either be a @code{const int} or stored in a variable. The builtin uses +the ISA 3.0 instruction @code{mffscrn} if available, otherwise it reads the FPSCR, masks the current rounding mode bits out and OR's in the new value. @@ -16182,7 +16187,8 @@ unsigned long long __builtin_unpack_dec128 (_Decim The @code{__builtin_set_fpscr_drn} builtin allows changing the three decimal floating point rounding mode bits. The argument is a 3-bit value. The -argument can either be a const int or the value can be stored in a variable. +argument can either be a @code{const int} or the value can be stored in +a variable. The builtin uses the ISA 3.0 instruction @code{mffscdrn} if available. Otherwise the builtin reads the FPSCR, masks the current decimal rounding mode bits out and OR's in the new value. @@ -19573,7 +19579,7 @@ The HTM builtins (with the exception of @code{__bu the full 4-bit condition register value set by their associated hardware instruction. The header file @code{htmintrin.h} defines some macros that can be used to decipher the return value. The @code{__builtin_tbegin} builtin -returns a simple true or false value depending on whether a transaction was +returns a simple @code{true} or @code{false} value depending on whether a transaction was successfully started or not. The arguments of the builtins match exactly the type and order of the associated hardware instruction's operands, except for the @code{__builtin_tcheck} builtin, which does not take any input arguments. @@ -22533,15 +22539,15 @@ This pragma gives the C function @var{oldname} the is defined if this pragma is available (currently on all platforms). @end table -This pragma and the asm labels extension interact in a complicated +This pragma and the @code{asm} labels extension interact in a complicated manner. Here are some corner cases you may want to be aware of: @enumerate @item This pragma silently applies only to declarations with external -linkage. Asm labels do not have this restriction. +linkage. The @code{asm} label feature does not have this restriction. @item In C++, this pragma silently applies only to declarations with -``C'' linkage. Again, asm labels do not have this restriction. +``C'' linkage. Again, @code{asm} labels do not have this restriction. @item If either of the ways of changing the assembly name of a declaration are applied to a declaration whose assembly name has @@ -23924,130 +23930,143 @@ pair of types). @table @code @item __has_nothrow_assign (type) -If @code{type} is const qualified or is a reference type then the trait is -false. Otherwise if @code{__has_trivial_assign (type)} is true then the trait -is true, else if @code{type} is a cv class or union type with copy assignment -operators that are known not to throw an exception then the trait is true, -else it is false. Requires: @code{type} shall be a complete type, -(possibly cv-qualified) @code{void}, or an array of unknown bound. +If @code{type} is @code{const}-qualified or is a reference type then +the trait is @code{false}. Otherwise if @code{__has_trivial_assign (type)} +is @code{true} then the trait is @code{true}, else if @code{type} is +a cv-qualified class or union type with copy assignment operators that are +known not to throw an exception then the trait is @code{true}, else it is +@code{false}. +Requires: @code{type} shall be a complete type, (possibly cv-qualified) +@code{void}, or an array of unknown bound. @item __has_nothrow_copy (type) -If @code{__has_trivial_copy (type)} is true then the trait is true, else if -@code{type} is a cv class or union type with copy constructors that -are known not to throw an exception then the trait is true, else it is false. +If @code{__has_trivial_copy (type)} is @code{true} then the trait is +@code{true}, else if @code{type} is a cv-qualified class or union type +with copy constructors that are known not to throw an exception then +the trait is @code{true}, else it is @code{false}. Requires: @code{type} shall be a complete type, (possibly cv-qualified) @code{void}, or an array of unknown bound. @item __has_nothrow_constructor (type) -If @code{__has_trivial_constructor (type)} is true then the trait is -true, else if @code{type} is a cv class or union type (or array +If @code{__has_trivial_constructor (type)} is @code{true} then the trait +is @code{true}, else if @code{type} is a cv class or union type (or array thereof) with a default constructor that is known not to throw an -exception then the trait is true, else it is false. Requires: -@code{type} shall be a complete type, (possibly cv-qualified) +exception then the trait is @code{true}, else it is @code{false}. +Requires: @code{type} shall be a complete type, (possibly cv-qualified) @code{void}, or an array of unknown bound. @item __has_trivial_assign (type) -If @code{type} is const qualified or is a reference type then the trait is -false. Otherwise if @code{__is_pod (type)} is true then the trait is -true, else if @code{type} is a cv class or union type with a trivial -copy assignment ([class.copy]) then the trait is true, else it is -false. Requires: @code{type} shall be a complete type, (possibly -cv-qualified) @code{void}, or an array of unknown bound. +If @code{type} is @code{const}- qualified or is a reference type then +the trait is @code{false}. Otherwise if @code{__is_pod (type)} is +@code{true} then the trait is @code{true}, else if @code{type} is +a cv-qualified class or union type with a trivial copy assignment +([class.copy]) then the trait is @code{true}, else it is @code{false}. +Requires: @code{type} shall be a complete type, (possibly cv-qualified) +@code{void}, or an array of unknown bound. @item __has_trivial_copy (type) -If @code{__is_pod (type)} is true or @code{type} is a reference type -then the trait is true, else if @code{type} is a cv class or union type -with a trivial copy constructor ([class.copy]) then the trait -is true, else it is false. Requires: @code{type} shall be a complete -type, (possibly cv-qualified) @code{void}, or an array of unknown bound. +If @code{__is_pod (type)} is @code{true} or @code{type} is a reference +type then the trait is @code{true}, else if @code{type} is a cv class +or union type with a trivial copy constructor ([class.copy]) then the trait +is @code{true}, else it is @code{false}. Requires: @code{type} shall be +a complete type, (possibly cv-qualified) @code{void}, or an array of unknown +bound. @item __has_trivial_constructor (type) -If @code{__is_pod (type)} is true then the trait is true, else if -@code{type} is a cv class or union type (or array thereof) with a -trivial default constructor ([class.ctor]) then the trait is true, -else it is false. Requires: @code{type} shall be a complete -type, (possibly cv-qualified) @code{void}, or an array of unknown bound. +If @code{__is_pod (type)} is @code{true} then the trait is @code{true}, +else if @code{type} is a cv-qualified class or union type (or array thereof) +with a trivial default constructor ([class.ctor]) then the trait is @code{true}, +else it is @code{false}. +Requires: @code{type} shall be a complete type, (possibly cv-qualified) +@code{void}, or an array of unknown bound. @item __has_trivial_destructor (type) -If @code{__is_pod (type)} is true or @code{type} is a reference type then -the trait is true, else if @code{type} is a cv class or union type (or -array thereof) with a trivial destructor ([class.dtor]) then the trait -is true, else it is false. Requires: @code{type} shall be a complete -type, (possibly cv-qualified) @code{void}, or an array of unknown bound. +If @code{__is_pod (type)} is @code{true} or @code{type} is a reference type +then the trait is @code{true}, else if @code{type} is a cv class or union +type (or array thereof) with a trivial destructor ([class.dtor]) then +the trait is @code{true}, else it is @code{false}. +Requires: @code{type} shall be a complete type, (possibly cv-qualified) +@code{void}, or an array of unknown bound. @item __has_virtual_destructor (type) If @code{type} is a class type with a virtual destructor -([class.dtor]) then the trait is true, else it is false. Requires: -@code{type} shall be a complete type, (possibly cv-qualified) +([class.dtor]) then the trait is @code{true}, else it is @code{false}. +Requires: @code{type} shall be a complete type, (possibly cv-qualified) @code{void}, or an array of unknown bound. @item __is_abstract (type) If @code{type} is an abstract class ([class.abstract]) then the trait -is true, else it is false. Requires: @code{type} shall be a complete -type, (possibly cv-qualified) @code{void}, or an array of unknown bound. +is @code{true}, else it is @code{false}. +Requires: @code{type} shall be a complete type, (possibly cv-qualified) +@code{void}, or an array of unknown bound. @item __is_base_of (base_type, derived_type) If @code{base_type} is a base class of @code{derived_type} -([class.derived]) then the trait is true, otherwise it is false. -Top-level cv qualifications of @code{base_type} and +([class.derived]) then the trait is @code{true}, otherwise it is @code{false}. +Top-level cv-qualifications of @code{base_type} and @code{derived_type} are ignored. For the purposes of this trait, a -class type is considered is own base. Requires: if @code{__is_class -(base_type)} and @code{__is_class (derived_type)} are true and -@code{base_type} and @code{derived_type} are not the same type -(disregarding cv-qualifiers), @code{derived_type} shall be a complete +class type is considered is own base. +Requires: if @code{__is_class (base_type)} and @code{__is_class (derived_type)} +are @code{true} and @code{base_type} and @code{derived_type} are not the same +type (disregarding cv-qualifiers), @code{derived_type} shall be a complete type. A diagnostic is produced if this requirement is not met. @item __is_class (type) -If @code{type} is a cv class type, and not a union type -([basic.compound]) the trait is true, else it is false. +If @code{type} is a cv-qualified class type, and not a union type +([basic.compound]) the trait is @code{true}, else it is @code{false}. @item __is_empty (type) -If @code{__is_class (type)} is false then the trait is false. +If @code{__is_class (type)} is @code{false} then the trait is @code{false}. Otherwise @code{type} is considered empty if and only if: @code{type} has no non-static data members, or all non-static data members, if any, are bit-fields of length 0, and @code{type} has no virtual members, and @code{type} has no virtual base classes, and @code{type} has no base classes @code{base_type} for which -@code{__is_empty (base_type)} is false. Requires: @code{type} shall -be a complete type, (possibly cv-qualified) @code{void}, or an array -of unknown bound. +@code{__is_empty (base_type)} is @code{false}. +Requires: @code{type} shall be a complete type, (possibly cv-qualified) +@code{void}, or an array of unknown bound. @item __is_enum (type) If @code{type} is a cv enumeration type ([basic.compound]) the trait is -true, else it is false. +@code{true}, else it is @code{false}. @item __is_literal_type (type) If @code{type} is a literal type ([basic.types]) the trait is -true, else it is false. Requires: @code{type} shall be a complete type, -(possibly cv-qualified) @code{void}, or an array of unknown bound. +@code{true}, else it is @code{false}. +Requires: @code{type} shall be a complete type, (possibly cv-qualified) +@code{void}, or an array of unknown bound. @item __is_pod (type) -If @code{type} is a cv POD type ([basic.types]) then the trait is true, -else it is false. Requires: @code{type} shall be a complete type, -(possibly cv-qualified) @code{void}, or an array of unknown bound. +If @code{type} is a cv POD type ([basic.types]) then the trait is @code{true}, +else it is @code{false}. +Requires: @code{type} shall be a complete type, (possibly cv-qualified) +@code{void}, or an array of unknown bound. @item __is_polymorphic (type) If @code{type} is a polymorphic class ([class.virtual]) then the trait -is true, else it is false. Requires: @code{type} shall be a complete -type, (possibly cv-qualified) @code{void}, or an array of unknown bound. +is @code{true}, else it is @code{false}. +Requires: @code{type} shall be a complete type, (possibly cv-qualified) +@code{void}, or an array of unknown bound. @item __is_standard_layout (type) If @code{type} is a standard-layout type ([basic.types]) the trait is -true, else it is false. Requires: @code{type} shall be a complete -type, (possibly cv-qualified) @code{void}, or an array of unknown bound. +@code{true}, else it is @code{false}. +Requires: @code{type} shall be a complete type, (possibly cv-qualified) +@code{void}, or an array of unknown bound. @item __is_trivial (type) If @code{type} is a trivial type ([basic.types]) the trait is -true, else it is false. Requires: @code{type} shall be a complete -type, (possibly cv-qualified) @code{void}, or an array of unknown bound. +@code{true}, else it is @code{false}. +Requires: @code{type} shall be a complete type, (possibly cv-qualified) +@code{void}, or an array of unknown bound. @item __is_union (type) If @code{type} is a cv union type ([basic.compound]) the trait is -true, else it is false. +@code{true}, else it is @code{false}. @item __underlying_type (type) -The underlying type of @code{type}. Requires: @code{type} shall be -an enumeration type ([dcl.enum]). +The underlying type of @code{type}. +Requires: @code{type} shall be an enumeration type ([dcl.enum]). @item __integer_pack (length) When used as the pattern of a pack expansion within a template @@ -24098,7 +24117,7 @@ likely to be removed in the future. @table @code @item __is_same (type1, type2) -A binary type trait: true whenever the type arguments are the same. +A binary type trait: @code{true} whenever the type arguments are the same. @end table