gcc-8 - en to unknown language translation catalogue (683 entries)

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

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:   -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:   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 GCC optimize is not allowed inside functions
target: #pragma GCC optimise is not allowed inside functions

en: #pragma GCC optimize string... is badly formed
target: #pragma GCC optimise string... is badly formed

en: %<#pragma GCC optimize (string [,string]...)%> does not have a final %<)%>
target: %<#pragma GCC optimise (string [,string]...)%> does not have a final %<)%>

en: %<#pragma GCC optimize%> is not a string or number
target: %<#pragma GCC optimise%> is not a string or number

en: %<-fcheck-pointer-bounds%> is not supported with Address Sanitizer
target: %<-fcheck-pointer-bounds%> is not supported with Address Sanitiser

en: %<-fcheck-pointer-bounds%> is not supported with Thread Sanitizer
target: %<-fcheck-pointer-bounds%> is not supported with Thread Sanitiser

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: %<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: %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 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 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: '%%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: -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: -Wnormalised=[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: -fdeduce-init-list	enable deduction of std::initializer_list for a template type parameter from a brace-enclosed initializer-list.
target: -fdeduce-init-list	enable deduction of std::initialiser_list for a template type parameter from a brace-enclosed initialiser-list.

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

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

en: -fenable-[tree|rtl|ipa]-<pass>=range1+range2 enables an optimization pass.
target: -fenable-[tree|rtl|ipa]-<pass>=range1+range2 enables 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-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: -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: -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: -mcpu=CPU	Use features of and optimize for CPU.
target: -mcpu=CPU	Use features of and optimise for CPU.

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=CPU	Optimize for CPU.
target: -mtune=CPU	Optimise for CPU.

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

en: 31 bit ABI.
target: 32 bit ABI.

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: ASYNCHRONOUS= specifier at %L must be an initialization expression
target: ASYNCHRONOUS= specifier at %L must be an initialisation expression

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: 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 Pointer Bounds Checker optimizations.  By default allowed on optimization levels >0.
target: Allow Pointer Bounds Checker optimisations.  By default, allowed on optimisation levels >0.

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: Analyzed alias has no reference
target: Analysed alias has no reference

en: Analyzed node has no reference to instrumented version
target: Analysed node has no reference to instrumented version

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: 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: Automatic array %qs at %L cannot have an initializer
target: Automatic array %qs at %L cannot have an initialiser

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: Can't initialize implied-shape array at %L with scalar
target: Can't 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: 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 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: 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=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 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 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 signaling NaNs.

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

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 put uninitialized globals in the common section.
target: Do not put uninitialised globals in the common section.

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: Dump optimization passes.
target: Dump optimisation passes.

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: 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 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 front-end optimisation.

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 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 scalar initialization expression at %C
target: Expected scalar initialisation expression 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: 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: 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 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 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 SSA-PRE optimization on trees, enable partial-partial redundancy elimination.
target: In SSA-PRE optimisation on trees, enable partial-partial redundancy elimination.

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 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: 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: Link-time optimization with number of parallel jobs or jobserver.
target: Link-time optimisation with number of parallel jobs or jobserver.

en: Loop parallelized across gangs is not allowed inside another loop parallelized across gangs at %L
target: Loop parallelised across gangs is not allowed inside another loop parallelised across gangs at %L

en: Loop parallelized across vectors is not allowed inside another loop parallelized across vectors at %L
target: Loop parallelised across vectors is not allowed inside another loop parallelised across vectors at %L

en: Loop parallelized across workers is not allowed inside another loop parallelized across vectors at %L
target: Loop parallelised across workers is not allowed inside another loop parallelised across vectors at %L

en: Loop parallelized across workers is not allowed inside another loop parallelized across workers at %L
target: Loop parallelised across workers is not allowed inside another loop parallelised across workers at %L

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 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: 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: Noninteger exponent in an initialization expression at %L
target: Noninteger exponent in an initialisation expression 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 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: 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 branch target load optimization after prologue / epilogue threading.
target: Perform branch target load optimisation after prologue / epilogue threading.

en: Perform branch target load optimization before prologue / epilogue threading.
target: Perform branch target load optimisation before prologue / epilogue threading.

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 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: 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 zero initialized data in the bss section.
target: Put zero initialised data in the bss section.

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: 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: Schedule type of omp schedule for loops parallelized by parloops (static, dynamic, guided, auto, runtime).
target: Schedule type of omp schedule for loops parallelised by parloops (static, dynamic, guided, auto, runtime).

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: Specifies the cost model for vectorization. -fvect-cost-model=[unlimited|dynamic|cheap]	Specifies the cost model for vectorization.
target: Specifies the cost model for vectorisation. -fvect-cost-model=[unlimited|dynamic|cheap]	Specifies the cost model for vectorisation.

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 --param option recognizes the following as parameters
target: The --param option recognises the following as parameters

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 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: 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: Uninitialized probability of edge %i->%i
target: Uninitialised probability of edge %i->%i

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

