gcc-10 - en to unknown language translation catalogue (910 entries)

en:     -n, --normalize <int64_t>           Normalize the profile
target:     -n, --normalize <int64_t>           Normalise the profile

en:   -dumpspecs               Display all of the built in spec strings.
target:   -dumpspecs               Display all of the built-in spec strings.

en:   -j, --human-readable            Output human readable numbers
target:   -j, --human-readable            Output human-readable numbers

en:   -k, --use-colors                Emit colored output
target:   -k, --use-colors                Emit coloured output

en:   -no-canonical-prefixes   Do not canonicalize paths when building relative
                               prefixes to other gcc components.
target:   -no-canonical-prefixes   Do not canonicalise paths when building relative
                               prefixes to other gcc components.

en:   -print-multiarch         Display the target's normalized GNU triplet, used as
                               a component in the library path.
target:   -print-multiarch         Display the target's normalised GNU triplet, used as
                               a component in the library path.

en:   -q, --use-hotness-colors        Emit perf-like colored output for hot lines
target:   -q, --use-hotness-colors        Emit perf-like coloured output for hot lines

en:   -w, --verbose                   Print verbose informations
target:   -w, --verbose                   Print verbose information

en:   -x <language>            Specify the language of the following input files.
                               Permissible languages include: c c++ assembler none
                               'none' means revert to the default behavior of
                               guessing the language based on the file's extension.
target:   -x <language>            Specify the language of the following input files.
                               Permissible languages include: c c++ assembler none
                               'none' means revert to the default behaviour of
                               guessing the language based on the file's extension.

en:   an inherited constructor is not a candidate for initialization from an expression of the same or derived type
target:   an inherited constructor is not a candidate for initialisation from an expression of the same or derived type

en:   as it is a non-system directory that duplicates a system directory
target:   as it is a non-system duplicate of a system directory

en:   conversion from return type %qT of template conversion function specialization to %qT is not an exact match
target:   conversion from return type %qT of template conversion function specialisation to %qT is not an exact match

en:   crosses initialization of %q#D
target:   crosses initialisation of %q#D

en:   enters synchronized or atomic statement
target:   enters synchronised or atomic statement

en:   initializing argument %P of %qD
target:   initialising argument %P of %qD

en:   skips initialization of %q#D
target:   skips initialisation of %q#D

en:   when initialized here
target:   when initialised here

en:  None found.  Use --help=%s to show *all* the options supported by the %s front-end.
target:  None found.  Use --help=%s to show *all* the options supported by the %s frontend.

en: %<#pragma omp declare reduction%> initializer refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>
target: %<#pragma omp declare reduction%> initialiser refers to variable %qD which is not %<omp_priv%> nor %<omp_orig%>

en: %<%.*s%> directive precision out of range
target: %<%.*s%> directive precision out-of-range

en: %<%.*s%> directive width out of range
target: %<%.*s%> directive width out-of-range

en: %<-gnat%> misspelled as %<-gant%>
target: %<-gnat%> misspelt as %<-gant%>

en: %<.%s%> designator used multiple times in the same initializer list
target: %<.%s%> designator used multiple times in the same initialiser list

en: %<...%> not allowed in designated initializer list
target: %<...%> not allowed in designated initialiser list

en: %<[%E] =%> used in a GNU-style designated initializer for class %qT
target: %<[%E] =%> used in a GNU-style designated initialiser for class %qT

en: %<__auto_type%> requires an initialized data declaration
target: %<__auto_type%> requires an initialised data declaration

en: %<__auto_type%> used with a bit-field initializer
target: %<__auto_type%> used with a bit-field initialiser

en: %<constexpr%> constructor for union %qT must initialize exactly one non-static data member
target: %<constexpr%> constructor for union %qT must initialise exactly one non-static data member

en: %<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type
target: %<constexpr%> needed for in-class initialisation of static data member %q#D of non-integral type

en: %<constexpr%> static data member %qD must have an initializer
target: %<constexpr%> static data member %qD must have an initialiser

en: %<constinit%> variable %qD does not have a constant initializer
target: %<constinit%> variable %qD does not have a constant initialiser

en: %<custom-%s=%> is not recognized as FPU instruction
target: %<custom-%s=%> is not recognised as FPU instruction

en: %<inline%> is not allowed in declaration of friend template specialization %qD
target: %<inline%> is not allowed in declaration of friend template specialisation %qD

en: %<weakref%> attribute ignored because variable is initialized
target: %<weakref%> attribute ignored because variable is initialised

en: %G%qD forming offset %s is out of bounds
target: %G%qD forming offset %s is out-of-bounds

en: %G%qD offset %s is out of bounds
target: %G%qD offset %s is out-of-bounds

en: %q#D is a static data member; it can only be initialized at its definition
target: %q#D is a static data member; it can only be initialised at its definition

en: %q#D should be initialized
target: %q#D should be initialised

en: %qD copying an object of type %#qT with %qs member %qD from an array of %#qT; use assignment or copy-initialization instead
target: %qD copying an object of type %#qT with %qs member %qD from an array of %#qT; use assignment or copy-initialisation instead

en: %qD declared as reference but not initialized
target: %qD declared as reference but not initialised

en: %qD is initialized with itself
target: %qD is initialised with itself

en: %qD is used uninitialized in this function
target: %qD is used uninitialised in this function

en: %qD may be used uninitialized in this function
target: %qD may be used uninitialised in this function

en: %qD should be initialized
target: %qD should be initialised

en: %qD should be initialized in the member initialization list
target: %qD should be initialised in the member initialisation list

en: %qD used in its own initializer
target: %qD used in its own initialiser

en: %qD was not initialized with a constant expression
target: %qD was not initialised with a constant expression

en: %qD will be initialized after
target: %qD will be initialised after

en: %qE attribute applies only to initialized variables with external linkage
target: %qE attribute applies only to initialised variables with external linkage

en: %qE has both %<extern%> and initializer
target: %qE has both %<extern%> and initialiser

en: %qE initialized and declared %<extern%>
target: %qE initialised and declared %<extern%>

en: %qE is an unrecognized format function type
target: %qE is an unrecognised format function type

en: %qE is not a constant expression because it refers to an incompletely initialized variable
target: %qE is not a constant expression because it refers to an incompletely initialised variable

en: %qE is not initialized
target: %qE is not initialised

en: %qE is used uninitialized in this function
target: %qE is used uninitialised in this function

en: %qE may be used uninitialized in this function
target: %qE may be used uninitialised in this function

en: %qc directive redundant after prior occurence of the same
target: %qc directive redundant after prior occurrence of the same

en: %qs appears to be a misspelled %qs handler, missing %<__vector%> prefix
target: %qs appears to be a misspelt %qs handler, missing %<__vector%> prefix

en: %qs at %L already is initialized at %L
target: %qs at %L already is initialised at %L

en: %qs entity cannot have an initializer at %C
target: %qs entity cannot have an initialiser at %C

en: %qs has both %<extern%> and initializer
target: %qs has both %<extern%> and initialiser

en: %qs initialized and declared %<extern%>
target: %qs initialised and declared %<extern%>

en: %s%swarning: %s header version %s differs from library version %s.
target: %s%s warning: %s header version %s differs from library version %s.

en: %s: couldn%'t open PCH file: %m
target: %s: could not open PCH file: %m

en: %s:'%s' has arcs from exit block
target: %s: '%s' has arcs from exit block

en: %s:'%s' has arcs to entry block
target: %s: '%s' has arcs to entry block

en: %s:'%s' lacks entry and/or exit blocks
target: %s: '%s' lacks entry and/or exit blocks

en: %s:already seen blocks for '%s'
target: %s: already seen blocks for '%s'

en: %s:cannot open data file, assuming not executed
target: %s: cannot open data file, assuming not executed

en: %s:cannot open notes file
target: %s: cannot open notes file

en: %s:corrupted
target: %s: corrupted

en: %s:graph is unsolvable for '%s'
target: %s: graph is unsolvable for '%s'

en: %s:no functions found
target: %s: no functions found

en: %s:no lines for '%s'
target: %s: no lines for '%s'

en: %s:not a gcov data file
target: %s: not a gcov data file

en: %s:not a gcov notes file
target: %s: not a gcov notes file

en: %s:overflowed
target: %s: overflowed

en: %s:profile mismatch for '%s'
target: %s: profile mismatch for '%s'

en: %s:source file is newer than notes file '%s'
target: %s: source file is newer than notes file '%s'

en: %s:stamp mismatch with notes file
target: %s: stamp mismatch with notes file

en: %s:version '%.4s', prefer '%.4s'
target: %s: version '%.4s', prefer '%.4s'

en: %s:version '%.4s', prefer version '%.4s'
target: %s: version '%.4s', prefer version '%.4s'

en: '%%l' operand isn't a label
target: '%%l' operand is not a label

en: (C)
target: ©

en: (an out of class initialization is required)
target: (an out of class initialisation is required)

en: (near initialization for %qs)
target: (near initialisation for %qs)

en: (static initializers for %s)
target: (static initialisers for %s)

en: --help=<class>	Display descriptions of a specific class of options.  <class> is one or more of optimizers, target, warnings, undocumented, params.
target: --help=<class>	Display descriptions of a specific class of options.  <class> is one or more of optimisers, target, warnings, undocumented, params.

en: --param=parloops-schedule=[static|dynamic|guided|auto|runtime]	Schedule type of omp schedule for loops parallelized by parloops.
target: --param=parloops-schedule=[static|dynamic|guided|auto|runtime]	Schedule type of omp schedule for loops parallelised by parloops.

en: -O<number>	Set optimization level to <number>.
target: -O<number>	Set optimisation level to <number>.

en: -Wnormalized=[none|id|nfc|nfkc]	Warn about non-normalized Unicode strings.
target: -Wnormalized=[none|id|nfc|nfkc]	Warn about non-normalised Unicode strings.

en: -fcoarray=<none|single|lib>	Specify which coarray parallelization should be used.
target: -fcoarray=<none|single|lib>	Specify which coarray parallelisation should be used.

en: -fdiagnostics-color=[never|always|auto]	Colorize diagnostics.
target: -fdiagnostics-color=[never|always|auto]	Colourise diagnostics.

en: -fdisable-[tree|rtl|ipa]-<pass>=range1+range2	Disable an optimization pass.
target: -fdisable-[tree|rtl|ipa]-<pass>=range1+range2	Disable an optimisation pass.

en: -fenable-[tree|rtl|ipa]-<pass>=range1+range2	Enable an optimization pass.
target: -fenable-[tree|rtl|ipa]-<pass>=range1+range2	Enable an optimisation pass.

en: -fgo-optimize-<type>	Turn on optimization passes in the frontend.
target: -fgo-optimize-<type>	Turn on optimisation passes in the frontend.

en: -finit-character=<n>	Initialize local character variables to ASCII value n.
target: -finit-character=<n>	Initialise local character variables to ASCII value n.

en: -finit-integer=<n>	Initialize local integer variables to n.
target: -finit-integer=<n>	Initialise local integer variables to n.

en: -finit-logical=<true|false>	Initialize local logical variables.
target: -finit-logical=<true|false>	Initialise local logical variables.

en: -finit-real=<zero|snan|nan|inf|-inf>	Initialize local real variables.
target: -finit-real=<zero|snan|nan|inf|-inf>	Initialise local real variables.

en: -flive-patching=[inline-only-static|inline-clone]	Control IPA optimizations to provide a safe compilation for live-patching.  At the same time, provides multiple-level control on the enabled IPA optimizations.
target: -flive-patching=[inline-only-static|inline-clone]	Control IPA optimisations to provide a safe compilation for live-patching.  At the same time, provides multiple-level control on the enabled IPA optimisations.

en: -fno-threadsafe-statics	Do not generate thread-safe code for initializing local statics.
target: -fno-threadsafe-statics	Do not generate thread-safe code for initialising local statics.

en: -fopt-info[-<type>=filename]	Dump compiler optimization details.
target: -fopt-info[-<type>=filename]	Dump compiler optimisation details.

en: -fsanitize-sections=<sec1,sec2,...>	Sanitize global variables in user-defined sections.
target: -fsanitize-sections=<sec1,sec2,...>	Sanitise global variables in user-defined sections.

en: -fsimd-cost-model=[unlimited|dynamic|cheap]	Specifies the vectorization cost model for code marked with a simd directive.
target: -fsimd-cost-model=[unlimited|dynamic|cheap]	Specifies the vectorisation cost model for code marked with a simd directive.

en: -ftree-parallelize-loops=<number>	Enable automatic parallelization of loops.
target: -ftree-parallelize-loops=<number>	Enable automatic parallelisation of loops.

en: -fvect-cost-model=[unlimited|dynamic|cheap]	Specifies the cost model for vectorization.
target: -fvect-cost-model=[unlimited|dynamic|cheap]	Specifies the cost model for vectorisation.

en: -mno-serialize-volatile	Do not serialize volatile memory references with MEMW instructions.
target: -mno-serialize-volatile	Do not serialise volatile memory references with MEMW instructions.

en: -moverride=<string>	Power users only! Override CPU optimization parameters.
target: -moverride=<string>	Power users only! Override CPU optimisation parameters.

en: -mtune=PROCESSOR	Optimize the output for PROCESSOR.
target: -mtune=PROCESSOR	Optimise the output for PROCESSOR.

en: -weak_reference_mismatches <treatment>	Specifies what to do if a symbol import conflicts between file (weak in one and not in another) the default is to treat the symbol as non-weak.
target: -weak_reference_mismatches <treatment>	Specifies what to do if a symbol import conflicts between file (weak in one and not in another). The default is to treat the symbol as non-weak.

en: ; use assignment or value-initialization instead
target: ; use assignment or value-initialisation instead

en: ; use copy-assignment or copy-initialization instead
target: ; use copy-assignment or copy-initialisation instead

en: ; use copy-initialization instead
target: ; use copy-initialisation instead

en: ; use value-initialization instead
target: ; use value-initialisation instead

en: <During initialization>
target: <During initialisation>

en: <brace-enclosed initializer list>
target: <brace-enclosed initialiser list>

en: A floatig point to integer truncation may be replaced with rounding to save mode switching.
target: A floating point to integer truncation may be replaced with rounding to save mode switching.

en: AUX pointer initialized for edge %d->%d
target: AUX pointer initialised for edge %d->%d

en: Add a common subexpression elimination pass after loop optimizations.
target: Add a common subexpression elimination pass after loop optimisations.

en: After diagnosing undefined behavior attempt to continue execution.
target: After diagnosing undefined behaviour, attempt to continue execution.

en: Aggressively optimize loops using language constraints.
target: Aggressively optimise loops using language constraints.

en: Allocatable %qs at %L cannot have an initializer
target: Allocatable %qs at %L cannot have an initialiser

en: Allow interposing function (or variables) by ones with different semantics (or initializer) respectively by dynamic linker.
target: Allow interposing function (or variables) by ones with different semantics (or initialiser) respectively by dynamic linker.

en: Allow math optimizations that may violate IEEE or ISO standards.
target: Allow math optimisations that may violate IEEE or ISO standards.

en: Allow optimization for floating-point arithmetic which may change the result of the operation due to rounding.
target: Allow optimisation for floating-point arithmetic which may change the result of the operation due to rounding.

en: Analyze and remove doubleword swaps from VSX computations.
target: Analyse and remove doubleword swaps from VSX computations.

en: Analyzed alias has no reference
target: Analysed alias has no reference

en: Array in initializer list at %L must have an explicit shape
target: Array in initialiser list at %L must have an explicit shape

en: Array reference at %L is out of bounds (%ld < %ld) in codimension %d
target: Array reference at %L is out-of-bounds (%ld < %ld) in codimension %d

en: Array reference at %L is out of bounds (%ld < %ld) in dimension %d
target: Array reference at %L is out-of-bounds (%ld < %ld) in dimension %d

en: Array reference at %L is out of bounds (%ld > %ld) in codimension %d
target: Array reference at %L is out-of-bounds (%ld > %ld) in codimension %d

en: Array reference at %L is out of bounds (%ld > %ld) in dimension %d
target: Array reference at %L is out-of-bounds (%ld > %ld) in dimension %d

en: Array reference at %L out of bounds (%ld < %ld) in loop beginning at %L
target: Array reference at %L out-of-bounds (%ld < %ld) in loop beginning at %L

en: Array reference at %L out of bounds (%ld > %ld) in loop beginning at %L
target: Array reference at %L out-of-bounds (%ld > %ld) in loop beginning at %L

en: Array reference out of bounds
target: Array reference out-of-bounds

en: Assume we are finalizing for phsa and its libhsail-rt.  Enables additional phsa-specific optimizations (default).
target: Assume we are finalising for phsa and its libhsail-rt.  Enables additional phsa-specific optimisations (default).

en: Assumed shape array %qs at %L is not permitted in an initialization expression
target: Assumed shape array %qs at %L is not permitted in an initialisation expression

en: Assumed size array %qs at %L is not permitted in an initialization expression
target: Assumed size array %qs at %L is not permitted in an initialisation expression

en: Assumed-shape array %qs at %L is not permitted in an initialization expression
target: Assumed-shape array %qs at %L is not permitted in an initialisation expression

en: Attempting to allocate already allocated variable
target: Attempting to allocate an alread-allocated variable

en: Automatic array %qs at %L cannot have an initializer
target: Automatic array %qs at %L cannot have an initialiser

en: BOZ literal constant at %L cannot appear as an initializer
target: BOZ literal constant at %L cannot appear as an initialiser

en: BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialization
target: BOZ literal constant near %L cannot be assigned to a %qs variable in an old-style initialisation

en: Bound on number of candidates below that all candidates are considered in iv optimizations.
target: Bound on number of candidates below that all candidates are considered in iv optimisations.

en: Bound on number of iv uses in loop optimized in iv optimizations.
target: Bound on number of iv uses in loop optimised in iv optimisations.

en: Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check.
target: Bound on number of runtime checks inserted by the vectoriser's loop versioning for alias check.

en: Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check.
target: Bound on number of runtime checks inserted by the vectoriser's loop versioning for alignment check.

en: Bound on size of expressions used in the scalar evolutions analyzer.
target: Bound on size of expressions used in the scalar evolutions analyser.

en: Bound on the complexity of the expressions in the scalar evolutions analyzer.
target: Bound on the complexity of the expressions in the scalar evolutions analyser.

en: C++ designated initializers only available with %<-std=c++2a%> or %<-std=gnu++2a%>
target: C++ designated initialisers only available with %<-std=c++2a%> or %<-std=gnu++2a%>

en: C++11 %<thread_local%> allows dynamic initialization and destruction
target: C++11 %<thread_local%> allows dynamic initialisation and destruction

en: C99 designator %qE outside aggregate initializer
target: C99 designator %qE outside aggregate initialiser

en: Cannot initialize implied-shape array at %L with scalar
target: Cannot initialise implied-shape array at %L with scalar

en: Cannot initialize parameter array at %L with variable length elements
target: Cannot initialise parameter array at %L with variable length elements

en: Chunk size of omp schedule for loops parallelized by parloops.
target: Chunk size of omp schedule for loops parallelised by parloops.

en: Clear the BSS to zero and place zero initialized in BSS.
target: Clear the BSS to zero and place zero initialised in BSS.

en: Compile with 32 bit longs and pointers, which is the only supported behavior and thus the flag is ignored.
target: Compile with 32 bit longs and pointers, which is the only supported behaviour and thus the flag is ignored.

en: Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar
target: Component %qs at %L with coarray component shall be a nonpointer, non-allocatable scalar

en: Component %qs is initialized twice in the structure constructor at %L
target: Component %qs is initialised twice in the structure constructor at %L

en: Component initializer without name after component named %s at %L
target: Component initialiser without name after component named %s at %L

en: Conflicting initializers in union at %L and %L
target: Conflicting initialisers in union at %L and %L

en: Cost at which GCSE optimizations will not constraint the distance an expression can travel.
target: Cost at which GCSE optimisations will not constrain the distance an expression can travel.

en: DIM argument at %L is out of bounds
target: DIM argument at %L is out-of-bounds

en: Declaring method %qD final would enable devirtualization of %i call | Declaring method %qD final would enable devirtualization of %i calls
target[0]: Declaring method %qD final would enable devirtualisation of %i call
target[1]: Declaring method %qD final would enable devirtualisation of %i calls

en: Declaring method %qD final would enable devirtualization of %i call executed %lli times | Declaring method %qD final would enable devirtualization of %i calls executed %lli times
target[0]: Declaring method %qD final would enable devirtualisation of %i call executed %lli times
target[1]: Declaring method %qD final would enable devirtualisation of %i calls executed %lli times

en: Declaring type %qD final would enable devirtualization of %i call | Declaring type %qD final would enable devirtualization of %i calls
target[0]: Declaring type %qD final would enable devirtualisation of %i call
target[1]: Declaring type %qD final would enable devirtualisation of %i calls

en: Declaring type %qD final would enable devirtualization of %i call executed %lli times | Declaring type %qD final would enable devirtualization of %i calls executed %lli times
target[0]: Declaring type %qD final would enable devirtualisation of %i call executed %lli times
target[1]: Declaring type %qD final would enable devirtualisation of %i calls executed %lli times

en: Declaring virtual destructor of %qD final would enable devirtualization of %i call | Declaring virtual destructor of %qD final would enable devirtualization of %i calls
target[0]: Declaring virtual destructor of %qD final would enable devirtualisation of %i call
target[1]: Declaring virtual destructor of %qD final would enable devirtualisation of %i calls

en: Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times | Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times
target[0]: Declaring virtual destructor of %qD final would enable devirtualisation of %i call executed %lli times
target[1]: Declaring virtual destructor of %qD final would enable devirtualisation of %i calls executed %lli times

en: Deferred array %qs at %L is not permitted in an initialization expression
target: Deferred array %qs at %L is not permitted in an initialisation expression

en: Deprecated in favor of -std=c++11.
target: Deprecated in favour of -std=c++11.

en: Deprecated in favor of -std=c++14.
target: Deprecated in favour of -std=c++14.

en: Deprecated in favor of -std=c++17.
target: Deprecated in favour of -std=c++17.

en: Deprecated in favor of -std=c11.
target: Deprecated in favour of -std=c11.

en: Deprecated in favor of -std=c99.
target: Deprecated in favour of -std=c99.

en: Deprecated in favor of -std=gnu++11.
target: Deprecated in favour of -std=gnu++11.

en: Deprecated in favor of -std=gnu++14.
target: Deprecated in favour of -std=gnu++14.

en: Deprecated in favor of -std=gnu++17.
target: Deprecated in favour of -std=gnu++17.

en: Deprecated in favor of -std=gnu11.
target: Deprecated in favour of -std=gnu11.

en: Deprecated in favor of -std=gnu99.
target: Deprecated in favour of -std=gnu99.

en: Deprecated in favor of -std=iso9899:1999.
target: Deprecated in favour of -std=iso9899:1999.

en: Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON
target: Derived type variable %qs at %L with default initialisation cannot be in EQUIVALENCE with a variable in COMMON

en: Derived type variable %qs in COMMON at %L may not have default initializer
target: Derived type variable %qs in COMMON at %L may not have default initialiser

en: Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer
target: Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initialiser

en: Detect paths that trigger erroneous or undefined behavior due to a null value being used in a way forbidden by a returns_nonnull or nonnull attribute.  Isolate those paths from the main control flow and turn the statement with erroneous or undefined behavior into a trap.
target: Detect paths that trigger erroneous or undefined behaviour due to a null value being used in a way forbidden by a returns_nonnull or nonnull attribute.  Isolate those paths from the main control flow and turn the statement with erroneous or undefined behaviour into a trap.

en: Detect paths that trigger erroneous or undefined behavior due to dereferencing a null pointer.  Isolate those paths from the main control flow and turn the statement with erroneous or undefined behavior into a trap.
target: Detect paths that trigger erroneous or undefined behaviour due to dereferencing a null pointer.  Isolate those paths from the main control flow and turn the statement with erroneous or undefined behaviour into a trap.

en: Dimensions specified for %s at %L after its initialization
target: Dimensions specified for %s at %L after its initialisation

en: Disable Scalar to Vector optimization pass transforming 64-bit integer computations into a vector ones.
target: Disable Scalar to Vector optimisation pass transforming 64-bit integer computations into a vector ones.

en: Disable floating point optimizations that ignore the IEEE signedness of zero.
target: Disable floating point optimisations that ignore the IEEE signedness of zero.

en: Disable optimizations observable by IEEE signaling NaNs.
target: Disable optimisations observable by IEEE signalling NaNs.

en: Disable optimizations that assume default FP rounding behavior.
target: Disable optimisations that assume default FP rounding behaviour.

en: Disallow tail call optimization when a calling routine may have omitted character lengths.
target: Disallow tail call optimisation when a calling routine may have omitted character lengths.

en: Display the code tree after front end optimization.
target: Display the code tree after frontend optimisation.

en: Do CFG-sensitive rematerialization in LRA.
target: Do CFG-sensitive rematerialisation in LRA.

en: Do alignment optimizations for call instructions.
target: Do alignment optimisations for call instructions.

en: Do not perform optimizations increasing noticeably stack usage.
target: Do not perform optimisations increasing noticeably stack usage.

en: Do not pretty-print template specializations as the template signature followed by the arguments.
target: Do not pretty-print template specialisations as the template signature followed by the arguments.

en: Don't optimize block moves, use memcpy.
target: Don't optimise block moves, use memcpy.

en: Don't optimize block moves.
target: Don't optimise block moves.

en: Dummy %qs at %L cannot have an initializer
target: Dummy %qs at %L cannot have an initialiser

en: Dummy procedure %qs is invalid in procedure pointer initialization at %L
target: Dummy procedure %qs is invalid in procedure pointer initialisation at %L