en: Unrecognized MCU name '%s', 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 '%s', 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 '%s', assuming that it just supports the MSP430 ISA.
    Use the -mcpu option to set the ISA explicitly.
target: Unrecognised MCU name '%s', assuming that it just supports the MSP430 ISA.
    Use the -mcpu option to set the ISA explicitly.

en: Unrecognized MCU name '%s'.
target: Unrecognised MCU name '%s'.

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

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: 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 expression value profiles in optimizations.
target: Use expression value profiles in optimisations.

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 statically initialized variable for constant bounds instead of generating them each time it is required.
target: Use statically initialised variable for constant bounds instead of generating them each time it is required.

en: Use statically initialized variable for vars bounds instead of generating them each time it is required.
target: Use statically initialised variable for vars bounds instead of generating them each time it is required.

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: 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: Vectorize for double-word operations.
target: Vectorise for double-word operations.

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 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 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 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 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: Where shorter, use canonicalized paths to systems headers.
target: Where shorter, use canonicalised paths to systems headers.

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: 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: 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 %<-Wnormalised%> not recognised

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

en: array %qD initialized by parenthesized string literal %qE
target: array %qD initialised by parenthesized 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 initializer

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: 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: branch target register load optimization is not intended to be run twice
target: branch target register load optimisation is not intended to be run twice

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

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 initialize aggregate of type %qT with a compound literal
target: cannot initialise aggregate of type %qT with a compound literal

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

en: char-array initialized from wide string
target: char-array initialised from wide string

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

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: defining explicit specialization %qD in friend declaration
target: defining explicit specialisation %qD in friend declaration

en: definition of %qD does not match %<#include <initializer_list>%>
target: definition of %qD does not match %<#include <initialiser_list>%>

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: enters synchronized or atomic statement
target: enters synchronised or atomic statement

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 array initializer
target: excess elements in array initialiser

en: excess elements in char array initializer
target: excess elements in char 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: 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: 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: field name not in record or union initializer
target: field name not in record or union initialiser

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: 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: 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 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: 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 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 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 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 array of chars is too long
target: initialiser-string for array of chars is too long

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: 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: int-array initialized from incompatible wide string
target: int-array initialised from incompatible wide string

en: int-array initialized from non-wide string
target: int-array initialised from non-wide string

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

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 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: 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: list-initializer for non-class type must not be parenthesized
target: list-initialiser for non-class type must not be parenthesized

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: 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 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: 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 %qD is not allowed
target: non-class, non-variable partial specialisation %qD 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 %qD is not allowed
target: non-type partial specialisation %qD 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: obsolete use of designated initializer with %<:%>
target: obsolete use of designated initialiser with %<:%>

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 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: 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: 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: 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: pure virtual %q#D called from non-static data member initializer
target: pure virtual %q#D called from non-static data member initialiser

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: 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: 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: 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 %q#T in different namespace
target: specialising %q#T in different namespace

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

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: 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 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: too many braces around initializer for %qT
target: too many braces around initialiser for %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 decltype instead)
target: typedef %qD is initialised (use decltype instead)

en: uninitialized const %qD
target: uninitialised const %qD

en: uninitialized const %qD is invalid in C++
target: uninitialised const %qD 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 %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 vectorization library ABI type (%s) for -mveclibabi= switch
target: unknown vectorisation library ABI type (%s) for -mveclibabi= 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 %s target: %s
target: unrecognised %s target: %s

en: unrecognized -mfpu target: %s
target: unrecognised -mfpu 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 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 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: '%s'
target: unrecognised edge flag: '%s'

en: unrecognized format specifier
target: unrecognised format specifier

en: unrecognized gcc debugging option: %c
target: unrecognised gcc debugging option: %c

en: unrecognized hwpy field in msp430_mcu_data[%d]: %d
target: unrecognised hwpy field in msp430_mcu_data[%d]: %d

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: 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: vectorization did not happen for a simd loop
target: vectorisation did not happen for a simd loop

en: wide character array initialized from incompatible wide string
target: wide character array initialised from incompatible wide string

en: wide character array initialized from non-wide string
target: wide character array initialised from non-wide string

en: you can work around this by removing the initializer
target: you can work around this by removing the initialiser