en: Dump analyzer-specific call graph information to a SRCFILE.callgraph.dot file.
target: Dump analyser-specific call graph information to a SRCFILE.callgraph.dot file.

en: Dump optimization passes.
target: Dump optimisation passes.

en: Dump the analyzer exploded graph to a SRCFILE.eg.dot file.
target: Dump the analyser exploded graph to a SRCFILE.eg.dot file.

en: Dump the analyzer supergraph to a SRCFILE.supergraph.dot file.
target: Dump the analyser supergraph to a SRCFILE.supergraph.dot file.

en: Dump various analyzer internals to SRCFILE.analyzer.txt.
target: Dump various analyser internals to SRCFILE.analyzer.txt.

en: Dump various analyzer internals to stderr.
target: Dump various analyser internals to stderr.

en: During link time optimization warn about mismatched types of global declarations.
target: During link time optimisation warn about mismatched types of global declarations.

en: ENUMERATOR %L not initialized with integer expression
target: ENUMERATOR %L not initialised with integer expression

en: Elemental function as initialization expression with non-integer/non-character arguments at %L
target: Elemental function as initialisation expression with non-integer/non-character arguments at %L

en: Emit optimization diagnostics.
target: Emit optimisation diagnostics.

en: Empty old style initializer list at %C
target: Empty old style initialiser list at %C

en: Enable Objective-C exception and synchronization syntax.
target: Enable Objective-C exception and synchronisation syntax.

en: Enable SSA dead code elimination optimization on trees.
target: Enable SSA dead code elimination optimisation on trees.

en: Enable SSA-BIT-CCP optimization on trees.
target: Enable SSA-BIT-CCP optimisation on trees.

en: Enable SSA-CCP optimization on trees.
target: Enable SSA-CCP optimisation on trees.

en: Enable SSA-PRE optimization on trees.
target: Enable SSA-PRE optimisation on trees.

en: Enable all optimization info dumps on stderr.
target: Enable all optimisation info dumps on stderr.

en: Enable basic block vectorization (SLP) on trees.
target: Enable basic block vectorisation (SLP) on trees.

en: Enable common options for generating profile info for profile feedback directed optimizations, and set -fprofile-dir=.
target: Enable common options for generating profile info for profile feedback directed optimisations, and set -fprofile-dir=.

en: Enable common options for generating profile info for profile feedback directed optimizations.
target: Enable common options for generating profile info for profile feedback directed optimisations.

en: Enable common options for performing profile feedback directed optimizations, and set -fprofile-dir=.
target: Enable common options for performing profile feedback directed optimisations, and set -fprofile-dir=.

en: Enable common options for performing profile feedback directed optimizations.
target: Enable common options for performing profile feedback directed optimisations.

en: Enable dominator optimizations.
target: Enable dominator optimisations.

en: Enable front end optimization.
target: Enable frontend optimisation.

en: Enable generation of compare and set flag with immediate (l.sf*i) instructions. By default extra instructions will be generated to store the immediate to a register first.
target: Enable generation of compare and set flag with immediate (l.sf*i) instructions. By default, extra instructions will be generated to store the immediate to a register first.

en: Enable generation of conditional move (l.cmov) instructions.  By default the equivalent will be generated using set and branch.
target: Enable generation of conditional move (l.cmov) instructions.  By default, the equivalent will be generated using set and branch.

en: Enable generation of rotate right (l.ror) instructions.  By default functions from libgcc are used to perform rotate right operations.
target: Enable generation of rotate right (l.ror) instructions.  By default, functions from libgcc are used to perform rotate right operations.

en: Enable generation of rotate right with immediate (l.rori) instructions.  By default functions from libgcc are used to perform rotate right with immediate operations.
target: Enable generation of rotate right with immediate (l.rori) instructions.  By default, functions from libgcc are used to perform rotate right with immediate operations.

en: Enable generation of shift with immediate (l.srai, l.srli, l.slli) instructions. By default extra instructions will be generated to store the immediate to a register first.
target: Enable generation of shift with immediate (l.srai, l.srli, l.slli) instructions. By default, extra instructions will be generated to store the immediate to a register first.

en: Enable generation of sign extension (l.ext*) instructions.  By default memory loads are used to perform sign extension.
target: Enable generation of sign extension (l.ext*) instructions.  By default, memory loads are used to perform sign extension.

en: Enable label alignment optimizations.
target: Enable label alignment optimisations.

en: Enable link-time optimization.
target: Enable link-time optimisation.

en: Enable linker optimizations.
target: Enable linker optimisations.

en: Enable loop epilogue vectorization using smaller vector size.
target: Enable loop epilogue vectorisation using smaller vector size.

en: Enable loop optimizations on tree level.
target: Enable loop optimisations on tree level.

en: Enable loop vectorization on trees.
target: Enable loop vectorisation on trees.

en: Enable machine specific peephole optimizations.
target: Enable machine specific peephole optimisations.

en: Enable nested conditional execution optimizations.
target: Enable nested conditional execution optimisations.

en: Enable optimizing &&/|| in conditional execution.
target: Enable optimising &&/|| in conditional execution.

en: Enable string length optimizations on trees.
target: Enable string length optimisations on trees.

en: Enable the loop nest optimizer.
target: Enable the loop nest optimiser.

en: Enable vectorization on trees.
target: Enable vectorisation on trees.

en: Enables the dynamic vectorizer cost model.  Preserved for backward compatibility.
target: Enables the dynamic vectoriser cost model.  Preserved for backward compatibility.

en: End of scalar initializer expected at %C
target: End of scalar initialiser expected at %C

en: Error in pointer initialization at %C
target: Error in pointer initialisation at %C

en: Evaluation of nonstandard initialization expression at %L
target: Evaluation of nonstandard initialisation expression at %L

en: Expected a right parenthesis in expression at %C
target: Expected a right bracket (parenthesis) in expression at %C

en: Expected an initialization expression at %C
target: Expected an initialisation expression at %C

en: Expected initialization expression at %C
target: Expected initialisation expression at %C

en: Expected initialization expression in CASE at %C
target: Expected initialisation expression in CASE at %C

en: Expected left parenthesis
target: Expected left bracket (parenthesis)

en: Expected right parenthesis
target: Expected right bracket (parenthesis)

en: Expected scalar initialization expression at %C
target: Expected scalar initialisation expression at %C

en: Extension: Unary operator following arithmetic operator (use parentheses) at %C
target: Extension: Unary operator following arithmetic operator (use brackets) at %C

en: External %qs at %L cannot have an initializer
target: External %qs at %L cannot have an initialiser

en: External object %qs at %L may not have an initializer
target: External object %qs at %L may not have an initialiser

en: Factor complex constructors and destructors to favor space over speed.
target: Factor complex constructors and destructors to favour space over speed.

en: Fine grain control of tune features.
target: Fine-grain control of tune features.

en: Forbid performing fp-as-gp optimization.
target: Forbid performing fp-as-gp optimisation.

en: Forbid using $fp to access static and global variables.  This option strictly forbids fp-as-gp optimization regardless of '-mforce-fp-as-gp'.
target: Forbid using $fp to access static and global variables.  This option strictly forbids fp-as-gp optimisation, regardless of '-mforce-fp-as-gp'.

en: Force performing fp-as-gp optimization.
target: Force performing fp-as-gp optimisation.

en: Function %qs as initialization expression at %L
target: Function %qs as initialisation expression at %L

en: Function %qs at %L cannot have an initializer
target: Function %qs at %L cannot have an initialiser

en: Function %qs in initialization expression at %L must be an intrinsic function
target: Function %qs in initialisation expression at %L must be an intrinsic function

en: Function result %qs at %L cannot have an initializer
target: Function result %qs at %L cannot have an initialiser

en: Garbage after PARAMETERIZED TYPE declaration at %C
target: Garbage after PARAMETERISED TYPE declaration at %C

en: Generate inline floating point division, optimize for latency.
target: Generate inline floating point division, optimise for latency.

en: Generate inline floating point division, optimize for throughput.
target: Generate inline floating point division, optimise for throughput.

en: Generate inline integer division, optimize for latency.
target: Generate inline integer division, optimise for latency.

en: Generate inline integer division, optimize for throughput.
target: Generate inline integer division, optimise for throughput.

en: Generate inline square root, optimize for latency.
target: Generate inline square root, optimise for latency.

en: Generate inline square root, optimize for throughput.
target: Generate inline square root, optimise for throughput.

en: Generate mcount/__fentry__ calls as nops. To activate they need to be patched in.
target: Generate mcount/__fentry__ calls as nops. To activate, they need to be patched in.

en: Generate special Objective-C methods to initialize/destroy non-POD C++ ivars, if needed.
target: Generate special Objective-C methods to initialise/destroy non-POD C++ ivars, if needed.

en: Graphite loop optimizations cannot be used (isl is not available) (%<-fgraphite%>, %<-fgraphite-identity%>, %<-floop-nest-optimize%>, %<-floop-parallelize-all%>)
target: Graphite loop optimisations cannot be used (isl is not available) (%<-fgraphite%>, %<-fgraphite-identity%>, %<-floop-nest-optimize%>, %<-floop-parallelize-all%>)

en: Graphite loop optimizations cannot be used (isl is not available).
target: Graphite loop optimisations cannot be used (isl is not available).

en: ISO C forbids empty initializer braces
target: ISO C forbids empty initialiser braces

en: ISO C forbids initialization between function pointer and %<void *%>
target: ISO C forbids initialisation between function pointer and %<void *%>

en: ISO C forbids specifying range of elements to initialize
target: ISO C forbids specifying range of elements to initialise

en: ISO C++ does not allow C99 designated initializers
target: ISO C++ does not allow C99 designated initialisers

en: ISO C++ does not allow GNU designated initializers
target: ISO C++ does not allow GNU designated initialisers

en: ISO C++ forbids in-class initialization of non-const static member %qD
target: ISO C++ forbids in-class initialisation of non-const static member %qD

en: ISO C++ forbids initialization of member constant %qD of non-integral type %qT
target: ISO C++ forbids initialisation of member constant %qD of non-integral type %qT

en: ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to member function.  Say %<&%T::%D%>
target: ISO C++ forbids taking the address of an unqualified or parenthesised non-static member function to form a pointer to member function.  Say %<&%T::%D%>

en: ISO C90 forbids specifying subobject to initialize
target: ISO C90 forbids specifying subobject to initialise

en: If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization.
target: If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorisation.

en: If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization.
target: If number of candidates in the set is smaller, we always try to remove unused ivs during its optimisation.

en: Implied SAVE for module variable %qs at %L, needed due to the default initialization
target: Implied SAVE for module variable %qs at %L, needed due to the default initialisation

en: In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s
target: In Fortran 2003, COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s

en: In SSA-PRE optimization on trees, enable partial-partial redundancy elimination.
target: In SSA-PRE optimisation on trees, enable partial-partial redundancy elimination.

en: In a pure subprogram an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type if the derived type has a pointer component at any level of component selection.
target: In a pure subprogram, an INTENT(IN) dummy argument shall not be used as the expr at %L of an intrinsic assignment statement in which the variable is of a derived type, if the derived type has a pointer component at any level of component selection.

en: Incompatible initialization between a derived type entity and an entity with %qs type at %C
target: Incompatible initialisation between a derived type entity and an entity with %qs type at %C

en: Index in dimension %d is out of bounds at %L
target: Index in dimension %d is out-of-bounds at %L

en: Initialization at %C is not allowed in a PURE procedure
target: Initialisation at %C is not allowed in a PURE procedure

en: Initialization at %C isn't for a pointer variable
target: Initialisation at %C isn't for a pointer variable

en: Initialization of allocatable component at %C is not allowed
target: Initialisation of allocatable component at %C is not allowed

en: Initialization of pointer at %C is not allowed in a PURE procedure
target: Initialisation of pointer at %C is not allowed in a PURE procedure

en: Initialization of structure component with a HOLLERITH constant at %L is not allowed
target: Initialisation of structure component with a HOLLERITH constant at %L is not allowed

en: Initialization of variable at %C is not allowed in a PURE procedure
target: Initialisation of variable at %C is not allowed in a PURE procedure

en: Initialization string at %L was truncated to fit the variable (%ld/%ld)
target: Initialisation string at %L was truncated to fit the variable (%ld/%ld)

en: Initialize components of derived type variables according to other init flags.
target: Initialise components of derived type variables according to other init flags.

en: Initialize local variables to zero (from g77).
target: Initialise local variables to zero (from g77).

en: Initialized symbol %qs at %C can only be COMMON in BLOCK DATA
target: Initialised symbol %qs at %C can only be COMMON in BLOCK DATA

en: Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks
target: Initialised variable %qs at %L is in a blank COMMON but initialisation is only allowed in named common blocks

en: Initializer not allowed for PARAMETER %qs at %C
target: Initialiser not allowed for PARAMETER %qs at %C

en: Initializing already initialized variable at %C
target: Initialising already-initialised variable at %C

en: Internal procedure %qs is invalid in procedure pointer initialization at %L
target: Internal procedure %qs is invalid in procedure pointer initialisation at %L

en: Interval in which to probe the stack expressed as a power of two in bytes.
target: Interval in which to probe the stack expressed as a power of two, in bytes.

en: Intrinsic %qs at %L cannot have an initializer
target: Intrinsic %qs at %L cannot have an initialiser

en: Intrinsic function %qs (%d) not recognized
target: Intrinsic function %qs (%d) not recognised

en: Intrinsic function %qs at %L is not permitted in an initialization expression
target: Intrinsic function %qs at %L is not permitted in an initialisation expression

en: Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L
target: Invalid initialisation expression for ALLOCATABLE component %qs in structure constructor at %L

en: Invalid initializer %s in Data statement at %C
target: Invalid initialiser %s in Data statement at %C

en: Invalid old style initialization for derived type component at %C
target: Invalid old style initialisation for derived type component at %C

en: KIND parameter of %s at %L must be an initialization expression
target: KIND parameter of %s at %L must be an initialisation expression

en: Known vectorization library ABIs (for use with the -mveclibabi= option):
target: Known vectorisation library ABIs (for use with the -mveclibabi= option):

en: Label %qs at %C doesn't match IF label %qs
target: Label %qs at %C does not match IF label %qs

en: Labeled DO statement at %L
target: Labelled DO statement at %L

en: Letters must be in alphabetic order in IMPLICIT statement at %C
target: Letters must be in alphabetical order in IMPLICIT statement at %C

en: Level not found, use none, slim, blocks, vops.
target: Level not found, use: none, slim, blocks, vops.

en: Link-time optimization with number of parallel jobs or jobserver.
target: Link-time optimisation with number of parallel jobs or jobserver.

en: Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d
target: Lower array reference at %L is out-of-bounds (%ld < %ld) in dimension %d

en: Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d
target: Lower array reference at %L is out-of-bounds (%ld > %ld) in dimension %d

en: MMIX Internal: This is not a recognized address
target: MMIX Internal: This is not a recognised address

en: Maximum depth of sqrt chains to use when synthesizing exponentiation by a real constant.
target: Maximum depth of sqrt chains to use when synthesising exponentiation by a real constant.

en: Maximum length of partial antic set when performing tree pre optimization.
target: Maximum length of partial antic set when performing tree pre-optimisation.

en: Maximum number of instructions in basic block to be considered for SLP vectorization.
target: Maximum number of instructions in basic block to be considered for SLP vectorisation.

en: Maximum number of may-defs visited when devirtualizing speculatively.
target: Maximum number of may-defs visited when devirtualising speculatively.

en: Maximum number of nested calls to search for control dependencies during uninitialized variable analysis.
target: Maximum number of nested calls to search for control dependencies during uninitialised variable analysis.

en: Maximum number of strings for which strlen optimization pass will track string lengths.
target: Maximum number of strings for which strlen optimisation pass will track string lengths.

en: Maximum size, in storage units, of an aggregate which should be considered for scalarization when compiling for size.
target: Maximum size, in storage units, of an aggregate which should be considered for scalarisation when compiling for size.

en: Maximum size, in storage units, of an aggregate which should be considered for scalarization when compiling for speed.
target: Maximum size, in storage units, of an aggregate which should be considered for scalarisation when compiling for speed.

en: Minimum number of iterations per thread of an innermost parallelized loop.
target: Minimum number of iterations per thread of an innermost parallelised loop.

en: Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initializer at %L
target: Missing INITIALIZER clause for !$OMP DECLARE REDUCTION of derived type without default initialiser at %L

en: Missing required parentheses before BIND(C) at %C
target: Missing required brackets (parentheses) before BIND(C) at %C

en: Missing right parenthesis at %C
target: Missing right bracket (parenthesis) at %C

en: Missing right parenthesis or comma at %C
target: Missing right bracket (parenthesis) or comma at %C

en: NULL() initialization at %C is ambiguous
target: NULL() initialisation at %C is ambiguous

en: NULL() initialization at %C may not have MOLD
target: NULL() initialisation at %C may not have MOLD

en: No initializer for allocatable component %qs given in the structure constructor at %C
target: No initialiser for allocatable component %qs given in the structure constructor at %C

en: No initializer for component %qs given in the structure constructor at %C
target: No initialiser for component %qs given in the structure constructor at %C

en: Noninteger exponent in an initialization expression at %L
target: Noninteger exponent in an initialisation expression at %L

en: Nonnegative width required in format string at %L
target: Non-negative width required in format string at %L

en: Nonpointer object %qs with default initialization shall not appear in a DATA statement at %L
target: Nonpointer object %qs with default initialisation shall not appear in a DATA statement at %L

en: Not enough elements in array initializer at %C
target: Not enough elements in array initialiser at %C

en: Old-style initialization at %C
target: Old-style initialisation at %C

en: Optimize amount of stdarg registers saved to stack at start of function.
target: Optimise amount of stdarg registers saved to stack at start of function.

en: Optimize conditional patterns using SSA PHI nodes.
target: Optimise conditional patterns using SSA PHI nodes.

en: Optimize for CPU.
target: Optimise for CPU.

en: Optimize for debugging experience rather than speed or size.
target: Optimise for debugging experience rather than speed or size.

en: Optimize for space rather than speed.
target: Optimise for space rather than speed.

en: Optimize for speed disregarding exact standards compliance.
target: Optimise for speed disregarding exact standards compliance.

en: Optimize frame header.
target: Optimise frame header.

en: Optimize induction variables on trees.
target: Optimise induction variables on trees.

en: Optimize lui/addiu address loads.
target: Optimise lui/addiu address loads.

en: Optimize opcode sizes at link time.
target: Optimise opcode sizes at link time.

en: Optimize partition neutering.
target: Optimise partition neutering.

en: Optimize sibling and tail recursive calls.
target: Optimise sibling and tail recursive calls.

en: Optimize tail call instructions in assembler and linker.
target: Optimise tail call instructions in assembler and linker.

en: Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)
target: Out-of-bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)

en: Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)
target: Out-of-bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)

en: Overlapping unequal initializers in EQUIVALENCE at %C
target: Overlapping unequal initialisers in EQUIVALENCE at %C

en: Overlapping unequal initializers in EQUIVALENCE at %L
target: Overlapping unequal initialisers in EQUIVALENCE at %L

en: PARAMETER at %L is missing an initializer
target: PARAMETER at %L is missing an initialiser

en: PIC register isn't set up
target: PIC register is not set up

en: Parameterized derived type at %C is ambiguous
target: Parameterised derived type at %C is ambiguous

en: Parameterized type %qs does not have a component corresponding to parameter %qs at %L
target: Parameterised type %qs does not have a component corresponding to parameter %qs at %L

en: Perform VR4130-specific alignment optimizations.
target: Perform VR4130-specific alignment optimisations.

en: Perform a number of minor, expensive optimizations.
target: Perform a number of minor, expensive optimisations.

en: Perform a register copy-propagation optimization pass.
target: Perform a register copy-propagation optimisation pass.

en: Perform a register renaming optimization pass.
target: Perform a register renaming optimisation pass.

en: Perform a target dependent instruction fusion optimization pass.
target: Perform a target dependent instruction fusion optimisation pass.

en: Perform conversions of switch initializations.
target: Perform conversions of switch initialisations.

en: Perform cross-jumping optimization.
target: Perform cross-jumping optimisation.

en: Perform jump threading optimizations.
target: Perform jump threading optimisations.

en: Perform speculative devirtualization.
target: Perform speculative devirtualisation.

en: Perform variable tracking and also tag variables that are uninitialized.
target: Perform variable tracking and also tag variables that are uninitialised.

en: Perform whole program optimizations.
target: Perform whole program optimisations.

en: Pointer assignment target in initialization expression does not have the TARGET attribute at %L
target: Pointer assignment target in initialisation expression does not have the TARGET attribute at %L

en: Pointer initialization at %C requires %<=>%>, not %<=%>
target: Pointer initialisation at %C requires %<=>%>, not %<=%>

en: Pointer initialization target at %L must have the SAVE attribute
target: Pointer initialisation target at %L must have the SAVE attribute

en: Pointer initialization target at %L must have the TARGET attribute
target: Pointer initialisation target at %L must have the TARGET attribute

en: Pointer initialization target at %L must not be ALLOCATABLE
target: Pointer initialisation target at %L must not be ALLOCATABLE

en: Prevent $fp being allocated during register allocation so that compiler is able to force performing fp-as-gp optimization.
target: Prevent $fp being allocated during register allocation so that compiler is able to force performing fp-as-gp optimisation.

en: Procedure pointer initialization target at %L may not be a procedure pointer
target: Procedure pointer initialisation target at %L may not be a procedure pointer

en: Put uninitialized constants in ROM (needs -membedded-data).
target: Put uninitialised constants in ROM (needs -membedded-data).

en: Put uninitialized globals in the common section.
target: Put uninitialised globals in the common section.

en: Put zero initialized data in the bss section.
target: Put zero initialised data in the bss section.

en: Recognize C++ keywords like "compl" and "xor".
target: Recognise C++ keywords like "compl" and "xor".

en: Recognize GNU-defined keywords.
target: Recognise GNU-defined keywords.

en: Recognize built-in functions.
target: Recognise built-in functions.

en: Recognize the "asm" keyword.
target: Recognise the "asm" keyword.

en: Repeat spec invalid in scalar initializer at %C
target: Repeat spec invalid in scalar initialiser at %C

en: Report on memory allocation before interprocedural optimization.
target: Report on memory allocation before interprocedural optimisation.

en: Report various link-time optimization statistics for WPA only.
target: Report various link-time optimisation statistics for WPA only.

en: Report various link-time optimization statistics.
target: Report various link-time optimisation statistics.

en: Restrict the analyzer to run just the named checker.
target: Restrict the analyser to run just the named checker.

en: Run predictive commoning optimization.
target: Run predictive commoning optimisation.

en: Run the link-time optimizer in local transformation (LTRANS) mode.
target: Run the link-time optimiser in local transformation (LTRANS) mode.

en: Run the link-time optimizer in whole program analysis (WPA) mode.
target: Run the link-time optimiser in whole program analysis (WPA) mode.

en: Scalarization using DIMEN_RANGE unimplemented
target: Scalarisation using DIMEN_RANGE unimplemented

en: Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations.
target: Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimisations.

en: Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment.
target: Select fraction of the maximal frequency of executions of basic block in function, given basic block get alignment.

en: Select type of coverage sanitization.
target: Select type of coverage sanitisation.

en: Select what to sanitize.
target: Select what to sanitise.

en: Set linker output type (used internally during LTO optimization).
target: Set linker output type (used internally during LTO optimisation).

en: Size of the stack guard expressed as a power of two in bytes.
target: Size of the stack guard expressed as a power of two, in bytes.

en: Size optimization level: 0:none 1:opportunistic 2: regalloc 3:drop align, -Os.
target: Size optimisation level: 0:none 1:opportunistic 2: regalloc 3:drop align, -Os.

en: Stream extra data to support more aggressive devirtualization in LTO local transformation mode.
target: Stream extra data to support more aggressive devirtualisation in LTO local transformation mode.

en: Support dynamic initialization of thread-local variables in a different translation unit.
target: Support dynamic initialisation of thread-local variables in a different translation unit.

en: Syntax error in old style initialization of %s at %C
target: Syntax error in old style initialisation of %s at %C

en: Syntax error in old style initializer list at %C
target: Syntax error in old style initialiser list at %C

en: Take advantage of linker relaxations to reduce the number of instructions required to materialize symbol addresses.
target: Take advantage of linker relaxations to reduce the number of instructions required to materialise symbol addresses.

en: The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer
target: The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initialiser

en: The assignment to a KIND or LEN component of a parameterized type at %L is not allowed
target: The assignment to a KIND or LEN component of a parameterised type at %L is not allowed

en: The following options control optimizations
target: The following options control optimisations

en: The maximum code size growth ratio when expanding into a jump table (in percent).  The parameter is used when optimizing for size.
target: The maximum code size growth ratio when expanding into a jump table (in percent).  The parameter is used when optimising for size.

en: The maximum code size growth ratio when expanding into a jump table (in percent).  The parameter is used when optimizing for speed.
target: The maximum code size growth ratio when expanding into a jump table (in percent).  The parameter is used when optimising for speed.

en: The maximum number of 'after supernode' exploded nodes within the analyzer per supernode, before terminating analysis.
target: The maximum number of 'after supernode' exploded nodes within the analyser per supernode, before terminating analysis.

en: The maximum number of exploded nodes per program point within the analyzer, before terminating analysis of that point.
target: The maximum number of exploded nodes per program point within the analyser, before terminating analysis of that point.

en: The maximum number of times a callsite can appear in a call stack within the analyzer, before terminating analysis of a call that would recurse deeper.
target: The maximum number of times a callsite can appear in a call stack within the analyser, before terminating analysis of a call that would recurse deeper.

en: The minimum number of supernodes within a function for the analyzer to consider summarizing its effects at call sites.
target: The minimum number of supernodes within a function for the analyser to consider summarizing its effects at call sites.

en: The minimum size of variables taking part in stack slot sharing when not optimizing.
target: The minimum size of variables taking part in stack slot sharing when not optimising.

en: The smallest number of different values for which it is best to use a jump-table instead of a tree of conditional branches, if 0, use the default for the machine.
target: The smallest number of different values for which it is best to use a jump-table instead of a tree of conditional branches; if 0, use the default for the machine.

en: Tiled loop cannot be parallelized across gangs, workers and vectors at the same time at %L
target: Tiled loop cannot be parallelised across gangs, workers and vectors at the same time at %L

en: Too many elements in array initializer at %C
target: Too many elements in array initialiser at %C

en: Transformational function %qs at %L is invalid in an initialization expression
target: Transformational function %qs at %L is invalid in an initialisation expression

en: Treat data references as near, far or medium. medium is default.
target: Treat data references as near, far or medium. Default is medium.

en: Uninitialized probability of edge %i->%i
target: Uninitialised probability of edge %i->%i

en: Unrecognized MCU name %qs, assuming that it has no hardware multiply.
    Use the %<-mhwmult%> option to set this explicitly.
target: Unrecognised MCU name %qs, assuming that it has no hardware multiply.
    Use the %<-mhwmult%> option to set this explicitly.

en: Unrecognized MCU name %qs, assuming that it is just a MSP430 with no hardware multiply.
    Use the %<-mcpu%> and %<-mhwmult%> options to set these explicitly.
target: Unrecognised MCU name %qs, assuming that it is just a MSP430 with no hardware multiply.
    Use the %<-mcpu%> and %<-mhwmult%> options to set these explicitly.

en: Unrecognized MCU name %qs, assuming that it just supports the MSP430 ISA.
    Use the %<-mcpu%> option to set the ISA explicitly.
target: Unrecognised MCU name %qs, assuming that it just supports the MSP430 ISA.
    Use the %<-mcpu%> option to set the ISA explicitly.

en: Unrecognized MCU name %qs.
target: Unrecognised MCU name %qs.

en: Unrecognized option to %<-finit-logical%>: %s
target: Unrecognised option to %<-finit-logical%>: %s

en: Unrecognized option to endianness value: %qs
target: Unrecognised option to endianness value: %qs

en: Unrecognized option to floating-point init value: %qs
target: Unrecognised option to floating-point init value: %qs

en: Unrecognized option: %qs
target: Unrecognised option: %qs

en: Unused initialization string at %L because variable has zero length
target: Unused initialisation string at %L because variable has zero length

en: Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d
target: Upper array reference at %L is out-of-bounds (%ld < %ld) in dimension %d

en: Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d
target: Upper array reference at %L is out-of-bounds (%ld > %ld) in dimension %d

en: Use 128-bit AVX instructions instead of 256-bit AVX instructions in the auto-vectorizer.
target: Use 128-bit AVX instructions instead of 256-bit AVX instructions in the auto-vectoriser.

en: Use IRA based register pressure calculation in RTL hoist optimizations.
target: Use IRA based register pressure calculation in RTL hoist optimisations.

en: Use IRA based register pressure calculation in RTL loop optimizations.
target: Use IRA based register pressure calculation in RTL loop optimisations.

en: Use Neon double-word (rather than quad-word) registers for vectorization.
target: Use Neon double-word (rather than quad-word) registers for vectorisation.

en: Use Neon quad-word (rather than double-word) registers for vectorization.
target: Use Neon quad-word (rather than double-word) registers for vectorisation.

en: Use Virtualization (VZ) instructions.
target: Use Virtualisation (VZ) instructions.

en: Use a minimum runtime (no static initializers or ctors) for memory-constrained devices.
target: Use a minimum runtime (no static initialisers or ctors) for memory-constrained devices.

en: Use caller save register across calls if possible.
target: Use caller save register across calls, if possible.

en: Use expression value profiles in optimizations.
target: Use expression value profiles in optimisations.

en: Use features of and optimize for CPU.
target: Use features of and optimise for CPU.

en: Use given register vector width instructions instead of maximum register width in the auto-vectorizer.
target: Use given register vector width instructions instead of maximum register width in the auto-vectoriser.

en: Use table lookup optimization for small signed integer divisions.
target: Use table lookup optimisation for small signed integer divisions.

en: Use trap instead of a library function for undefined behavior sanitization.
target: Use trap instead of a library function for undefined behaviour sanitisation.

en: User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct
target: User-defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct

en: Usually "private extern" (hidden) symbols are made local when linking, this command suppresses that such that they remain exported.
target: Usually "private extern" (hidden) symbols are made local when linking, this command suppresses that, such that they remain exported.

en: Variable %qs at %C with an initializer already appears in a DATA statement
target: Variable %qs at %C with an initialiser already appears in a DATA statement

en: Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed
target: Variable %qs at %L is in COMMON but only in BLOCK DATA initialisation is allowed

en: Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray
target: Variable %qs at %L with coarray component shall be a nonpointer, non-allocatable scalar, which is not a coarray

en: Vectorize for double-word operations.
target: Vectorise for double-word operations.

en: Warn about code paths in which an unsanitized value is used as an array index.
target: Warn about code paths in which an unsanitised value is used as an array index.

en: Warn about dangling else.
target: Warn about a dangling else.

en: Warn about maybe uninitialized automatic variables.
target: Warn about maybe-uninitialised automatic variables.

en: Warn about missing fields in struct initializers.
target: Warn about missing fields in struct initialisers.

en: Warn about optimizations that assume that signed overflow is undefined.
target: Warn about optimisations that assume that signed overflow is undefined.

en: Warn about overriding initializers with side effects.
target: Warn about overriding initialisers with side effects.

en: Warn about overriding initializers without side effects.
target: Warn about overriding initialisers without side effects.

en: Warn about positional initialization of structs requiring designated initializers.
target: Warn about positional initialisation of structs requiring designated initialisers.

en: Warn about possibly missing braces around initializers.
target: Warn about possibly missing braces around initialisers.

en: Warn about some C++ One Definition Rule violations during link time optimization.
target: Warn about some C++ One Definition Rule violations during link time optimisation.

en: Warn about uninitialized automatic variables.
target: Warn about uninitialised automatic variables.

en: Warn about unrecognized pragmas.
target: Warn about unrecognised pragmas.

en: Warn about variables which are initialized to themselves.
target: Warn about variables which are initialised to themselves.

en: Warn for placement new expressions with undefined behavior.
target: Warn for placement new expressions with undefined behaviour.

en: Warn if a loop with constant number of iterations triggers undefined behavior.
target: Warn if a loop with constant number of iterations triggers undefined behaviour.

en: Warn if a simd directive is overridden by the vectorizer cost model.
target: Warn if a simd directive is overridden by the vectoriser cost model.

en: Warn if an MCU name is unrecognized or conflicts with other options (default: on).
target: Warn if an MCU name is unrecognised or conflicts with other options (default: on).

en: Warn if an array is accessed out of bounds.
target: Warn if an array is accessed out-of-bounds.

en: Warn if conversion of the result of arithmetic might change the value even though converting the operands cannot.
target: Warn if conversion of the result of arithmetic might change the value, even though converting the operands cannot.

en: Warn if dereferencing a NULL pointer may lead to erroneous or undefined behavior.
target: Warn if dereferencing a NULL pointer may lead to erroneous or undefined behaviour.

en: Warn if the ISR is misspelled, i.e. without __vector prefix. Enabled by default.
target: Warn if the ISR is misspelt, i.e. without __vector prefix. Enabled by default.

en: Warn if the code is too complicated for the analyzer to fully explore.
target: Warn if the code is too complicated for the analyser to fully explore.

en: Warn when a jump misses a variable initialization.
target: Warn when a jump misses a variable initialisation.

en: Warn when an optimization pass is disabled.
target: Warn when an optimisation pass is disabled.

en: Warn when non-templatized friend functions are declared within a template.
target: Warn when non-templatised friend functions are declared within a template.

en: When "signed" or "unsigned" is not given make the bitfield unsigned.
target: When "signed" or "unsigned" is not given, make the bitfield unsigned.

en: When -mhard-float is selected, enables generation of double-precision floating point instructions.  By default functions from libgcc are used to perform double-precision floating point operations.
target: When -mhard-float is selected, enables generation of double-precision floating point instructions.  By default, functions from libgcc are used to perform double-precision floating point operations.

en: When -mhard-float is selected, enables generation of unordered floating point compare and set flag (lf.sfun*) instructions.  By default functions from libgcc are used to perform unordered floating point compare and set flag operations.
target: When -mhard-float is selected, enables generation of unordered floating point compare and set flag (lf.sfun*) instructions.  By default, functions from libgcc are used to perform unordered floating point compare and set flag operations.

en: When possible do not generate stack frames.
target: When possible, do not generate stack frames.

en: When vectorizing for SVE, consider using unpacked vectors for smaller elements and use the cost model to pick the cheapest approach.  Also use the cost model to choose between SVE and Advanced SIMD vectorization.
target: When vectorising for SVE, consider using unpacked vectors for smaller elements and use the cost model to pick the cheapest approach.  Also use the cost model to choose between SVE and Advanced SIMD vectorisation.

en: Where shorter, use canonicalized paths to systems headers.
target: Where shorter, use canonicalised paths to systems headers.

en: Write a SRCFILE.opt-record.json file detailing what optimizations were performed.
target: Write a SRCFILE.opt-record.json file detailing which optimisations were performed.

en: a brace-enclosed initializer is not allowed here
target: a brace-enclosed initialiser is not allowed here

en: accessing %qD member instead of initialized %qD member in constant expression
target: accessing %qD member instead of initialised %qD member in constant expression

en: accessing uninitialized array element
target: accessing uninitialised array element

en: accessing uninitialized member %qD
target: accessing uninitialised member %qD

en: accumulator number is out of bounds
target: accumulator number is out-of-bounds

en: ambiguous template specialization %qD for %q+D
target: ambiguous template specialisation %qD for %q+D

en: an explicit specialization must be preceded by %<template <>%>
target: an explicit specialisation must be preceded by %<template <>%>

en: anachronistic old-style base class initializer
target: anachronistic old-style base class initialiser

en: and the implicitly-defined constructor does not initialize %q#D
target: and the implicitly-defined constructor does not initialise %q#D

en: applying %<#pragma weak %+D%> after first use results in unspecified behavior
target: applying %<#pragma weak %+D%> after first use results in unspecified behaviour

en: argument %qD doesn%'t match built-in prototype
target: argument %qD does not match built-in prototype

en: argument %qD doesn%'t match prototype
target: argument %qD does not match prototype

en: argument %qs to %<-Waligned-new%> not recognized
target: argument %qs to %<-Waligned-new%> not recognised

en: argument %qs to %<-Wnormalized%> not recognized
target: argument %qs to %<-Wnormalized%> not recognised

en: argument %qs to %<-femit-struct-debug-detailed%> not recognized
target: argument %qs to %<-femit-struct-debug-detailed%> not recognised

en: argument 1 of %qs is out of range
target: argument 1 of %qs is out-of-range

en: array %qD initialized by parenthesized string literal %qE
target: array %qD initialised by parenthesised string literal %qE

en: array bound forbidden after parenthesized type-id
target: array bound forbidden after parenthesised type-id

en: array index in initializer exceeds array bounds
target: array index in initialiser exceeds array bounds

en: array index in initializer is not an integer constant expression
target: array index in initialiser is not an integer constant expression

en: array index in initializer not of integer type
target: array index in initialiser not of integer type

en: array index in non-array initializer
target: array index in non-array initialiser

en: array index range in initializer exceeds array bounds
target: array index range in initialiser exceeds array bounds

en: array initialized from non-constant array expression
target: array initialised from non-constant array expression

en: array initialized from parenthesized string constant
target: array initialised from parenthesised string constant

en: array must be initialized with a brace-enclosed initializer
target: array must be initialised with a brace-enclosed initialiser

en: array of inappropriate type initialized from string constant
target: array of inappropriate type initialised from string constant

en: array used as initializer
target: array used as initialiser

en: assigning to an array from an initializer list
target: assigning to an array from an initialiser list

en: assignment (not initialization) in declaration
target: assignment (not initialisation) in declaration

en: attributes after parenthesized initializer ignored
target: attributes after parenthesised initialiser ignored

en: base %qT will be initialized after
target: base %qT will be initialised after

en: base class %q#T should be explicitly initialized in the copy constructor
target: base class %q#T should be explicitly initialised in the copy constructor

en: base initializer expansion %qT contains no parameter packs
target: base initialiser expansion %qT contains no parameter packs

en: braces around scalar initializer
target: braces around scalar initialiser

en: braces around scalar initializer for type %qT
target: braces around scalar initialiser for type %qT

en: caller is not optimized
target: caller is not optimised

en: can%'t get position in PCH file: %m
target: cannot get position in PCH file: %m

en: can't use non gp relative absolute address
target: can't use non-gp-relative absolute address

en: cannot convert %qH to %qI in initialization
target: cannot convert %qH to %qI in initialisation

en: cannot deduce template arguments for copy-initialization of %qT, as it has no non-explicit deduction guides or user-declared constructors
target: cannot deduce template arguments for copy-initialisation of %qT, as it has no non-explicit deduction guides or user-declared constructors

en: cannot expand initializer for member %qD
target: cannot expand initialiser for member %qD

en: cannot initialize aggregate of type %qT with a compound literal
target: cannot initialise aggregate of type %qT with a compound literal

en: cannot initialize array of %qT from a string literal with type array of %qT
target: cannot initialise array of %qT from a string literal with type array of %qT

en: cannot specialize concept %q#D
target: cannot specialise concept %q#D

en: cannot value-initialize array of unknown bound %qT
target: cannot value-initialise array of unknown bound %qT

en: change of the active member of a union from %qD to %qD during initialization
target: change of the active member of a union from %qD to %qD during initialisation

en: code may be misoptimized unless %<-fno-strict-aliasing%> is used
target: code may be misoptimised unless %<-fno-strict-aliasing%> is used

en: comparison with string literal results in unspecified behavior
target: comparison with string literal results in unspecified behaviour

en: constructor delegation follows mem-initializer for %qD
target: constructor delegation follows mem-initialiser for %qD

en: converting to %qH from %qI requires direct-initialization
target: converting to %qH from %qI requires direct-initialisation

en: converting to %qT from initializer list would use explicit constructor %qD
target: converting to %qT from initialiser list would use explicit constructor %qD

en: declaration of %q#D has %<extern%> and is initialized
target: declaration of %q#D has %<extern%> and is initialised

en: declaration of %q#D has no initializer
target: declaration of %q#D has no initialiser

en: deduced initializer does not satisfy placeholder constraints
target: deduced initialiser does not satisfy placeholder constraints

en: deducing from brace-enclosed initializer list requires %<#include <initializer_list>%>
target: deducing from brace-enclosed initialiser list requires %<#include <initializer_list>%>

en: default argument specified in explicit specialization
target: default argument specified in explicit specialisation

en: default arguments are not allowed in declaration of friend template specialization %qD
target: default arguments are not allowed in declaration of friend template specialisation %qD

en: default member initializer for %qD required before the end of its enclosing class
target: default member initialiser for %qD required before the end of its enclosing class

en: default member initializer for unnamed bit-field
target: default member initialiser for unnamed bit-field

en: default member initializers for bit-fields only available with %<-std=c++2a%> or %<-std=gnu++2a%>
target: default member initialisers for bit-fields only available with %<-std=c++2a%> or %<-std=gnu++2a%>

en: default template arguments may not be used in partial specializations
target: default template arguments may not be used in partial specialisations

en: defaulted default constructor does not initialize %q#D
target: defaulted default constructor does not initialise %q#D

en: defaulted default constructor does not initialize any non-static data member
target: defaulted default constructor does not initialise any non-static data member

en: defining explicit specialization %qD in friend declaration
target: defining explicit specialisation %qD in friend declaration

en: deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior
target: deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behaviour

en: deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior
target: deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behaviour

en: direct-list-initialization of %<auto%> requires exactly one element
target: direct-list-initialisation of %<auto%> requires exactly one element

en: duplicate initialization of %qD
target: duplicate initialisation of %qD

en: either all initializer clauses should be designated or none of them should be
target: either all initialiser clauses should be designated or none of them should be

en: empty index range in initializer
target: empty index range in initialiser

en: empty initializer for lambda init-capture
target: empty initialiser for lambda init-capture

en: empty initializer in lambda init-capture
target: empty initialiser in lambda init-capture

en: empty scalar initializer
target: empty scalar initialiser

en: enclosing class templates are not explicitly specialized
target: enclosing class templates are not explicitly specialised

en: enum conversion from %qT to %qT in initialization is invalid in C++
target: enum conversion from %qT to %qT in initialisation is invalid in C++

en: enum conversion in initialization is invalid in C++
target: enum conversion in initialisation is invalid in C++

en: excess elements in %<char%> array initializer
target: excess elements in %<char%> array initialiser

en: excess elements in array initializer
target: excess elements in array initialiser

en: excess elements in scalar initializer
target: excess elements in scalar initialiser

en: excess elements in struct initializer
target: excess elements in struct initialiser

en: excess elements in union initializer
target: excess elements in union initialiser

en: excess elements in vector initializer
target: excess elements in vector initialiser

en: expected initializer
target: expected initialiser

en: expected iteration declaration or initialization
target: expected iteration declaration or initialisation

en: expected labeled-statement
target: expected labelled-statement

en: explicit deduction guides not considered for copy-initialization
target: explicit deduction guides not considered for copy-initialisation

en: explicit specialization %q#D may be missing attributes
target: explicit specialisation %q#D may be missing attributes

en: explicit specialization declared %<concept%>
target: explicit specialisation declared %<concept%>

en: explicit specialization in non-namespace scope %qD
target: explicit specialisation in non-namespace scope %qD

en: explicit specialization of %qD after first use
target: explicit specialisation of %qD after first use

en: explicit specialization of %qD must be introduced by %<template <>%>
target: explicit specialisation of %qD must be introduced by %<template <>%>

en: explicit specialization of %qD outside its namespace must use a nested-name-specifier
target: explicit specialisation of %qD outside its namespace must use a nested-name-specifier

en: explicit specialization of function concept %qD
target: explicit specialisation of function concept %qD

en: explicit specialization of non-template %qT
target: explicit specialisation of non-template %qT

en: explicit template specialization cannot have a storage class
target: explicit template specialisation cannot have a storage class

en: expression list treated as compound expression in initializer
target: expression list treated as compound expression in initialiser

en: expression list treated as compound expression in mem-initializer
target: expression list treated as compound expression in mem-initialiser

en: extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>
target: extended initialiser lists only available with %<-std=c++11%> or %<-std=gnu++11%>

en: external TLS initialization functions not supported on this target
target: external TLS initialisation functions not supported on this target

en: extra brace group at end of initializer
target: extra brace group at end of initialiser

en: extra elements in scalar initializer
target: extra elements in scalar initialiser

en: fail to initialize plugin %s
target: fail to initialise plugin %s

en: failed to initialize plugin %s
target: failed to initialise plugin %s

en: field name not in record or union initializer
target: field name not in record or union initialiser

en: for deduction to %<std::initializer_list%>, use copy-list-initialization (i.e. add %<=%> before the %<{%>)
target: for deduction to %<std::initializer_list%>, use copy-list-initialisation (i.e. add %<=%> before the %<{%>)

en: fr30_print_operand: unrecognized %%B code
target: fr30_print_operand: unrecognised %%B code

en: fr30_print_operand: unrecognized %%b code
target: fr30_print_operand: unrecognised %%b code

en: fr30_print_operand: unrecognized %%p code
target: fr30_print_operand: unrecognised %%p code

en: friend declaration %qD is not visible to explicit specialization
target: friend declaration %qD is not visible to explicit specialisation

en: function %q#D is initialized like a variable
target: function %q#D is initialised like a variable

en: function %qD is initialized like a variable
target: function %qD is initialised like a variable

en: function declaration isn%'t a prototype
target: function declaration is not a prototype

en: if any %<if%> clause has modifier, then all %<if%> clauses have to use modifier
target: if any %<if%> clause has a modifier, then all %<if%> clauses have to use a modifier

en: ignoring %qE attribute applied to template specialization %qT
target: ignoring %qE attribute applied to template specialisation %qT

en: ignoring nonexistent directory "%s"
target: ignoring non-existent directory "%s"

en: ignoring unrecognized switch %<-mcustom-fpu-cfg%> value %<%s%>
target: ignoring unrecognised switch %<-mcustom-fpu-cfg%> value %<%s%>

en: in C++98 %qD must be initialized by constructor, not by %<{...}%>
target: in C++98 %qD must be initialised by constructor, not by %<{...}%>

en: in argument to unary !
target: in argument to unary!

en: in initialization of structured binding variable %qD
target: in initialisation of structured binding variable %qD

en: in-class initialization of static data member %q#D of incomplete type
target: in-class initialisation of static data member %q#D of incomplete type

en: in-class initialization of static data member %q#D of non-literal type
target: in-class initialisation of static data member %q#D of non-literal type

en: incompatible types when initializing type %qT using type %qT
target: incompatible types when initialising type %qT using type %qT

en: inconsistent capitalization in format
target: inconsistent capitalisation in format

en: index in dimension %d is out of bounds at %L
target: index in dimension %d is out-of-bounds at %L

en: index value instead of field name in union initializer
target: index value instead of field name in union initialiser

en: initialization discards %qv qualifier from pointer target type
target: initialisation discards %qv qualifier from pointer target type

en: initialization from distinct Objective-C type
target: initialisation from distinct Objective-C type

en: initialization from pointer to non-enclosed address space
target: initialisation from pointer to non-enclosed address space

en: initialization left-hand side might be a candidate for a format attribute
target: initialisation left-hand side might be a candidate for a format attribute

en: initialization makes %q#v qualified function pointer from unqualified
target: initialisation makes %q#v qualified function pointer from unqualified

en: initialization of %qT from %qT makes integer from pointer without a cast
target: initialisation of %qT from %qT makes integer from pointer without a cast

en: initialization of %qT from %qT makes pointer from integer without a cast
target: initialisation of %qT from %qT makes pointer from integer without a cast

en: initialization of %qT from incompatible pointer type %qT
target: initialisation of %qT from incompatible pointer type %qT

en: initialization of %qT from pointer to %qD with incompatible type %qT
target: initialisation of %qT from pointer to %qD with incompatible type %qT

en: initialization of a flexible array member
target: initialisation of a flexible array member

en: initialization of common block variable %qs in DATA statement at %C
target: initialisation of common block variable %qs in DATA statement at %C

en: initialization of flexible array member in a nested context
target: initialisation of flexible array member in a nested context

en: initialization of new-expression for type %<auto%> requires exactly one element
target: initialisation of new-expression for type %<auto%> requires exactly one element

en: initialization of non-const reference type %q#T from rvalue of type %qT
target: initialisation of non-const reference type %q#T from rvalue of type %qT

en: initialization of volatile reference type %q#T from rvalue of type %qT
target: initialisation of volatile reference type %q#T from rvalue of type %qT

en: initializations for multiple members of %qT
target: initialisations for multiple members of %qT

en: initialized field overwritten
target: initialised field overwritten

en: initialized field with side-effects overwritten
target: initialised field with side-effects overwritten

en: initialized member %q+D declared here
target: initialised member %q+D declared here

en: initialized variable %q+D is marked dllimport
target: initialised variable %q+D is marked dllimport

en: initializer element is not a constant expression
target: initialiser element is not a constant expression

en: initializer element is not computable at load time
target: initialiser element is not computable at load time

en: initializer element is not constant
target: initialiser element is not constant

en: initializer ends prematurely
target: initialiser ends prematurely

en: initializer expression refers to iteration variable %qD
target: initialiser expression refers to iteration variable %qD

en: initializer fails to determine size of %q+D
target: initialiser fails to determine size of %q+D

en: initializer fails to determine size of %qD
target: initialiser fails to determine size of %qD

en: initializer fails to determine size of %qT
target: initialiser fails to determine size of %qT

en: initializer for %<decltype(auto) %D%> has function type; did you forget the %<()%>?
target: initialiser for %<decltype(auto) %D%> has function type; did you forget the %<()%>?

en: initializer for %q#D expands to an empty list of expressions
target: initialiser for %q#D expands to an empty list of expressions

en: initializer for %q#D is invalid
target: initialiser for %q#D is invalid

en: initializer for %qT must be brace-enclosed
target: initialiser for %qT must be brace-enclosed

en: initializer for flexible array member %q#D
target: initialiser for flexible array member %q#D

en: initializer for floating value is not a floating constant
target: initialiser for floating value is not a floating constant

en: initializer for integer/fixed-point value is too complicated
target: initialiser for integer/fixed-point value is too complicated

en: initializer in range-based %<for%> loop
target: initialiser in range-based %<for%> loop

en: initializer invalid for static member with constructor
target: initialiser invalid for static member with constructor

en: initializer provided for function
target: initialiser provided for function

en: initializer specified for friend function %qD
target: initialiser specified for friend function %qD

en: initializer specified for non-virtual method %q+D
target: initialiser specified for non-virtual method %q+D

en: initializer specified for static member function %qD
target: initialiser specified for static member function %qD

en: initializer-string for %qT is too long
target: initialiser-string for %qT is too long

en: initializing %qD from %qE does not extend the lifetime of the underlying array
target: initialising %qD from %qE does not extend the lifetime of the underlying array

en: initializing %qH with %qI in converted constant expression does not bind directly
target: initialising %qH with %qI in converted constant expression does not bind directly

en: initializing a base class of type %qT results in object slicing
target: initialising a base class of type %qT results in object slicing

en: insufficient partitioning available to parallelize element loop
target: insufficient partitioning available to parallelise element loop

en: insufficient partitioning available to parallelize loop
target: insufficient partitioning available to parallelise loop

en: insufficient partitioning available to parallelize tile loop
target: insufficient partitioning available to parallelise tile loop

en: inter-module optimizations not implemented for C++
target: inter-module optimisations not implemented for C++

en: intrinsic variable which isn't a procedure
target: intrinsic variable which is not a procedure

en: invalid explicit specialization
target: invalid explicit specialisation

en: invalid in-class initialization of static data member of non-integral type %qT
target: invalid in-class initialisation of static data member of non-integral type %qT

en: invalid initialization of non-const reference of type %qH from an rvalue of type %qI
target: invalid initialisation of non-const reference of type %qH from an rvalue of type %qI

en: invalid initialization of reference of type %qH from expression of type %qI
target: invalid initialisation of reference of type %qH from expression of type %qI

en: invalid initializer
target: invalid initialiser

en: invalid initializer clause
target: invalid initialiser clause

en: invalid initializer for %q#D
target: invalid initialiser for %q#D

en: invalid initializer for array member %q#D
target: invalid initialiser for array member %q#D

en: invalid initializer for member function %qD
target: invalid initialiser for member function %qD

en: invalid initializer for structured binding declaration
target: invalid initialiser for structured binding declaration

en: invalid type %qT as initializer for a vector of type %qT
target: invalid type %qT as initialiser for a vector of type %qT

en: invalid use of brace-enclosed initializer list
target: invalid use of brace-enclosed initialiser list

en: invalid value-initialization of reference type
target: invalid value-initialisation of reference type

en: iteration %s invokes undefined behavior
target: iteration %s invokes undefined behaviour

en: jump skips variable initialization
target: jump skips variable initialisation

en: keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)
target: keyword %<typename%> not allowed in this context (a qualified member initialiser is implicitly a type)

en: lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>
target: lambda capture initialisers only available with %<-std=c++14%> or %<-std=gnu++14%>

en: language %s not recognized
target: language %s not recognised

en: language string %<"%E"%> not recognized
target: language string %<"%E"%> not recognised

en: list-initializer for non-class type must not be parenthesized
target: list-initialiser for non-class type must not be parenthesised

en: literal operator suffixes not preceded by %<_%> are reserved for future standardization
target: literal operator suffixes not preceded by %<_%> are reserved for future standardisation

en: machine independent builtin code out of range
target: machine independent builtin code out-of-range

en: mem-initializer for %qD follows constructor delegation
target: mem-initialiser for %qD follows constructor delegation

en: member %qD is uninitialized reference
target: member %qD is uninitialised reference

en: member %qD must be initialized by mem-initializer in %<constexpr%> constructor
target: member %qD must be initialised by mem-initialiser in %<constexpr%> constructor

en: member %qD with uninitialized reference fields
target: member %qD with uninitialised reference fields

en: members of an explicitly specialized class are defined without a template header
target: members of an explicitly specialised class are defined without a template header

en: mismatched declarations during linktime optimization
target: mismatched declarations during linktime optimisation

en: missing braces around initializer
target: missing braces around initialiser

en: missing braces around initializer for %qT
target: missing braces around initialiser for %qT

en: missing initializer for field %qD of %qT
target: missing initialiser for field %qD of %qT

en: missing initializer for member %qD
target: missing initialiser for member %qD

en: misspelled term %<%.*s%> in format; use %<%s%s%> instead
target: misspelt term %<%.*s%> in format; use %<%s%s%> instead

en: multiple fields in union %qT initialized
target: multiple fields in union %qT initialised

en: multiple initializations given for %qD
target: multiple initialisations given for %qD

en: multiple initializations given for base %qT
target: multiple initialisations given for base %qT

en: name %qD used in a GNU-style designated initializer for an array
target: name %qD used in a GNU-style designated initialiser for an array

en: name used in a GNU-style designated initializer for an array
target: name used in a GNU-style designated initialiser for an array

en: no field %qD found in union being initialized
target: no field %qD found in union being initialised

en: node is analyzed but it is not a definition
target: node is analysed but it is not a definition

en: non-NULL pointer initialization at %C
target: non-NULL pointer initialisation at %C

en: non-class, non-variable partial specialization %qE is not allowed
target: non-class, non-variable partial specialisation %qE is not allowed

en: non-constant array initialization
target: non-constant array initialisation

en: non-constant in-class initialization invalid for non-inline static member %qD
target: non-constant in-class initialisation invalid for non-inline static member %qD

en: non-constant in-class initialization invalid for static member %qD
target: non-constant in-class initialisation invalid for static member %qD

en: non-constant initialization expression at %L
target: non-constant initialisation expression at %L

en: non-delegitimized UNSPEC %s (%d) found in variable location
target: non-delegitimised UNSPEC %s (%d) found in variable location

en: non-local variable %qD declared %<__thread%> needs dynamic initialization
target: non-local variable %qD declared %<__thread%> needs dynamic initialisation

en: non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>
target: non-static data member initialisers only available with %<-std=c++11%> or %<-std=gnu++11%>

en: non-static initialization of a flexible array member
target: non-static initialisation of a flexible array member

en: non-trivial designated initializers not supported
target: non-trivial designated initialisers not supported

en: non-type partial specialization %qE is not allowed
target: non-type partial specialisation %qE is not allowed

en: nonconstant array index in initializer
target: nonconstant array index in initialiser

en: normalization cannot co-exist with scaling
target: normalisation cannot co-exist with scaling

en: number of arguments doesn%'t match built-in prototype
target: number of arguments does not match built-in prototype

en: number of arguments doesn%'t match prototype
target: number of arguments does not match prototype

en: number of components of vector not a power of two
target: number of components of vector is not a power of two

en: obsolete use of designated initializer with %<:%>
target: obsolete use of designated initialiser with %<:%>

en: obsolete use of designated initializer without %<=%>
target: obsolete use of designated initialiser without %<=%>

en: one of the initializer call arguments should be %<&omp_priv%>
target: one of the initialiser call arguments should be %<&omp_priv%>

en: one of the initializer call arguments should be %<omp_priv%> or %<&omp_priv%>
target: one of the initialiser call arguments should be %<omp_priv%> or %<&omp_priv%>

en: only constructors take member initializers
target: only constructors take member initialisers

en: only uninitialized variables can be placed in a .bss section
target: only uninitialised variables can be placed in a .bss section

en: only uninitialized variables can be placed in the .noinit section
target: only uninitialised variables can be placed in the .noinit section

en: only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out of range
target: only values 12 (4 KB) and 16 (64 KB) are supported for guard size.  Given value %d (%llu KB) is out-of-range

en: only zero initializers are allowed in section %qs
target: only zero initialisers are allowed in section %qs

en: opaque vector types cannot be initialized
target: opaque vector types cannot be initialised

en: operand number out of range in format
target: operand number out-of-range in format

en: optimization attribute on %qD follows definition but the attribute doesn%'t match
target: optimisation attribute on %qD follows definition but the attribute does not match

en: optimization level attribute mismatch
target: optimisation level attribute mismatch

en: optimization may eliminate reads and/or writes to register variables
target: optimisation may eliminate reads and/or writes to register variables

en: parameter %qD is initialized
target: parameter %qD is initialised

en: parametrized derived type argument
target: parametrised derived type argument

en: parenthesized initialization is not allowed in OpenMP %<for%> loop
target: parenthesised initialisation is not allowed in OpenMP %<for%> loop

en: parenthesized initializer in array new
target: parenthesised initialiser in array new

en: partial specialization %q+D does not specialize any template arguments and is not more constrained than the primary template; to define the primary template, remove the template argument list
target: partial specialisation %q+D does not specialise any template arguments and is not more constrained than the primary template; to define the primary template, remove the template argument list

en: partial specialization %q+D does not specialize any template arguments; to define the primary template, remove the template argument list
target: partial specialisation %q+D does not specialise any template arguments; to define the primary template, remove the template argument list

en: partial specialization %qD is not more specialized than
target: partial specialisation %qD is not more specialised than

en: partial specialization %qT declared %<friend%>
target: partial specialisation %qT declared %<friend%>

en: partial specialization is not more specialized than the primary template because it replaces multiple parameters with a pack expansion
target: partial specialisation is not more specialised than the primary template because it replaces multiple parameters with a pack expansion

en: partial specialization of %qD after instantiation of %qD
target: partial specialisation of %qD after instantiation of %qD

en: passing too large argument on stack
target: passing too large an argument on stack

en: plugin %s is not licensed under a GPL-compatible license
    %s
target: plugin %s is not licensed under a GPL-compatible licence
    %s

en: plugin %s is not licensed under a GPL-compatible license %s
target: plugin %s is not licensed under a GPL-compatible licence %s

en: pointer targets in initialization of %qT from %qT differ in signedness
target: pointer targets in initialisation of %qT from %qT differ in signedness

en: positional initialization of field in %<struct%> declared with %<designated_init%> attribute
target: positional initialisation of field in %<struct%> declared with %<designated_init%> attribute

en: promoted argument %qD doesn%'t match built-in prototype
target: promoted argument %qD does not match built-in prototype

en: promoted argument %qD doesn%'t match prototype
target: promoted argument %qD does not match prototype

en: pure virtual %q#D called from non-static data member initializer
target: pure virtual %q#D called from non-static data member initialiser

en: range-based %<for%> loops with initializer only available with %<-std=c++2a%> or %<-std=gnu++2a%>
target: range-based %<for%> loops with initialiser only available with %<-std=c++2a%> or %<-std=gnu++2a%>

en: re-initialization of %qs at %L
target: re-initialisation of %qs at %L

en: recursive instantiation of default member initializer for %qD
target: recursive instantiation of default member initialiser for %qD

en: reference %qD is initialized with itself
target: reference %qD is initialised with itself

en: register number must be a compile-time constant.  Try giving higher optimization levels
target: register number must be a compile-time constant.  Try giving higher optimisation levels

en: remove %<{ }%> around initializer
target: remove %<{ }%> around initialiser

en: requested %qE attribute is not a comma separated pair of non-negative integer constants or too large (max. %d)
target: requested %qE attribute is not a comma-separated pair of non-negative integer constants or too large (max. %d)

en: returning initializer list
target: returning initialiser list

en: saw %d %<template<>%>, need %d for specializing a member function template
target: saw %d %<template<>%>, need %d for specialising a member function template

en: scalar object %qD requires one element in initializer
target: scalar object %qD requires one element in initialiser

en: scaling cannot co-exist with normalization, skipping
target: scaling cannot co-exist with normalisation, skipping

en: spec failure: %<%%*%> has not been initialized by pattern match
target: spec failure: %<%%*%> has not been initialised by pattern match

en: spec failure: unrecognized spec option %qc
target: spec failure: unrecognised spec option %qc

en: specialization %qT after instantiation %qT
target: specialisation %qT after instantiation %qT

en: specialization of %qD after instantiation
target: specialisation of %qD after instantiation

en: specialization of %qD in different namespace
target: specialisation of %qD in different namespace

en: specialization of %qD must appear at namespace scope
target: specialisation of %qD must appear at namespace scope

en: specialization of %qT after instantiation
target: specialisation of %qT after instantiation

en: specialization of alias template %qD
target: specialisation of alias template %qD

en: specialization of implicitly-declared special member function
target: specialisation of implicitly-declared special member function

en: specialization of variable concept %q#D
target: specialisation of variable concept %q#D

en: specialization of variable template %qD declared as function
target: specialisation of variable template %qD declared as function

en: specializing member %<%T::%E%> requires %<template<>%> syntax
target: specialising member %<%T::%E%> requires %<template<>%> syntax

en: statement marked for throw, but doesn%'t
target: statement marked for throw, but does not

en: static chain with function that doesn%'t use one
target: static chain with function that does not use one

en: static initialization of variable %q+D in %<.shared%> memory is not supported
target: static initialisation of variable %q+D in %<.shared%> memory is not supported

en: stmt (%p) marked modified after optimization pass:
target: stmt (%p) marked modified after optimisation pass:

en: suggest parentheses around %<&&%> within %<||%>
target: suggest brackets (parentheses) around %<&&%> within %<||%>

en: suggest parentheses around %<+%> in operand of %<&%>
target: suggest brackets (parentheses) around %<+%> in operand of %<&%>

en: suggest parentheses around %<+%> inside %<<<%>
target: suggest brackets (parentheses) around %<+%> inside %<<<%>

en: suggest parentheses around %<+%> inside %<>>%>
target: suggest brackets (parentheses) around %<+%> inside %<>>%>

en: suggest parentheses around %<-%> in operand of %<&%>
target: suggest brackets (parentheses) around %<-%> in operand of %<&%>

en: suggest parentheses around %<-%> inside %<<<%>
target: suggest brackets (parentheses) around %<-%> inside %<<<%>

en: suggest parentheses around %<-%> inside %<>>%>
target: suggest brackets (parentheses) around %<-%> inside %<>>%>

en: suggest parentheses around %<>>%> expression
target: suggest brackets (parentheses) around %<>>%> expression

en: suggest parentheses around arithmetic in operand of %<^%>
target: suggest brackets (parentheses) around arithmetic in operand of %<^%>

en: suggest parentheses around arithmetic in operand of %<|%>
target: suggest brackets (parentheses) around arithmetic in operand of %<|%>

en: suggest parentheses around comparison in operand of %<!=%>
target: suggest brackets (parentheses) around comparison in operand of %<!=%>

en: suggest parentheses around comparison in operand of %<&%>
target: suggest brackets (parentheses) around comparison in operand of %<&%>

en: suggest parentheses around comparison in operand of %<==%>
target: suggest brackets (parentheses) around comparison in operand of %<==%>

en: suggest parentheses around comparison in operand of %<^%>
target: suggest brackets (parentheses) around comparison in operand of %<^%>

en: suggest parentheses around comparison in operand of %<|%>
target: suggest brackets (parentheses) around comparison in operand of %<|%>

en: suggest parentheses around operand of %<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>
target: suggest brackets (parentheses) around operand of %<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>

en: suggest parentheses around operand of %<!%> or change %<|%> to %<||%> or %<!%> to %<~%>
target: suggest brackets (parentheses) around operand of %<!%> or change %<|%> to %<||%> or %<!%> to %<~%>

en: switch jumps over variable initialization
target: switch jumps over variable initialisation

en: synthesized method %qD first required here
target: synthesised method %qD first required here

en: target of initialization might be a candidate for a format attribute
target: target of initialisation might be a candidate for a format attribute

en: template parameters not deducible in partial specialization:
target: template parameters not deducible in partial specialisation:

en: template specialization of %qD not allowed by ISO C++
target: template specialisation of %qD not allowed by ISO C++

en: template specialization with C linkage
target: template specialisation with C linkage

en: the content of uninitialized storage is not usable in a constant expression
target: the content of uninitialised storage is not usable in a constant expression

en: the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>
target: the mangled name of the initialisation guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>

en: the range of count should be in 0 to 32.  please check the intrinsic _mm_ror_pi16 in code.
target: the range of count should be in 0 to 32.  Please check the intrinsic _mm_ror_pi16 in code.

en: the range of count should be in 0 to 32.  please check the intrinsic _mm_ror_pi32 in code.
target: the range of count should be in 0 to 32.  Please check the intrinsic _mm_ror_pi32 in code.

en: the range of count should be in 0 to 32.  please check the intrinsic _mm_rori_pi16 in code.
target: the range of count should be in 0 to 32.  Please check the intrinsic _mm_rori_pi16 in code.

en: the range of count should be in 0 to 32.  please check the intrinsic _mm_rori_pi32 in code.
target: the range of count should be in 0 to 32.  Please check the intrinsic _mm_rori_pi32 in code.

en: the range of count should be in 0 to 64.  please check the intrinsic _mm_ror_si64 in code.
target: the range of count should be in 0 to 64.  Please check the intrinsic _mm_ror_si64 in code.

en: the range of count should be in 0 to 64.  please check the intrinsic _mm_rori_si64 in code.
target: the range of count should be in 0 to 64.  Please check the intrinsic _mm_rori_si64 in code.

en: to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified
target: to be safe: all intermediate pointers in cast from %qT to %qT must be %<const%> qualified

en: to generate dependencies you must specify either %<-M%> or %<-MM%>
target: you must specify either %<-M%> or %<-MM%> to generate dependencies

en: too many arguments for partial specialization %qT
target: too many arguments for partial specialisation %qT

en: too many braces around initializer for %qT
target: too many braces around initialiser for %qT

en: too many braces around scalar initializer for type %qT
target: too many braces around scalar initialiser for type %qT

en: too many initializers for %qT
target: too many initialisers for %qT

en: traditional C rejects automatic aggregate initialization
target: traditional C rejects automatic aggregate initialisation

en: traditional C rejects initialization of unions
target: traditional C rejects initialisation of unions

en: trailing return type %qT of deduction guide is not a specialization of %qT
target: trailing return type %qT of deduction guide is not a specialisation of %qT

en: transformational intrinsic %qs at %L is not permitted in an initialization expression
target: transformational intrinsic %qs at %L is not permitted in an initialisation expression

en: type of array %q+D completed incompatibly with implicit initialization
target: type of array %q+D completed incompatibly with implicit initialisation

en: typedef %qD is initialized (use %<__typeof__%> instead)
target: typedef %qD is initialised (use %<__typeof__%> instead)

en: typedef %qD is initialized (use %qs instead)
target: typedef %qD is initialised (use %qs instead)

en: undefined behavior when second parameter of %<va_start%> is declared with %<register%> storage
target: undefined behaviour when second parameter of %<va_start%> is declared with %<register%> storage

en: uninitialized %<const %D%>
target: uninitialised %<const %D%>

en: uninitialized %<const %D%> is invalid in C++
target: uninitialised %<const %D%> is invalid in C++

en: uninitialized const in %<new%> of %q#T
target: uninitialised const in %<new%> of %q#T

en: uninitialized const member in %q#T
target: uninitialised const member in %q#T

en: uninitialized const member in %q#T using %<new%> without new-initializer
target: uninitialised const member in %q#T using %<new%> without new-initialiser

en: uninitialized const member in %qT is invalid in C++
target: uninitialised const member in %qT is invalid in C++

en: uninitialized const member in base %q#T of %q#T
target: uninitialised const member in base %q#T of %q#T

en: uninitialized const member in base %q#T of %q#T using %<new%> without new-initializer
target: uninitialised const member in base %q#T of %q#T using %<new%> without new-initialiser

en: uninitialized reference member in %q#T
target: uninitialised reference member in %q#T

en: uninitialized reference member in %q#T using %<new%> without new-initializer
target: uninitialised reference member in %q#T using %<new%> without new-initialiser

en: uninitialized reference member in base %q#T of %q#T
target: uninitialised reference member in base %q#T of %q#T

en: uninitialized reference member in base %q#T of %q#T using %<new%> without new-initializer
target: uninitialised reference member in base %q#T of %q#T using %<new%> without new-initialiser

en: uninitialized variable %q+D put into program memory area
target: uninitialised variable %q+D put into program memory area

en: uninitialized variable %qD in %<constexpr%> context
target: uninitialised variable %qD in %<constexpr%> context

en: uninitialized variable %qD in %<constexpr%> function
target: uninitialised variable %qD in %<constexpr%> function

en: unknown vectorization library ABI type (%qs) for %qs switch
target: unknown vectorisation library ABI type (%qs) for %qs switch

en: unknown vectorizer cost model %qs
target: unknown vectoriser cost model %qs

en: unknown vtable verify initialization priority %qs
target: unknown vtable verify initialisation priority %qs

en: unmatched color reset directive
target: unmatched colour reset directive

en: unnamed initializer for %qT, which has no base classes
target: unnamed initialiser for %qT, which has no base classes

en: unnamed initializer for %qT, which uses multiple inheritance
target: unnamed initialiser for %qT, which uses multiple inheritance

en: unrecognizable argument of option
target: unrecognisable argument of option

en: unrecognizable insn:
target: unrecognisable insn:

en: unrecognized %<-mfpu%> target: %s
target: unrecognised %<-mfpu%> target: %s

en: unrecognized %<hwmpy%> field in %<hard_msp430_mcu_data[%d]%>: %qd
target: unrecognised %<hwmpy%> field in %<hard_msp430_mcu_data[%d]%>: %qd

en: unrecognized %<include_flags 0x%x%> passed to %<print_specific_help%>
target: unrecognised %<include_flags 0x%x%> passed to %<print_specific_help%>

en: unrecognized %<revision%> field in %<hard_msp430_mcu_data[%d]%>: %qd
target: unrecognised %<revision%> field in %<hard_msp430_mcu_data[%d]%>: %qd

en: unrecognized %s target: %s
target: unrecognised %s target: %s

en: unrecognized address
target: unrecognised address

en: unrecognized argument in option %qs
target: unrecognised argument in option %qs

en: unrecognized argument of %<-mcpu%>: %s
target: unrecognised argument of %<-mcpu%>: %s

en: unrecognized argument to %<--help=%> option: %q.*s
target: unrecognised argument to %<--help=%> option: %q.*s

en: unrecognized argument to %<-f%ssanitize%s=%> option: %q.*s
target: unrecognised argument to %<-f%ssanitize%s=%> option: %q.*s

en: unrecognized argument to %<-f%ssanitize%s=%> option: %q.*s; did you mean %qs?
target: unrecognised argument to %<-f%ssanitize%s=%> option: %q.*s; did you mean %qs?

en: unrecognized argument to %<-flto=%> option: %qs
target: unrecognised argument to %<-flto=%> option: %qs

en: unrecognized command-line option %<-%s%>
target: unrecognised command-line option %<-%s%>

en: unrecognized command-line option %<-%s%>; did you mean %<-%s%>?
target: unrecognised command-line option %<-%s%>; did you mean %<-%s%>?

en: unrecognized command-line option %<-fdump-%s%>
target: unrecognised command-line option %<-fdump-%s%>

en: unrecognized command-line option %<-fopt-info-%s%>
target: unrecognised command-line option %<-fopt-info-%s%>

en: unrecognized command-line option %qs
target: unrecognised command-line option %qs

en: unrecognized command-line option %qs may have been intended to silence earlier diagnostics
target: unrecognised command-line option %qs may have been intended to silence earlier diagnostics

en: unrecognized control register number: %d - using %<psw%>
target: unrecognised control register number: %d - using %<psw%>

en: unrecognized debug output level %qs
target: unrecognised debug output level %qs

en: unrecognized edge flag: %qs
target: unrecognised edge flag: %qs

en: unrecognized enum value: %qs
target: unrecognised enum value: %qs

en: unrecognized format specifier
target: unrecognised format specifier

en: unrecognized gcc debugging option: %c
target: unrecognised gcc debugging option: %c

en: unrecognized interrupt vector argument of %qE attribute
target: unrecognised interrupt vector argument of %qE attribute

en: unrecognized ivar visibility value %qs
target: unrecognised ivar visibility value %qs

en: unrecognized operand to %%:asm_auto_mfpu
target: unrecognised operand to %%:asm_auto_mfpu

en: unrecognized operand to %%:canon_for_mlib
target: unrecognised operand to %%:canon_for_mlib

en: unrecognized option %<-fdisable%>
target: unrecognised option %<-fdisable%>

en: unrecognized option %<-fenable%>
target: unrecognised option %<-fenable%>

en: unrecognized option passed to %%:target_mode_check
target: unrecognised option passed to %%:target_mode_check

en: unrecognized register name %qs
target: unrecognised register name %qs

en: unrecognized scalar storage order value %qs
target: unrecognised scalar storage order value %qs

en: unrecognized section name %qE
target: unrecognised section name %qE

en: unrecognized shadow offset %qs
target: unrecognised shadow offset %qs

en: unrecognized supposed constant
target: unrecognised supposed constant

en: unrecognized visibility value %qs
target: unrecognised visibility value %qs

en: unterminated color directive
target: unterminated colour directive

en: use %<template<>%> for an explicit specialization
target: use %<template<>%> for an explicit specialisation

en: use of %qs length modifier with %qc type character has either no effect or undefined behavior
target: use of %qs length modifier with %qc type character has either no effect or undefined behaviour

en: user defined reduction lookup is ambiguous
target: user-defined reduction lookup is ambiguous

en: user defined reduction not found for %qE
target: user-defined reduction not found for %qE

en: user defined reduction with constructor initializer for base class %qT
target: user-defined reduction with constructor initialiser for base class %qT

en: using alias template specialization %qT after %qs
target: using alias template specialisation %qT after %qs

en: value-initialization of function type %qT
target: value-initialisation of function type %qT

en: value-initialization of incomplete type %qT
target: value-initialisation of incomplete type %qT

en: value-initialization of reference type %qT
target: value-initialisation of reference type %qT

en: variable %q#D has initializer but incomplete type
target: variable %q#D has initialiser but incomplete type

en: variable %q+D with dynamic initialization put into program memory area
target: variable %q+D with dynamic initialisation put into program memory area

en: variable %qD has initializer but incomplete type
target: variable %qD has initialiser but incomplete type

en: variable concept has no initializer
target: variable concept has no initialiser

en: variable-sized object may not be initialized
target: variable-sized object may not be initialised

en: variables marked with %qE attribute must be initialized
target: variables marked with %qE attribute must be initialised

en: vectorization did not happen for a simd loop
target: vectorisation did not happen for a simd loop

en: virtual definition of statement not up to date
target: virtual definition of statement not up-to-date

en: virtual use of statement not up to date
target: virtual use of statement not up-to-date

en: you can work around this by removing the initializer
target: you can work around this by removing the initialiser
