1.2 List of the armcc error and warning messages

A list of the error and warning messages that armcc produces.

Note

In ARM Compiler 5.02 and earlier, the IDs for the messages in the form C4XXX were in the range 3000-3499.
0: unknown error
1: last line of file ends without a new line
2: last line of file ends with a backslash
3: #include file <entity> includes itself
4: out of memory
5: cannot open <entity> input file <filename>: <reason>
For example:
#include <file.h>
results in the message:
Error: #5: cannot open source input file "file.h": No such file or directory
because file.h does not exist in the system include directory.
6: comment unclosed at end of file
Comment started with /* but no matching */ to close the comment.
7: unrecognized token
8: missing closing quote
For example:
char foo[] = {"\"};
In this example, the backslash causes the following quote " to be treated as a literal character rather than closing the string. To fix this, use:
char foo[] = {"\\"};
9: nested comment is not allowed
For example:
/*nested
/*comment*/
10: "#" not expected here
11: unrecognized preprocessing directive
For example:
#foo
12: parsing restarts here after previous syntax error
13: expected a file name
For example:
#include <>
14: extra text after expected end of preprocessing directive
For example:
#if EMBEDDED foo
or:
#include <stdio.h> foo
or:
#ifdef SOMETHING
:
#endif SOMETHING
The #endif does not expect or require any argument. Enclosing the trailing part of the line in a comment fixes the problem:
#endif /* SOMETHING */
16: <entity> is not a valid source file name
17: expected a "]"
18: expected a ")"
19: extra text after expected end of number
For example:
int a = 37r;
20: identifier <entity> is undefined
For example, when compiled for C++, the code:
void foo( arg ) { }
results in the message:
Error: #20: identifier <arg> is undefined
Another example of code that can cause this error is:
int foo(void)
{
  int a = 4;
  a = i;
}
which results in the message:
Error: #20: identifier "i" is undefined
because i has not been declared.
21: type qualifiers are meaningless in this declaration
22: invalid hexadecimal number
23: integer constant is too large
24: invalid octal digit
For example:
int a = 0378;
25: quoted string should contain at least one character
For example:
char a ='';
26: too many characters in character constant
For example, the following code produces this warning because the multibyte character consists of more bytes than can fit into an int:
int a ='abcde';
27: character value is out of range
This error can occur when a character value described by a hex constant is too large to be represented in a char variable, for example:
char x = '\x100';
28: expression must have a constant value
29: expected an expression
30: floating constant is out of range
31: expression must have integral type
32: expression must have arithmetic type
33: expected a line number
34: invalid line number
35: #error directive: <entity>
36: the #if for this directive is missing
37: the #endif for this directive is missing
An open #if was still active, but was not closed with #endif before the end of file.
38: directive is not allowed -- an #else has already appeared
39: division by zero
40: expected an identifier
This error is raised if preprocessor statements are incorrectly formatted, for example if an identifier which must immediately follow a #define preprocessor command is missing.
This error can also occur when code uses a keyword as an identifier, for example:
int if =0;
41: expression must have arithmetic or pointer type
42: operand types are incompatible (<type> and <type>)
44: expression must have pointer type
45: #undef may not be used on this predefined name
46: <entity> is predefined; attempted redefinition ignored
47: incompatible redefinition of macro <entity>
A macro has been defined twice, with different replacement strings.
For example:
#define TEST 0
#define TEST 1
causes the compiler to produce:
Warning: #47-D: incompatible redefinition of macro "TEST" (declared at line 1)
If it is necessary to do this, undefine the macro using #undef before the second definition.
If you want to define a macro, unless it already has a definition, you can use conditional preprocessing, for example:
#ifndef TEST
#define TEST 0
#endif
Compiling this with armcc -c foo.c defines TEST to be 0 (the default).
Compiling this with armcc -c -DTEST=1 foo.c defines TEST to be 1.
49: duplicate macro parameter name
50: "##" may not be first in a macro definition
51: "##" may not be last in a macro definition
52: expected a macro parameter name
53: expected a ":"
54: too few arguments in macro invocation
55: too many arguments in macro invocation
56: operand of sizeof may not be a function
57: this operator is not allowed in a constant expression
58: this operator is not allowed in a preprocessing expression
59: function call is not allowed in a constant expression
60: this operator is not allowed in an integral constant expression
61: integer operation result is out of range
62: shift count is negative
63: shift count is too large
64: declaration does not declare anything
For example:
int; 
65: expected a ";"
66: enumeration value is out of "int" range
This diagnostic message is generated by the compiler when an enum constant is outside the range of a signed int.
For example, the compiler generates this warning when the following code is compiled in C mode:
typedef enum
{
  Bit31 = 0x80000000
} Bits;

Note

This description applies to RVCT 2.2 and later.
C mode:
  • the warning is produced but the compiler promotes the constants to unsigned
  • the switch --strict always produces this message as an error.
C++ mode:
  • by default the out-of-range constants are promoted to unsigned without a warning and also when --strict is used
As a work around for cases where the message is an error use the following code example:
typedef enum
{
  Bit31 = (int)0x80000000
} Bits;
An overflow no longer occurs, and so no error is reported.

Note

The value of Bit31 is now negative because it is a signed int.
See the following in the armcc User Guide:
67: expected a "}"
68: integer conversion resulted in a change of sign
The constant is too large to be represented in a signed long, and therefore has been given unsigned type.
Example:
long l = 2147483648;
69: integer conversion resulted in truncation
70: incomplete type is not allowed
Example:
typedef struct {
  unsigned char size;
  char string[];
} FOO;
By not declaring a size for the array in the structure, the compiler is not able to allocate a size of the structure. Incomplete types are permitted in --gnu and --c99 modes.
71: operand of sizeof may not be a bit field
76: argument to macro is empty
77: this declaration has no storage class or type specifier
78: a parameter declaration may not have an initializer
79: expected a type specifier
The ellipses to denote variadic functions, such as printf(), must follow at least one parameter. For example, change:
int foo( ... );
to:
int foo( int bar, ... ); 
80: a storage class may not be specified here
81: more than one storage class may not be specified
82: storage class is not first
83: type qualifier specified more than once
84: invalid combination of type specifiers
The type name or type qualifier cannot be used in the same declaration as the second type name or type qualifier. For example:
typedef int int;
85: invalid storage class for a parameter
86: invalid storage class for a function
87: a type specifier may not be used here
88: array of functions is not allowed
89: array of void is not allowed
90: function returning function is not allowed
91: function returning array is not allowed
92: identifier-list parameters may only be used in a function definition
93: function type may not come from a typedef
94: the size of an array must be greater than zero
Zero-sized arrays are permitted only when in --gnu mode, for example:
char name[0];
95: array is too large
There is a limit of 4GB on the maximum size of arrays or structures.
96: a translation unit must contain at least one declaration
97: a function may not return a value of this type
98: an array may not have elements of this type
99: a declaration here must declare a parameter
100: duplicate parameter name
101: <entity> has already been declared in the current scope
102: forward declaration of enum type is nonstandard
103: class is too large
104: struct or union is too large
There is a limit of 4GB on the maximum size of arrays or structures.
105: invalid size for bit field
Bit fields must not be larger than the size of the type.
For example, with --strict:
struct X{
  int y:5000;
};
106: invalid type for a bit field
Bit fields must have integral type.
Example:
struct X{
  float x:5;
  float y:2;
};
107: zero-length bit field must be unnamed
108: signed bit field of length 1
109: expression must have (pointer-to-) function type
110: expected either a definition or a tag name
111: statement is unreachable
112: expected "while"
114: <entity> was referenced but not defined
115: a continue statement may only be used within a loop
116: a break statement may only be used within a loop or switch
Example:
void foo(void){
  int a=0;
  continue;
}
or:
void bar(void){
  int a=0;
  break;
}
117: non-void <entity> should return a value
118: a void function may not return a value
119: cast to type <type> is not allowed
120: return value type does not match the function type
121: a case label may only be used within a switch
122: a default label may only be used within a switch
123: case label value has already appeared in this switch
124: default label has already appeared in this switch
125: expected a "("
126: expression must be an lvalue
127: expected a statement
128: loop is not reachable from preceding code
129: a block-scope function may only have extern storage class
130: expected a "{"
131: expression must have pointer-to-class type
132: expression must have pointer-to-struct-or-union type
133: expected a member name
134: expected a field name
135: <entity> has no member <entity>
136: <entity> has no field <entity>
137: expression must be a modifiable lvalue
138: taking the address of a register variable is not allowed
139: taking the address of a bit field is not allowed
140: too many arguments in function call
Function declaration does not match the number of parameters in an earlier function prototype.
Example:
extern void foo(int x);
void bar(void)
{
  foo(1,2);
}
141: unnamed prototyped parameters not allowed when body is present
142: expression must have pointer-to-object type
143: program too large or complicated to compile
144: a value of type <type> cannot be used to initialize an entity of type <type>
The initializing string for a fixed size character array is exactly as long as the array size, leaving no room for a terminating \0, for example:
char name[5] = "Hello";
The name array can hold up to 5 characters. "Hello" does not fit because C strings are always null-terminated (for example, "Hello\0"). The compiler reports:
Error: #144: a value of type "const char [6]" cannot be used to initialize an entity of type "char [5]"
A similar error is also raised if there is an implicit cast of non-zero int to pointer.
For example:
void foo_func( void )
{
  char *foo=1;
}
results in the message:
#144: a value of type "int" cannot be used to initialize an entity of type "char *"
For the cast, this error can be suppressed with the use of the --loose_implicit_cast switch.
145: <entity> may not be initialized
146: too many initializer values
147: declaration is incompatible with <entity>
The following incorrect C code causes an error in all modes. This can be downgraded from an error to a warning by using --diag_warning 147, or suppressed completely by using --diag_suppress 147.
typedef enum { e } E;
typedef enum { f } F;
E g(void);
F g(void);
148: <entity> has already been initialized
149: a global-scope declaration may not have this storage class
150: a type name may not be redeclared as a parameter
151: a typedef name may not be redeclared as a parameter
152: conversion of nonzero integer to pointer
153: expression must have class type
154: expression must have struct or union type
155: old-fashioned assignment operator
156: old-fashioned initializer
157: expression must be an integral constant expression
158: expression must be an lvalue or a function designator
159: declaration is incompatible with previous <entity>
160: external name conflicts with external name of <entity>
161: unrecognized #pragma
163: could not open temporary file <entity>
164: name of directory for temporary files is too long (<entity>)
165: too few arguments in function call
Function prototype is defined with a number of parameters that does not match the number of parameters passed in the function call.
For example:
extern void foo(int x);
void bar(void)
{
  foo();
}
166: invalid floating constant
167: argument of type <type> is incompatible with parameter of type <type>
168: a function type is not allowed here
169: expected a declaration
This can occur when attempting to compile some C++ header files with the C compiler instead of the C++ compiler.
170: pointer points outside of underlying object
171: invalid type conversion
172: external/internal linkage conflict with previous declaration
The compiler suppresses errors about linkage disagreements, where functions are implicitly declared as extern and later re-declared as static, unless the --strict option is used. For example:
extern void foo(void);
static void foo(void){}
173: floating-point value does not fit in required integral type
174: expression has no effect
175: subscript out of range
177: <entity> was declared but never referenced
By default, unused declaration warnings are given for:
  • Local (within a function) declarations of variables, typedefs, and functions.
  • Labels (always within a function).
  • Top-level static functions and static variables.
The --diag_suppress 177 option suppresses these warnings.
178: "&" applied to an array has no effect
179: right operand of "%" is zero
180: argument is incompatible with formal parameter
181: argument is incompatible with corresponding format string conversion
For example when compiling with --strict, the following code:
unsigned long foo = 0x1234;
printf("%08X", foo);
results in the warning:
Warning: #181-D: argument is incompatible with corresponding format string conversion
To avoid the warning, the code could be rewritten as follows:
unsigned long foo = 0x1234;
printf("%0lX", foo);
or alternatively:
unsigned int foo = 0x1234;
printf("%0X", foo);
%0X can be used for char, short or int. Use lX for a long integer, even though both ints and longs are 32-bits wide on an ARM processor.
182: could not open source file <entity> (no directories in search list)
183: type of cast must be integral
184: type of cast must be arithmetic or pointer
185: dynamic initialization in unreachable code
186: pointless comparison of unsigned integer with zero
For example:
unsigned short foo;
if (foo<0) printf("This never happens");
gives a warning that the comparison between an unsigned value, for example char or int, with zero always evaluates to false.
187: use of "=" where "==" may have been intended
For example:
int main(void)
{
  int a;
  const int b =1;
  if (a=b);
}
If the assignment in the if statement is intentional, then you can avoid the warning by adding an explicit comparison. For example, change the if statement in the example to:
  if ((a=b)!=0);
188: enumerated type mixed with another type
189: error while writing <entity> file
190: invalid intermediate language file
191: type qualifier is meaningless on cast type
The C specification states that a cast does not yield an lvalue, so a cast to a qualified type has the same effect as a cast to the unqualified version of the type. This warning is to inform you that the type qualifier has no effect, although the code is still legal. The warning is suppressible with --diag_suppress 191.
For example:
val2 = (const float)val1;
is equivalent to:
val2 = (float)val1;
192: unrecognized character escape sequence
This error is commonly associated with the attempted use of non-ASCII character sets, such as 16-bit Unicode characters. The compiler supports multibyte character sets, such as Unicode. Source files are compiled according to the selected locale of that machine. It is possible to use Escape processing (as recommended by Kernighan and Ritchie, section A2.5.2) to encode specific values instead.
For example:
char *p = "\x12\x34\x56\x78"; // 12 34 56 78
In character and string escapes, if the character following the \ has no special meaning, the value of the escape is the character itself, for example, \s is the same as s and the warning is given.
193: zero used for undefined preprocessing identifier <entity>
194: expected an asm string
195: an asm function must be prototyped
196: an asm function may not have an ellipsis
219: error while deleting file <entity>
220: integral value does not fit in required floating-point type
221: floating-point value does not fit in required floating-point type
222: floating-point operation result is out of range
223: function <entity> declared implicitly
This is a common warning that occurs where there is no prototype for a function.
For example:
void foo(void)
{
  printf("foo");
}
To fix this, add #include <stdio.h> to include the prototype for printf().
For ANSI C, you can suppress this warning with --diag_suppress 223. This is useful when compiling old-style C in ANSI C mode.
224: the format string requires additional arguments
225: the format string ends before this argument
226: invalid format string conversion
227: macro recursion
228: trailing comma is nonstandard
229: bit field cannot contain all values of the enumerated type
230: nonstandard type for a bit field
In strict ANSI C90, the only types permitted for a bit field are int, signed int, and unsigned int.
For example:
struct X {
   char y:2;
};
231: declaration is not visible outside of function
232: old-fashioned typedef of "void" ignored
233: left operand is not a struct or union containing this field
234: pointer does not point to struct or union containing this field
235: variable <entity> was declared with a never-completed type
236: controlling expression is constant
237: selector expression is constant
238: invalid specifier on a parameter
239: invalid specifier outside a class declaration
240: duplicate specifier in declaration
241: a union is not allowed to have a base class
242: multiple access control specifiers are not allowed
243: class or struct definition is missing
244: qualified name is not a member of class <type> or its base classes
245: a nonstatic member reference must be relative to a specific object
246: a nonstatic data member may not be defined outside its class
247: <entity> has already been defined
A typical example of this is where a variable name has been used more than once.
This can sometimes occur when compiling legacy code that relies on tentative declarations. Tentative declarations permit a variable to be declared and initialized as separate statements such as:
int a;
int a = 1;
Tentative declarations are permitted by default for C code, but produce an error with C++ code.
248: pointer to reference is not allowed
249: reference to reference is not allowed
250: reference to void is not allowed
251: array of reference is not allowed
252: reference <entity> requires an initializer
253: expected a ","
254: type name is not allowed
This occurs when a typedef name is being used directly in an expression, for example:
typedef int footype;
int x = footype; // reports Error: #254: type name is not allowed
To fix this, first create an instance of that type, for example, a variable of the new type:
typedef int footype;
footype bar = 1;
int x = bar;
255: type definition is not allowed
256: invalid redeclaration of type name <entity>
257: const <entity> requires an initializer
258: "this" may only be used inside a nonstatic member function
259: constant value is not known
260: explicit type is missing ("int" assumed)
261: access control not specified (<entity> by default)
262: not a class or struct name
263: duplicate base class name
264: invalid base class
265: <entity> is inaccessible
For C++ only, the --diag_warning 265 option downgrades access control errors to warnings.
For example:
class A { void f() {}; }; // private member
A a;
void g() { a.f(); } // erroneous access
results in the message:
Error: #265-D: function "A::f" is inaccessible
266: <entity> is ambiguous
267: old-style parameter list (anachronism)
268: declaration may not appear after executable statement in block
269: conversion to inaccessible base class <type> is not allowed
274: improperly terminated macro invocation
276: name followed by "::" must be a class or namespace name
277: invalid friend declaration
278: a constructor or destructor may not return a value
279: invalid destructor declaration
280: declaration of a member with the same name as its class
281: global-scope qualifier (leading "::") is not allowed
282: the global scope has no <entity>
283: qualified name is not allowed
284: NULL reference is not allowed
285: initialization with "<...>" is not allowed for object of type <type>
286: base class <type> is ambiguous
287: derived class <type> contains more than one instance of class <type>
288: cannot convert pointer to base class <type> to pointer to derived class <type> -- base class is virtual
289: no instance of constructor <entity> matches the argument list
290: copy constructor for class <type> is ambiguous
291: no default constructor exists for class <type>
292: <entity> is not a nonstatic data member or base class of class <type>
293: indirect nonvirtual base class is not allowed
294: invalid union member -- class <type> has a disallowed member function
296: invalid use of non-lvalue array
297: expected an operator
298: inherited member is not allowed
299: cannot determine which instance of <entity> is intended
300: a pointer to a bound function may only be used to call the function
301: typedef name has already been declared (with same type)
302: <entity> has already been defined
304: no instance of <entity> matches the argument list
305: type definition is not allowed in function return type declaration
306: default argument not at end of parameter list
307: redefinition of default argument
308: more than one instance of <entity> matches the argument list:
309: more than one instance of constructor <entity> matches the argument list:
310: default argument of type <type> is incompatible with parameter of type <type>
311: cannot overload functions distinguished by return type alone
312: no suitable user-defined conversion from <type> to <type> exists
313: type qualifier is not allowed on this function
314: only nonstatic member functions may be virtual
315: the object has cv-qualifiers that are not compatible with the member function
316: program too large to compile (too many virtual functions)
317: return type is not identical to nor covariant with return type <type> of overridden virtual function <entity>
318: override of virtual <entity> is ambiguous
319: pure specifier ("= 0") allowed only on virtual functions
320: badly-formed pure specifier (only "= 0" is allowed)
321: data member initializer is not allowed
322: object of abstract class type <type> is not allowed:
323: function returning abstract class <type> is not allowed:
324: duplicate friend declaration
325: inline specifier allowed on function declarations only
326: "inline" is not allowed
327: invalid storage class for an inline function
328: invalid storage class for a class member
329: local class member <entity> requires a definition
330: <entity> is inaccessible
332: class <type> has no copy constructor to copy a const object
333: defining an implicitly declared member function is not allowed
334: class <type> has no suitable copy constructor
335: linkage specification is not allowed
336: unknown external linkage specification
337: linkage specification is incompatible with previous <entity>
If the linkage for a function is redeclared with an incompatible specification to a previous declaration this error is produced.
For example:
int foo(void);
int bar(void)
{
  int x;
  x = foo();
  return x;
}
extern "C" int foo(void)
{
  return 0;
}
results in the message:
Error: #337: linkage specification is incompatible with previous "foo" (declared at line 1)
338: more than one instance of overloaded function <entity> has "C" linkage
339: class <type> has more than one default constructor
340: value copied to temporary, reference to temporary used
341: "operator<entity>" must be a member function
342: operator may not be a static member function
343: no arguments allowed on user-defined conversion
344: too many parameters for this operator function
345: too few parameters for this operator function
346: nonmember operator requires a parameter with class type
347: default argument is not allowed
348: more than one user-defined conversion from <type> to <type> applies:
349: no operator <entity> matches these operands
350: more than one operator <entity> matches these operands:
351: first parameter of allocation function must be of type "size_t"
352: allocation function requires "void *" return type
353: deallocation function requires "void" return type
354: first parameter of deallocation function must be of type "void *"
356: type must be an object type
357: base class <type> has already been initialized
358: base class name required -- <type> assumed (anachronism)
359: <entity> has already been initialized
360: name of member or base class is missing
361: assignment to "this" (anachronism)
362: "overload" keyword used (anachronism)
363: invalid anonymous union -- nonpublic member is not allowed
364: invalid anonymous union -- member function is not allowed
365: anonymous union at global or namespace scope must be declared static
366: <entity> provides no initializer for:
367: implicitly generated constructor for class <type> cannot initialize:
368: <entity> defines no constructor to initialize the following:
This indicates that you have a const structure or a structure containing a const. It is issued as a friendly warning to assist with error 369. This can safely be ignored providing that the const members of structures are appropriately initialized.
369: <entity> has an uninitialized const or reference member
This indicates that you have an instance of a const structure or a structure containing a const that has not been correctly initialized. You must either initialize it correctly for every instance or provide a constructor to initialize it.
370: <entity> has an uninitialized const field
371: class <type> has no assignment operator to copy a const object
372: class <type> has no suitable assignment operator
373: ambiguous assignment operator for class <type>
375: declaration requires a typedef name
377: "virtual" is not allowed
378: "static" is not allowed
379: cast of bound function to normal function pointer (anachronism)
380: expression must have pointer-to-member type
381: extra ";" ignored
In C, this can be caused by an unexpected semicolon at the end of a declaration line, for example:
int x;;
This might occur inadvertently when using macros.
Similarly, in C++, this might be caused by constructions like:
class X { ... } ; ;
This probably resulted from some macro usage, for example:
#define M(c) class c { ... } ;
M(X);
The extra semicolon is illegal because empty declarations are illegal.
382: nonstandard member constant declaration (standard form is a static const integral member)
384: no instance of overloaded <entity> matches the argument list
386: no instance of <entity> matches the required type
387: delete array size expression used (anachronism)
389: a cast to abstract class <type> is not allowed:
390: function "main" may not be called or have its address taken
391: a new-initializer may not be specified for an array
392: member function <entity> may not be redeclared outside its class
393: pointer to incomplete class type is not allowed
394: reference to local variable of enclosing function is not allowed
395: single-argument function used for postfix <entity> (anachronism)
398: cast to array type is nonstandard (treated as cast to <type>)
399: <entity> has an operator new<entity>() but no default operator delete<entity>()
400: <entity> has a default operator delete<entity>() but no operator new<entity>()
401: destructor for base class <entity> is not virtual
403: invalid redeclaration of member <entity>
404: function "main" may not be declared inline
405: member function with the same name as its class must be a constructor
406: using nested <entity> (anachronism)
407: a destructor may not have parameters
408: copy constructor for class <type> may not have a parameter of type <type>
409: <entity> returns incomplete type <type>
410: protected <entity> is not accessible through a <type> pointer or object
411: a parameter is not allowed
412: an "asm" declaration is not allowed here
413: no suitable conversion function from <type> to <type> exists
414: delete of pointer to incomplete class
415: no suitable constructor exists to convert from <type> to <type>
416: more than one constructor applies to convert from <type> to <type>:
417: more than one conversion function from <type> to <type> applies:
418: more than one conversion function from <type> to a built-in type applies:
424: a constructor or destructor may not have its address taken
427: qualified name is not allowed in member declaration
428: enumerated type mixed with another type (anachronism)
429: the size of an array in "new" must be non-negative
430: returning reference to local temporary
433: qualifiers dropped in binding reference of type <type> to initializer of type <type>
434: a reference of type <type> (not const-qualified) cannot be initialized with a value of type <type>
435: a pointer to function may not be deleted
436: conversion function must be a nonstatic member function
437: template declaration is not allowed here
438: expected a "<"
439: expected a ">"
440: template parameter declaration is missing
441: argument list for <entity> is missing
442: too few arguments for <entity>
443: too many arguments for <entity>
450: the type "long long" is nonstandard
451: omission of <entity> is nonstandard
452: return type may not be specified on a conversion function
456: excessive recursion at instantiation of <entity>
457: <entity> is not a function or static data member
458: argument of type <type> is incompatible with template parameter of type <type>
459: initialization requiring a temporary or conversion is not allowed
460: declaration of <entity> hides function parameter
461: initial value of reference to non-const must be an lvalue
463: "template" is not allowed
464: <type> is not a class template
467: invalid reference to <entity> (union/nonunion mismatch)
468: a template argument may not reference a local type
469: tag kind of <entity> is incompatible with declaration of <entity>
470: the global scope has no tag named <entity>
471: <entity> has no tag member named <entity>
473: <entity> may be used only in pointer-to-member declaration
476: name followed by "::~" must be a class name or a type name
477: destructor name does not match name of class <type>
478: type used as destructor name does not match type <type>
479: <entity> redeclared "inline" after being called
485: <entity> is not an entity that can be instantiated
486: compiler generated <entity> cannot be explicitly instantiated
487: inline <entity> cannot be explicitly instantiated
490: <entity> cannot be instantiated -- it has been explicitly specialized
494: declaring a void parameter list with a typedef is nonstandard
When the compiler is not in C99 mode, this error is produced by a function declaration f(V) where V is a void type.
Using a parameter that is a typedef to void to mean that the function has no parameters is only permitted in C99 mode.
496: template parameter <entity> may not be redeclared in this scope
497: declaration of <entity> hides template parameter
498: template argument list must match the parameter list
501: an operator name must be declared as a function
502: operator name is not allowed
503: <entity> cannot be specialized in the current scope
504: nonstandard form for taking the address of a member function
The C++ standard requires that a pointer to a member be named using a qualifier and an ampersand character, for example &A::f.
505: too few template parameters -- does not match previous declaration
506: too many template parameters -- does not match previous declaration
507: function template for operator delete(void *) is not allowed
508: class template and template parameter may not have the same name
511: enumerated type is not allowed
512: type qualifier on a reference type is not allowed
513: a value of type <type> cannot be assigned to an entity of type <type>
514: pointless comparison of unsigned integer with a negative constant
515: cannot convert to incomplete class <type>
516: const object requires an initializer
517: object has an uninitialized const or reference member
518: nonstandard preprocessing directive
519: <entity> may not have a template argument list
520: initialization with "<...>" expected for aggregate object
521: pointer-to-member selection class types are incompatible (<type> and <type>)
522: pointless friend declaration
524: non-const function called for const object (anachronism)
525: a dependent statement may not be a declaration
526: a parameter may not have void type
For example:
void foo(void a) { }
529: this operator is not allowed in a template argument expression
530: try block requires at least one handler
531: handler requires an exception declaration
532: handler is masked by default handler
533: handler is potentially masked by previous handler for type <type>
534: use of a local type to specify an exception
535: redundant type in exception specification
536: exception specification is incompatible with that of previous <entity>
540: support for exception handling is disabled
541: omission of exception specification is incompatible with previous <entity>
542: could not create instantiation request file <entity>
543: non-arithmetic operation not allowed in nontype template argument
544: use of a local type to declare a nonlocal variable
545: use of a local type to declare a function
546: transfer of control bypasses initialization of:
Example:
int main(void){
   int choice = 1;
   int z =1;
   switch(choice)
   {
     case 1:
       int y = 1;
       z = y + z;
       break;
     case 2:
     break;
   }
   return 0;
In this example, y is an initialized variable that is in scope but is unused in the other cases. A transfer from the condition of the switch statement to a case label, bypassing the initialization of y, conflicts with the C++ Standard.
The usual way to fix this is to enclose the case that declares y in braces. The following code limits the scope of y to case 1, so an attempt to use it elsewhere causes an error:
case 1:   {
  int y = 1;
  z = y + z;
}
break;
Because y is a Plain Old Data (POD) type, an alternative is to not use initialization:
case 1:
 int y;
 y = 1;
 z = y + z;
 break;
This approach has the disadvantage that if code outside of case 1 uses y, and accidentally expects it to have the value assigned in case 1, no warning is given.
548: transfer of control into an exception handler
549: <entity> is used before its value is set
550: <entity> was set but never used
551: <entity> cannot be defined in the current scope
552: exception specification is not allowed
553: external/internal linkage conflict for <entity>
554: <entity> will not be called for implicit or explicit conversions
555: tag kind of <entity> is incompatible with template parameter of type <type>
556: function template for operator new(size_t) is not allowed
558: pointer to member of type <type> is not allowed
559: ellipsis is not allowed in operator function parameter list
560: <entity> is reserved for future use as a keyword
561: invalid macro definition:
562: invalid macro undefinition:
563: invalid <entity> output file <filename>
564: cannot open <entity> output file <filename>: <reason>
570: error in debug option argument
571: invalid option:
574: invalid number:
576: invalid instantiation mode:
578: invalid error limit:
585: virtual function tables can only be suppressed when compiling C++
586: anachronism option can be used only when compiling C++
587: instantiation mode option can be used only when compiling C++
588: automatic instantiation mode can be used only when compiling C++
589: implicit template inclusion mode can be used only when compiling C++
590: exception handling option can be used only when compiling C++
593: missing source file name
594: output files may not be specified when compiling several input files
595: too many arguments on command line
596: an output file was specified, but none is needed
598: a template parameter may not have void type
600: strict mode is incompatible with allowing anachronisms
601: a throw expression may not have void type
602: local instantiation mode is incompatible with automatic instantiation
603: parameter of abstract class type <type> is not allowed:
604: array of abstract class <type> is not allowed:
605: floating-point template parameter is nonstandard
606: this pragma must immediately precede a declaration
607: this pragma must immediately precede a statement
608: this pragma must immediately precede a declaration or statement
609: this kind of pragma may not be used here
611: overloaded virtual function <entity> is only partially overridden in <entity>
612: specific definition of inline template function must precede its first use
613: invalid error tag in diagnostic control option:
614: invalid error number in diagnostic control option:
615: parameter type involves pointer to array of unknown bound
616: parameter type involves reference to array of unknown bound
617: pointer-to-member-function cast to pointer to function
618: struct or union declares no named members
619: nonstandard unnamed field
620: nonstandard unnamed member
624: <entity> is not a type name
625: cannot open precompiled header input file <entity>: <reason>
626: precompiled header file <entity> is either invalid or not generated by this version of the compiler
627: precompiled header file <entity> was not generated in this directory
628: header files used to generate precompiled header file <entity> have changed
629: the command line options do not match those used when precompiled header file <entity> was created
630: the initial sequence of preprocessing directives is not compatible with those of precompiled header file <entity>
631: unable to obtain mapped memory for <entity>: <reason>
This can occur if you are trying to use a large Precompiled Header (PCH), and you have a size limitation on the TMP directory that the ARM Compiler toolchain uses. A possible workaround is to remove the TMP environment variable. This forces the tools to create temporary files in the current working directory.
See the following in the Getting Started Guide:
632: "<entity>": using precompiled header file "<entity>"
633: "<entity>": creating precompiled header file "<entity>"
634: memory usage conflict with precompiled header file <entity>
This can occur if a PCH file cannot be mapped back into the build because the required parts of the address space of the compiler are not available.
See also error 631.
635: invalid PCH memory size
636: PCH options must appear first in the command line
637: insufficient memory for PCH memory allocation
638: precompiled header files may not be used when compiling several input files
639: insufficient preallocated memory for generation of precompiled header file (<entity> bytes required)
640: very large entity in program prevents generation of precompiled header file
641: <entity> is not a valid directory
642: cannot build temporary file name
643: "restrict" is not allowed
644: a pointer or reference to function type may not be qualified by "restrict"
645: <entity> is an unrecognized __declspec attribute
646: a calling convention modifier may not be specified here
647: conflicting calling convention modifiers
650: calling convention specified here is ignored
651: a calling convention may not be followed by a nested declarator
652: calling convention is ignored for this type
654: declaration modifiers are incompatible with previous declaration
655: the modifier <entity> is not allowed on this declaration
656: transfer of control into a try block
657: inline specification is incompatible with previous <entity>
658: closing brace of template definition not found
659: wchar_t keyword option can be used only when compiling C++
660: invalid packing alignment value
661: expected an integer constant
662: call of pure virtual function
A pure virtual function is being called, for example:
struct T { T(); virtual void pvfn() = 0; };
                   // a pure virtual function
T::T() { pvfn(); } // warning given here
By default, calling a pure virtual function results in:
  1. a call to the library function __cxa_pure_virtual()
  2. the __cxa_pure_virtual() function raising the signal SIGPVFN
  3. the signal being trapped by the default_signal_handler
  4. the handler displaying Pure virtual fn called on the console using semihosting.
See the following in the armcc User Guide:
663: invalid source file identifier string
664: a class template cannot be defined in a friend declaration
665: "asm" is not allowed
666: "asm" must be used with a function definition
667: "asm" function is nonstandard
668: ellipsis with no explicit parameters is nonstandard
669: "&..." is nonstandard
670: invalid use of "&..."
672: temporary used for initial value of reference to const volatile (anachronism)
673: a reference of type <type> cannot be initialized with a value of type <type>
674: initial value of reference to const volatile must be an lvalue
676: using out-of-scope declaration of <entity>
678: call of <entity> cannot be inlined
679: <entity> cannot be inlined
680: invalid PCH directory:
688: <entity> not found on pack alignment stack
689: empty pack alignment stack
690: RTTI option can be used only when compiling C++
691: <entity>, required for copy that was eliminated, is inaccessible
692: <entity>, required for copy that was eliminated, is not callable because reference parameter cannot be bound to rvalue
693: <typeinfo> must be included before typeid is used
694: <entity> cannot cast away const or other type qualifiers
695: the type in a dynamic_cast must be a pointer or reference to a complete class type, or void *
696: the operand of a pointer dynamic_cast must be a pointer to a complete class type
697: the operand of a reference dynamic_cast must be an lvalue of a complete class type
698: the operand of a runtime dynamic_cast must have a polymorphic class type
699: bool option can be used only when compiling C++
702: expected an "="
703: expected a declarator in condition declaration
704: <entity>, declared in condition, may not be redeclared in this scope
705: default template arguments are not allowed for function templates
706: expected a "," or ">"
707: expected a template parameter list
708: incrementing a bool value is deprecated
709: bool type is not allowed
710: offset of base class <entity> within class <entity> is too large
711: expression must have bool type (or be convertible to bool)
712: array new and delete option can be used only when compiling C++
713: <entity> is not a variable name
717: the type in a const_cast must be a pointer, reference, or pointer to member to an object type
718: a const_cast can only adjust type qualifiers; it cannot change the underlying type
719: mutable is not allowed
720: redeclaration of <entity> is not allowed to alter its access
722: use of alternative token "<:" appears to be unintended
723: use of alternative token "%:" appears to be unintended
724: namespace definition is not allowed
725: name must be a namespace name
726: namespace alias definition is not allowed
727: namespace-qualified name is required
728: a namespace name is not allowed
730: <entity> is not a class template
731: array with incomplete element type is nonstandard
732: allocation operator may not be declared in a namespace
733: deallocation operator may not be declared in a namespace
734: <entity> conflicts with using-declaration of <entity>
735: using-declaration of <entity> conflicts with <entity>
736: namespaces option can be used only when compiling C++
737: using-declaration ignored -- it refers to the current namespace
738: a class-qualified name is required
744: incompatible memory attributes specified
745: memory attribute ignored
746: memory attribute may not be followed by a nested declarator
747: memory attribute specified more than once
748: calling convention specified more than once
749: a type qualifier is not allowed
750: <entity> was used before its template was declared
751: static and nonstatic member functions with same parameter types cannot be overloaded
752: no prior declaration of <entity>
753: a template-id is not allowed
754: a class-qualified name is not allowed
755: <entity> may not be redeclared in the current scope
756: qualified name is not allowed in namespace member declaration
757: <entity> is not a type name
758: explicit instantiation is not allowed in the current scope
759: <entity> cannot be explicitly instantiated in the current scope
760: <entity> explicitly instantiated more than once
761: typename may only be used within a template
763: typename option can be used only when compiling C++
764: implicit typename option can be used only when compiling C++
765: nonstandard character at start of object-like macro definition
766: exception specification for virtual <entity> is incompatible with that of overridden <entity>
767: conversion from pointer to smaller integer
768: exception specification for implicitly declared virtual <entity> is incompatible with that of overridden <entity>
769: <entity>, implicitly called from <entity>, is ambiguous
770: option "explicit" can be used only when compiling C++
771: "explicit" is not allowed
772: declaration conflicts with <entity> (reserved class name)
773: only "()" is allowed as initializer for array <entity>
774: "virtual" is not allowed in a function template declaration
775: invalid anonymous union -- class member template is not allowed
776: template nesting depth does not match the previous declaration of <entity>
777: this declaration cannot have multiple "template <...>" clauses
778: option to control the for-init scope can be used only when compiling C++
779: <entity>, declared in for-loop initialization, may not be redeclared in this scope
780: reference is to <entity> -- under old for-init scoping rules it would have been <entity>
781: option to control warnings on for-init differences can be used only when compiling C++
782: definition of virtual <entity> is required here
783: empty comment interpreted as token-pasting operator "##"
784: a storage class is not allowed in a friend declaration
785: template parameter list for <entity> is not allowed in this declaration
786: <entity> is not a valid member class or function template
787: not a valid member class or function template declaration
788: a template declaration containing a template parameter list may not be followed by an explicit specialization declaration
789: explicit specialization of <entity> must precede the first use of <entity>
790: explicit specialization is not allowed in the current scope
791: partial specialization of <entity> is not allowed
792: <entity> is not an entity that can be explicitly specialized
793: explicit specialization of <entity> must precede its first use
794: template parameter <entity> may not be used in an elaborated type specifier
795: specializing <entity> requires "template<>" syntax
798: option old_specializations can be used only when compiling C++
799: specializing <entity> without "template<>" syntax is nonstandard
800: this declaration may not have extern "C" linkage
801: <entity> is not a class or function template name in the current scope
802: specifying a default argument when redeclaring an unreferenced function template is nonstandard
803: specifying a default argument when redeclaring an already referenced function template is not allowed
804: cannot convert pointer to member of base class <type> to pointer to member of derived class <type> -- base class is virtual
805: exception specification is incompatible with that of <entity><entity>
806: omission of exception specification is incompatible with <entity>
807: unexpected end of default argument expression
808: default-initialization of reference is not allowed
809: uninitialized <entity> has a const member
810: uninitialized base class <type> has a const member
811: const <entity> requires an initializer -- class <type> has no explicitly declared default constructor
812: const object requires an initializer -- class <type> has no explicitly declared default constructor
814: strict mode is incompatible with long preserving rules
815: type qualifier on return type is meaningless
For example:
__packed void foo( void ) { }
The __packed qualifier is ignored because the return type cannot be __packed.
816: in a function definition a type qualifier on a "void" return type is not allowed
817: static data member declaration is not allowed in this class
818: template instantiation resulted in an invalid function declaration
819: "..." is not allowed
821: extern inline <entity> was referenced but not defined
822: invalid destructor name for type <type>
824: destructor reference is ambiguous -- both <entity> and <entity> could be used
825: <entity> could be used
826: <entity> was never referenced
827: only one member of a union may be specified in a constructor initializer list
828: support for "new[]" and "delete[]" is disabled
829: "double" used for "long double" in generated C code
830: <entity> has no corresponding operator delete<entity> (to be called if an exception is thrown during initialization of an allocated object)
831: support for placement delete is disabled
832: no appropriate operator delete is visible
833: pointer or reference to incomplete type is not allowed
834: invalid partial specialization -- <entity> is already fully specialized
835: incompatible exception specifications
836: returning reference to local variable
837: omission of explicit type is nonstandard ("int" assumed)
A function has been declared or defined with no return type.
Example, with the code:
foo(void){
    int a;
}
an int result is assumed.
If you want it to return no result, use void as the return type. This is widespread in old-style C.
The --diag_suppress 837 option suppresses this warning.
See also message number 938, that is a special case of this message for main().
838: more than one partial specialization matches the template argument list of <entity>
840: a template argument list is not allowed in a declaration of a primary template
841: partial specializations may not have default template arguments
842: <entity> is not used in template argument list of <entity>
844: the template argument list of the partial specialization includes a nontype argument whose type depends on a template parameter
845: this partial specialization would have been used to instantiate <entity>
846: this partial specialization would have been made the instantiation of <entity> ambiguous
847: expression must have integral or enum type
848: expression must have arithmetic or enum type
849: expression must have arithmetic, enum, or pointer type
850: type of cast must be integral or enum
851: type of cast must be arithmetic, enum, or pointer
852: expression must be a pointer to a complete object type
854: a partial specialization nontype argument must be the name of a nontype parameter or a constant
855: return type is not identical to return type <type> of overridden virtual function <entity>
856: option "guiding_decls" can be used only when compiling C++
857: a partial specialization of a class template must be declared in the namespace of which it is a member
858: <entity> is a pure virtual function
859: pure virtual <entity> has no overrider
860: __declspec attributes ignored
861: invalid character in input line
862: function returns incomplete type <type>
863: effect of this "#pragma pack" directive is local to <entity>
864: <entity> is not a template
865: a friend declaration may not declare a partial specialization
866: exception specification ignored
867: declaration of "size_t" does not match the expected type <type>
868: space required between adjacent ">" delimiters of nested template argument lists (">>" is the right shift operator)
869: could not set locale <entity> to allow processing of multibyte characters
870: invalid multibyte character sequence
871: template instantiation resulted in unexpected function type of <type> (the meaning of a name may have changed since the template declaration -- the type of the template is <type>)
872: ambiguous guiding declaration -- more than one function template <entity> matches type <type>
873: non-integral operation not allowed in nontype template argument
884: pointer-to-member representation <entity> has already been set for <entity>
885: <type> cannot be used to designate constructor for <type>
886: invalid suffix on integral constant
890: variable length array with unspecified bound is not allowed
891: an explicit template argument list is not allowed on this declaration
892: an entity with linkage cannot have a type involving a variable length array
893: a variable length array cannot have static storage duration
894: <entity> is not a template
895: variable length array dimension (declared <entity>)
896: expected a template argument
902: type qualifier ignored
912: ambiguous class member reference -- <entity> used in preference to <entity>
915: a segment name has already been specified
916: cannot convert pointer to member of derived class <type> to pointer to member of base class <type> -- base class is virtual
917: invalid directory for instantiation files:
921: an instantiation information file name may not be specified when compiling several input files
923: more than one command line option matches the abbreviation "--<entity>":
925: type qualifiers on function types are ignored
926: cannot open definition list file: <entity>
928: incorrect use of va_start
929: incorrect use of va_arg
930: incorrect use of va_end
931: pending instantiations option can be used only when compiling C++
932: invalid directory for #import files:
934: a member with reference type is not allowed in a union
935: "typedef" may not be specified here
936: redeclaration of <entity> alters its access
937: a class or namespace qualified name is required
938: return type "int" omitted in declaration of function "main"
main() has been declared or defined with no return type.
For example:
main(void){
  int a;
}
is reported as an error by the compiler if compiled with --strict.
If you want it to return no result, use void as the return type. This is widespread in old-style C.
For ANSI C, the --diag_suppress 938 option suppresses this warning.
For C++, this always results in an error.
See also message number 837 for more general cases.
939: pointer-to-member representation <entity> is too restrictive for <entity>
940: missing return statement at end of non-void <entity>
A return type has been defined for a function, but no value is returned.
Example:
int foo(int a)
{
  printf("Hello %d", a);
}
941: duplicate using-declaration of <entity> ignored
942: enum bit-fields are always unsigned, but enum <type> includes negative enumerator
943: option "class_name_injection" can be used only when compiling C++
944: option "arg_dep_lookup" can be used only when compiling C++
945: option "friend_injection" can be used only when compiling C++
946: name following "template" must be a template
949: specifying a default argument on this declaration is nonstandard
951: return type of function "main" must be "int"
952: a nontype template parameter may not have class type
953: a default template argument cannot be specified on the declaration of a member of a class template outside of its class
954: a return statement is not allowed in a handler of a function try block of a constructor
955: ordinary and extended designators cannot be combined in an initializer designation
956: the second subscript must not be smaller than the first
959: declared size for bit field is larger than the size of the bit field type; truncated to <entity> bits
960: type used as constructor name does not match type <type>
961: use of a type with no linkage to declare a variable with linkage
962: use of a type with no linkage to declare a function
963: return type may not be specified on a constructor
964: return type may not be specified on a destructor
965: incorrectly formed universal character name
966: universal character name specifies an invalid character
967: a universal character name cannot designate a character in the basic character set
968: this universal character is not allowed in an identifier
969: the identifier __VA_ARGS__ can only appear in the replacement lists of variadic macros
970: the qualifier on this friend declaration is ignored
971: array range designators cannot be applied to dynamic initializers
972: property name cannot appear here
975: a variable-length array type is not allowed
976: a compound literal is not allowed in an integral constant expression
977: a compound literal of type <type> is not allowed
978: a template friend declaration cannot be declared in a local class
979: ambiguous "?" operation: second operand of type <type> can be converted to third operand type <type>, and vice versa
980: call of an object of a class type without appropriate operator() or conversion functions to pointer-to-function type
982: there is more than one way an object of type <type> can be called for the argument list:
983: typedef name has already been declared (with similar type)
984: operator new and operator delete cannot be given internal linkage
985: storage class "mutable" is not allowed for anonymous unions
986: invalid precompiled header file
987: abstract class type <type> is not allowed as catch type:
988: a qualified function type cannot be used to declare a nonmember function or a static member function
989: a qualified function type cannot be used to declare a parameter
990: cannot create a pointer or reference to qualified function type
991: extra braces are nonstandard
992: invalid macro definition:
Incorrect use of -D on the compile line, for example, "-D##"
993: subtraction of pointer types <type> and <type> is nonstandard
994: an empty template parameter list is not allowed in a template template parameter declaration
995: expected "class"
996: the "class" keyword must be used when declaring a template template parameter
997: <entity> is hidden by <entity> -- virtual function override intended?
998: a qualified name is not allowed for a friend declaration that is a function definition
999: <entity> is not compatible with <entity>
1000: a storage class may not be specified here
1001: class member designated by a using-declaration must be visible in a direct base class
1006: a template template parameter cannot have the same name as one of its template parameters
1007: recursive instantiation of default argument
1009: <entity> is not an entity that can be defined
1010: destructor name must be qualified
1011: friend class name may not be introduced with "typename"
1012: a using-declaration may not name a constructor or destructor
1013: a qualified friend template declaration must refer to a specific previously declared template
1014: invalid specifier in class template declaration
1015: argument is incompatible with formal parameter
1016: prefix form of ARM function qualifier not permitted in this position
1017: Duplicate ARM function qualifiers not permitted
1018: ARM function qualifiers not permitted on this declaration/definition
Examples of ARM function qualifiers are __svc, __pure, and __irq.
See the following in the armcc User Guide:
1019: function qualifier <entity> not permitted on a non-static member function
1020: __irq functions must take no arguments
1021: __irq functions must return no result
1022: cannot have pointer nor reference to <entity> function
1023: __global_reg not allowed on this declaration
1024: invalid global register number; 1 to 8 allowed
An invalid register is being used in __global_reg.
Example:
__global_reg(786) int x;
1025 : __svc parameter <entity> is not within permitted range (0 to 0xffffff) for ARM SVC instruction
SVC numbers are limited to the range 0 to 0xffffff for ARM code, and 0 to 0xFF for Thumb code.
For standard semihosting SVCs, 0x123456 is used for ARM code and 0xAB is used for Thumb code.
1026: taking the address of a global register variable is not allowed
1027: __svc_indirect function must have arguments
1028: conflicting global register declaration with <entity>
1029: __packed ignored for non-pointer parameter
1030: <entity> <type> previously declared without __packed
1031: Definition of <type> in packed <type> must be __packed
The compiler faults a non-packed child structure contained in a packed parent structure. This includes the case where the substructure is an array.
For example:
typedef struct ChildStruct {
 int a;
 } ChildStruct;
typedef __packed struct ParentStruct {
   ChildStruct child[1];
 } ParentStruct;
results in the message:
Error: #1031: Definition of "ChildStruct" in packed "ParentStruct" must be __packed
See the following in the armcc User Guide:
1032: Definition of nested anonymous <entity> in packed <type> must be __packed
1033: <entity> incompatible with function definition
1034: __irq functions must not be the target of a function call
1038: invalid alignment specified; only integer powers of 2 allowed
1039: conflicting alignment declaration with <entity>
1040: under-alignment not allowed
1041: alignment for an auto object may not be larger than 8
For example:
int main(void){
  __align(16) int foo = 10;
}
__align is not permitted for a local variable foo, so the error is given.
See the following in the armcc User Guide:
1042: <entity> cannot be dynamically initialized when compiled position independent
1043: <entity> cannot be const because it contains a mutable member
For example:
struct foo { int a; mutable int b; };
extern const struct foo bar;
When the compiler is in ROPI or RWPI mode, it disallows const objects from containing mutable members.
The reason for this restriction is that in these modes, the compiler addresses read-only data differently from read-write data. It therefore must know whether an object is in the RO or RW data section. In the following example, this restriction means that bar cannot contain any mutable members and is therefore in the RO data section:
struct foo;
extern const struct foo bar;
const struct foo *get_foo()  { return &bar; }
See the following in the armcc User Guide:
1044: option "dep_name" can be used only when compiling C++
1045: loop in sequence of "operator->" functions starting at class <type>
1046: <entity> has no member class <entity>
1047: the global scope has no class named <entity>
1048: recursive instantiation of template default argument
1049: access declarations and using-declarations cannot appear in unions
1050: <entity> is not a class member
1051: nonstandard member constant declaration is not allowed
1053: option "parse_templates" can be used only when compiling C++
1054: option "dep_name" cannot be used with "no_parse_templates"
1055: language modes specified are incompatible
1056: invalid redeclaration of nested class
1057: type containing an unknown-size array is not allowed
1058: a variable with static storage duration cannot be defined within an inline function
1059: an entity with internal linkage cannot be referenced within an inline function with external linkage
1060: argument type <type> does not match this type-generic function macro
1062: friend declaration cannot add default arguments to previous declaration
1063: <entity> cannot be declared in this scope
1064: the reserved identifier <entity> may only be used inside a function
1065: this universal character cannot begin an identifier
1066: expected a string literal
1070: incorrect use of va_copy
1071: <entity> can only be used with floating-point types
1072: complex type is not allowed
1073: invalid designator kind
1074: floating-point value cannot be represented exactly
1075: complex floating-point operation result is out of range
1077: an initializer cannot be specified for a flexible array member
1079: standard requires that <entity> be given a type by a subsequent declaration ("int" assumed)
1080: a definition is required for inline <entity>
1081: conversion from integer to smaller pointer
1082: a floating-point type must be included in the type specifier for a _Complex or _Imaginary type
1083: Inline assembler syntax error
In ARM Compiler 4.1p2 and earlier, this error can be generated when inline assembly code contains instructions that are not supported by the inline assembler (for example, the WFI instruction). In 4.1p3 and later, including all ARM Compiler 5 versions, the following error is raised instead:
1084: This instruction not permitted in inline assembler
1084: This instruction not permitted in inline assembler
1085: Missing operand
1086: Operand is wrong type
1087: Operand should be constant
1088: Wrong number of operands
1089: Invalid PSR operand
1090: Expected PSR operand
1091: Invalid shift specified
1092: Should be acc0
1093: Must be a modifiable lvalue
1094: Expected a register expression
1095: Expected a label or function name
1096: Instruction cannot be conditional
1097: Expected a [ or ]
1098: Expected a shift operation
1099: Unexpected ]
1100: Register specified shift not allowed
1101: Pre-Indexed addressing not allowed
1102: Post-Indexed addressing not allowed
1103: Writeback not allowed in the addressing mode
1104: Expected {
1105: Expected }
1106: Too many registers in register list
1107: Only ^ valid here
1108: Cannot mix virtual register and C/C++ expressions in register list
1109: Only virtual registers can be specified in a register range
1110: User mode register selection/CPSR update not supported in inline assembler. Use embedded assembler or out-of-line assembler
1111: Expected a coprocessor name
1112: Expected a coprocessor register name
These errors are given by the inline assembler if either of the following occurs:
  • the coprocessor number is accidentally omitted from an MCR or MRC instruction
  • an invalid coprocessor number or coprocessor register number has been given.
This is an example of correct use:
void foo()
{
  int reg0;
  __asm
  {
    MRC p15, 0, reg0, c1, c0, 0
  }
}
1114: this feature not supported on target architecture/processor
Example when compiled with armcc --cpu 4T:
int main(void) {
  int a,b,c;
  __asm {
  QADD a,b,c
  }
  return(a);
}
results in an error message because the saturated add instruction is only supported in ARMv5TE and later.
1115: Cannot assign to const operand
1116: Register list cannot be empty
1117: Unqualified virtual function not allowed
1118: Expected a newline
1119: Reference to static variable not allowed in __asm function
1120: Reference to static function not allowed in __asm function
1121: Pointer to data member not allowed in __asm function
1122: __asm function cannot have static qualifier
1123: base class <type> is a virtual base class of <type>
1124: base class <type> is not virtual base class of <type>
1125: <entity> has no member function <entity>
1126: "__asm" is not allowed in this declaration
1127: Member initializer list not permitted for __asm constructors
1128: try block not permitted for __asm constructors
1129: Order of operands not compatible with previous compiler versions
1130: __align not permitted in typedef
1131: Non portable instruction (LDM with writeback and base in reg. list, final value of base unpredictable)
1132: Non portable instruction (STM with writeback and base not first in reg. list, stored value of base unpredictable)
1133: Expression operands not permitted with virtual base register
1134: literal treated as "long long"
The constant is too large to be represented in a signed long, and therefore has been treated as a (signed) long long.
For example:
int foo(unsigned int bar) 
{   return (bar == 2147483648); 
} 
gives a warning because 2147483648 is one greater than the maximum value permitted for a signed long. To eliminate the warning, if the constant should be treated as a (64-bit) long long type rather than a signed long, explicitly add an ll or LL suffix, or, if it should be treated as an unsigned integer, add a U suffix.
For example:
int foo(unsigned int bar) 
{ 
  return (bar == 2147483648U); 
} 
See the following in the armcc User Guide:
1135: literal treated as "unsigned long long"
The constant is too large to be represented in a signed long long, and therefore has been given type unsigned long long. See also error number 1134.
1137: Expected a comma
1138: Unexpected comma after this expression
1139: MRRC operation opcode must lie in range 0-15
1140: MCRR operation opcode must lie in range 0-15
1141: CDP operation opcode must lie in range 0-15
1142: MRC operation opcode must lie in range 0-7
1143: MCR operation opcode must lie in range 0-7
1144: opcode_2 must lie in range 0-7
1145: LDC/STC extra opcode must lie in range 0-255
1146: LDC/STC offset must lie in range -1020 to 1020 and be word aligned
1147: Constant operand out of range
1148: floating-point operator is not permitted with --fpu=none
1149: floating-point return type in function definition is not permitted with -fpu=none
1150: floating-point parameter type in function definition is not permitted with -fpu=none
1151: floating-point variable definition with initialiser is not permitted with -fpu=none
1152: polymorphic base classes need to be exported as well
1153: Cannot assign physical registers in this register list
1154: Can only specify an even-numbered physical register here
1155: Can only specify an assignment to a physical register here
1156: Can only specify an assignment from a physical register here
1157: Can only specify physical registers in a corrupted register list
1158: PSR operand not valid here
1159: Expected an unambiguous label or function name
1160: Calls to destructors for temporaries will overwrite the condition flags updated by this instruction
1161: Cannot directly modify the stack pointer SP (r13)
1162: Cannot directly modify the link register LR (r14)
1163: Cannot directly modify the program counter PC (r15)
1164: Offset must be word-aligned
1165: types cannot be declared in anonymous unions
1166: returning pointer to local variable
1167: returning pointer to local temporary
1168: option "export" can be used only when compiling C++
1169: option "export" cannot be used with "no_dep_name"
1170: option "export" cannot be used with "implicit_include"
1171: declaration of <entity> is incompatible with a declaration in another translation unit
1172: the other declaration is <entity>
1175: a field declaration cannot have a type involving a variable length array
1176: declaration of <entity> had a different meaning during compilation of <entity>
1177: expected "template"
1178: "export" cannot be used on an explicit instantiation
1179: "export" cannot be used on this declaration
1180: a member of an unnamed namespace cannot be declared "export"
1181: a template cannot be declared "export" after it has been defined
1182: a declaration cannot have a label
1183: support for exported templates is disabled
1184: cannot open exported template file: <entity>
1185: <entity> already defined during compilation of <entity>
1186: <entity> already defined in another translation unit
1188: the option to list makefile dependencies may not be specified when compiling more than one translation unit
1190: the option to generate preprocessed output may not be specified when compiling more than one translation unit
1191: a field with the same name as its class cannot be declared in a class with a user-declared constructor
1192: "implicit_include" cannot be used when compiling more than one translation unit
1193: exported template file <entity> is corrupted
1194: <entity> cannot be instantiated -- it has been explicitly specialized in the translation unit containing the exported definition
1196: the object has cv-qualifiers that are not compatible with the member <entity>
1197: no instance of <entity> matches the argument list and object (the object has cv-qualifiers that prevent a match)
1198: an attribute specifies a mode incompatible with <type>
1199: there is no type with the width specified
1200: invalid alignment value specified by attribute
1201: invalid attribute for <type>
1202: invalid attribute for <entity>
1203: invalid attribute for parameter
1204: attribute <entity> does not take arguments
1207: attribute <entity> ignored
1208: attributes may not appear here
1209: invalid argument to attribute <entity>
1210: the "packed" attribute is ignored in a typedef
1211: in "goto *expr" expr must have type "void *"
1212: "goto *expr" is nonstandard
1213: taking the address of a label is nonstandard
1214: file name specified more than once:
1215: #warning directive: <entity>
1216: attribute <entity> is only allowed in a function definition
1217: the "transparent_union" attribute only applies to unions, and <type> is not a union
1218: the "transparent_union" attribute is ignored on incomplete types
1219: <type> cannot be transparent because <entity> does not have the same size as the union
1220: <type> cannot be transparent because it has a field of type <type> which is not the same size as the union
1221: only parameters can be transparent
1222: the <entity> attribute does not apply to local variables
1224: attributes are not permitted in a function definition
1225: declarations of local labels should only appear at the start of statement expressions
1226: the second constant in a case range must be larger than the first
1227: an asm name is not permitted in a function definition
1228: an asm name is ignored in a typedef
1229: unknown register name "<entity>"
1230: modifier letter '<entity>' ignored in asm operand
1231: unknown asm constraint modifier '<entity>'
1232: unknown asm constraint letter '<entity>'
1233: asm operand has no constraint letter
1234: an asm output operand must have one of the '=' or '+' modifiers
1235: an asm input operand may not have the '=' or '+' modifiers
1236: too many operands to asm statement (maximum is 30; '+' modifier adds an implicit operand)
1237: too many colons in asm statement
1238: register "<entity>" used more than once
1239: register "<entity>" is both used and clobbered
1240: register "<entity>" clobbered more than once
1241: register "<entity>" has a fixed purpose and may not be used in an asm statement
1242: register "<entity>" has a fixed purpose and may not be clobbered in an asm statement
1243: an empty clobbers list must be omitted entirely
1244: expected an asm operand
1245: expected a register to clobber
1246: "format" attribute applied to <entity> which does not have variable arguments
1247: first substitution argument is not the first variable argument
1248: format argument index is greater than number of parameters
1249: format argument does not have string type
1250: the "template" keyword used for syntactic disambiguation may only be used within a template
1253: attribute does not apply to non-function type <type>
1254: arithmetic on pointer to void or function type
1255: storage class must be auto or register
1256: <type> would have been promoted to <type> when passed through the ellipsis parameter; use the latter type instead
1257: <entity> is not a base class member
1262: mangled name is too long
1263: Offset must be half-word aligned
1264: Offset must be double-word aligned
1265: converting to and from floating-point type is not permitted with --fpu=none
1266: Operand should be a constant expression
1267: Implicit physical register <entity> should be defined as a variable
1268: declaration aliased to unknown entity <entity>
1269: declaration does not match its alias <entity>
1270: entity declared as alias cannot have definition
1271: variable-length array field type will be treated as zero-length array field type
1272: nonstandard cast on lvalue not supported
1273: unrecognized flag name
1274: void return type cannot be qualified
1275: the auto specifier is ignored here (invalid in standard C/C++)
1276: a reduction in alignment without the "packed" attribute is ignored
1277: a member template corresponding to <entity> is declared as a template of a different kind in another translation unit
1278: excess initializers are ignored
1279: va_start should only appear in a function with an ellipsis parameter
1282: variable <entity> cannot be used in a register range
1283: A physical register name is required here
1284: A register range cannot be specified here
1285: Implicit physical register <entity> has not been defined
1286: LDRD/STRD instruction will be expanded
When LDRD and STRD instructions are used in inline assembler the compiler expands these into two LDR or STR instructions before being passed through the compiler optimization stage.
The optimization stage normally combines the two LDR or STR instruction back into a single LDRD or STRD instruction, however it is possible in some cases that a LDRD or STRD is not used.
1287: LDM/STM instruction may be expanded
The compiler expands LDM and STM instructions in inline assembly code into a number of LDR or STR instructions, before passing through the compiler optimization stage.
The optimization stage normally changes the LDR or STR instructions back into LDM or STM instructions, although it is possible that in some cases a single LDM or STM instruction is not used.
1288: Implicit ARM register <entity> was not defined due to name clash
1289: statement expressions are only allowed in block scope
1291: an asm name is ignored on a non-register automatic variable
1292: inline function also declared as an alias; definition ignored
1293: assignment in condition
In a context where a boolean value is required, for example in the controlling expression for an if, while, or for statement, or the first operand of a conditional expression, the expression contains one of the following instead:
  • A bitwise not operator (~). It is likely that a logical not operator (!) was intended.
  • An assignment operator (=). This could be a mis-typed equality operator (==). For example:
    int main(void) 
    { 
      int a,b; 
      if (a=b); 
    } 
    
In either case, if the operator was used intentionally, it might be possible to suppress the warning by adding an explicit comparison against zero.
For example, change the if statement in the example to:
  if ((a=b)!=0);
This warning can also be suppressed by using the --diag_suppress 1293 option.
See also message number 187, which applies when you compare against a constant.
1294: Old-style function <entity>
The compiler accepts both old-style and new-style function declarations. The difference between them is shown in the following example:
// new style 
int add2(int a, int b) 
{ 
  return a+b; 
} 
// old style 
int oldadd2(a,b) 
int a; 
int b; 
{ 
  return a+b; 
} 
When compiling old-style functions in C mode, the compiler reports:
Warning: #1294-D: Old-style function oldadd2 
1295: Deprecated declaration <entity> - give arg types
This warning is normally given when a declaration without argument types is encountered in ANSI C mode. In ANSI C, declarations like this are deprecated. However, it is sometimes useful to suppress this warning with the --diag_suppress 1295 option when porting old code.
In C++:
void foo(); 
means:
void foo(void); 
and no warning is generated.
1296: extended constant initialiser used
The expression used as a constant initializer might not be portable.
This warns that there is a constant initializer that does not follow the strict rules of ANSI C.
The solution is to rewrite your code to be ANSI compliant.
The following examples show code that generates this warning, and suggest potential alternatives for achieving the same goal with ANSI C compliant code.
Compiling with --diag_suppress 1296 suppresses the warning.
Example 1:
This code generates warning 1296 when x and y are static objects, that is, global variables or static local variables, because the C standard does not permit a cast of a pointer to an integer in a constant expression:
int x;
int y = (int) &x;
ANSI C requires the initializer for a static object to be a constant expression. (int) &x is not considered to be a constant expression.
Be aware that addresses are not arithmetic types, so this example C code is disallowed for ANSI C. Unfortunately, this is a common ANSI non-compliance amongst other compilers, and can result in problems when porting legacy code to ARM. This is why the ARM compiler issues a warning rather than an error.
An ANSI C compliant alternative method would be to rewrite the code so that y is a pointer to x:
int x;
int* y = &x;
Example 2:
This code, compiled with the --c90 switch, generates warning 1296:
const int foo_table[] = { (int)"foo", 0, 1, 2}; 
An ANSI C compliant alternative method would be to rewrite the code as follows:
const char* foo_table[] = { "foo", 0, (char*)1, (char*)2};
Example 3:
This code generates warning 1296 because the C standard does not permit a cast of a pointer to a long integer in a constant expression:
char value;
long array[] = {
    (long)&value,
    (long)"string"
};
An ANSI C compliant alternative method would be to rewrite the code to use pointers:
char value;
char *array[] = {
    (char*)&value,
    (char*)"string"
};
This solution works because pointer-to-pointer casts are allowed in C.
1297: Header file not guarded against multiple inclusion
This warning is given when an unguarded header file is #included.
An unguarded header file is a header file not wrapped in a declaration such as:
#ifdef foo_h 
#define foo_h 
/* body of include file */ 
#endif 
This warning is off by default. It can be enabled with:
--diag_warning 1297
1298: Header file is guarded by '<entity>', but does not #define it
Example:
#ifndef MYHEADER_H 
//#define MYHEADER_H 
#endif 
To correct the code, remove the comment slashes (//). This warning is off by default. It can be enabled with:
--diag_warning 1298
1299: members and base-classes will be initialized in declaration order, not in member initialisation list order
1300: <entity> inherits implicit virtual
This warning is issued when a non-virtual member function of a derived class hides a virtual member of a parent class. For example:
struct Base { virtual void f(); };
struct Derived : Base { void f(); };
results in the message:
Warning: #1300-D: f inherits implicit virtual
struct Derived : Base { void f(); };
                             ^
Adding the virtual keyword in the derived class prevents the warning. For C++, specifying the --diag_suppress 1300 option suppresses the implicit virtual warning.
1301: padding inserted in struct <entity>
For the members of the structure to be correctly aligned, some padding has been inserted between members. This warning is off by default and can be enabled with --diag_warning 1301 or --remarks.
For example:
struct X {
  char x;
  int y;
}
results in the message:
Warning: #1301-D: padding inserted in struct X
The compiler can also warn of padding added at the end of a struct or between structs, see message number 2530.
1302: type too large to be returned in registers - __value_in_regs ignored
1303: using --force_new_nothrow: added "throw()"
1304: operator new missing exception specification
1305: using --force_new_nothrow: added "(::std::nothrow)"
1307: floating point argument not permitted with -fpu=none
1308: Base class <type> of __packed class <type> must be __packed
1310: shared block size does not match one previously specified
1311: bracketed expression is assumed to be a block size specification rather than an array dimension
1312: the block size of a shared array must be greater than zero
1313: multiple block sizes not allowed
1314: strict or relaxed requires shared
1316: block size specified exceeds the maximum value of <entity>
1317: function returning shared is not allowed
1320: shared type inside a struct or union is not allowed
1321: parameters may not have shared types
1323: shared variables must be static or extern
1327: affinity expression must have a shared type or point to a shared type
1328: affinity has shared type (not pointer to shared)
1329: shared void* types can only be compared for equality
1331: null (zero) character in input line ignored
1332: null (zero) character in string or character constant
1333: null (zero) character in header name
1334: declaration in for-initializer hides a declaration in the surrounding scope
1335: the hidden declaration is <entity>
1336: the prototype declaration of <entity> is ignored after this unprototyped redeclaration
1338: <entity> must have external C linkage
1339: variable declaration hides declaration in for-initializer
1340: typedef <entity> may not be used in an elaborated type specifier
1341: call of zero constant ignored
1342: parameter <entity> may not be redeclared in a catch clause of function try block
1343: the initial explicit specialization of <entity> must be declared in the namespace containing the template
1345: "template" must be followed by an identifier
1347: layout qualifier cannot qualify pointer to shared
1348: layout qualifier cannot qualify an incomplete array
1349: declaration of <entity> hides handler parameter
1350: nonstandard cast to array type ignored
1351: this pragma cannot be used in a _Pragma operator (a #pragma directive must be used)
1352: field uses tail padding of a base class
1353: GNU C++ compilers may use bit field padding
1354: memory mapping conflict with precompiled header file <entity>
1355: abstract class <type> has a non-virtual destructor, calling delete on a pointer to this class is undefined behaviour
1356: an asm name is not allowed on a nonstatic member declaration
1357: static initialisation of <entity> using address of <entity> may cause link failure <option>
See error number 1359.
1358: static initialisation of extern const <entity> using address of <entity> cannot be lowered for ROPI
1359: static initialisation of <entity> using address of <entity> may cause link failure <option>
Warnings 1357 and 1359 highlight code constructs that are not position independent (PI) and that might cause a subsequent link step to fail.
The following code, when compiled with --apcs /ropi:
char *str = "test"; /* global pointer */
results in the message:
Warning: #1357-D: static initialisation of variable "str" using address of string literal may cause link failure --ropi
because the global pointer str must be initialized to the address of the char string test in the .constdata section, but absolute addresses cannot be used in a PI system.
The following code, when compiled with --apcs /rwpi:
int bar;
int *foo = &bar; /* global pointer */
results in the message:
Warning: #1359-D: static initialisation of variable "foo" using address of bar may cause link failure --rwpi
because the global pointer foo must be initialized to the address of bar in the .data section, but absolute addresses cannot be used in a PI system.
The following workarounds are possible:
  • Change your code to avoid use of a global pointer. You can, for example, use a global array or local pointer instead.
  • Do the initialization at run-time, for example:
    int bar;
    int *foo;
    
    Then write code inside a function that sets foo = &bar;. This is because when generating code as opposed to statically initializing data, the compiler has scope to work around the ROPI/RWPI constraints.
See also the linker error L6248E.
1360: static initialisation of extern const <entity> using address of <entity> cannot be lowered for RWPI
For example, when compiled with --apcs /rwpi:
extern int y;
int* const x = &y;
int* foo()
{
  return(x);
}
produces a warning because prefixing y by extern prevents the compiler defining a direct address offset between the variables x and y.
1361: <entity> was declared "deprecated"
1362: unrecognized format function type <entity> ignored
1363: base class <entity> uses tail padding of base class <entity>
1366: this anonymous union/struct field is hidden by <entity>
1367: invalid error number
1368: invalid error tag
1369: expected an error number or error tag
1370: size of class is affected by tail padding
1371: labels can be referenced only in function definitions
1372: transfer of control into a statement expression is not allowed
1374: transfer of control out of a statement expression is not allowed
1375: a non-POD class definition is not allowed inside of a statement expression
1376: destructible entities are not allowed inside of a statement expression
1377: a dynamically-initialized local static variable is not allowed inside of a statement expression
1378: a variable-length array is not allowed inside of a statement expression
1379: a statement expression is not allowed inside of a default argument
1382: nonstandard conversion between pointer to function and pointer to data
1383: interface types cannot have virtual base classes
1384: interface types cannot specify "private" or "protected"
1385: interface types can only derive from other interface types
1386: <type> is an interface type
1387: interface types cannot have typedef members
1388: interface types cannot have user-declared constructors or destructors
1389: interface types cannot have user-declared member operators
1390: interface types cannot be declared in functions
1391: cannot declare interface templates
1392: interface types cannot have data members
1393: interface types cannot contain friend declarations
1394: interface types cannot have nested classes
1395: interface types cannot be nested class types
1396: interface types cannot have member templates
1397: interface types cannot have static member functions
1398: this pragma cannot be used in a __pragma operator (a #pragma directive must be used)
1399: qualifier must be base class of <type>
1400: declaration must correspond to a pure virtual member function in the indicated base class
1401: integer overflow in internal computation due to size or complexity of <type>
1402: integer overflow in internal computation
1404: potentially narrowing conversion when compiled in an environment where int, long, or pointer types are 64 bits wide
1405: current value of pragma pack is <entity>
1406: arguments for pragma pack(show) are ignored
1407: invalid alignment specifier value
1408: expected an integer literal
1409: earlier __declspec(align(...)) ignored
1410: expected an argument value for the <entity> attribute parameter
1411: invalid argument value for the <entity> attribute parameter
1412: expected a boolean value for the <entity> attribute parameter
1413: a positional argument cannot follow a named argument in an attribute
1414: attribute <filename> has no parameter named <filename>
1415: expected an argument list for the <entity> attribute
1416: expected a "," or "]"
1417: attribute argument <entity> has already been given a value
1418: a value cannot be assigned to the <entity> attribute
1419: a throw expression may not have pointer-to-incomplete type
1420: alignment-of operator applied to incomplete type
1421: <entity> may only be used as a standalone attribute
1422: <entity> attribute cannot be used here
1423: unrecognized attribute <entity>
1424: attributes are not allowed here
1425: invalid argument value for the <entity> attribute parameter
1426: too many attribute arguments
1427: conversion from inaccessible base class <type> is not allowed
1428: option "export" requires distinct template signatures
1429: string literals with different character kinds cannot be concatenated
1430: GNU layout bug not emulated because it places virtual base <entity> outside <entity> object boundaries
1431: virtual base <entity> placed outside <entity> object boundaries
1432: nonstandard qualified name in namespace member declaration
1433: reduction in alignment ignored
1434: const qualifier ignored
1436: __breakpoint argument must be an integral compile-time constant
1437: __breakpoint argument must be within 0-65535 when compiling for ARM
1438: __breakpoint argument must be within 0-255 when compiling for Thumb
1439: BKPT instruction is not supported on target architecture/processor
1440: oversize bitfield layout will change -- consider preceeding with "<entity>:0;"
1441: nonstandard cast on lvalue
The C specification states "An assignment operator shall have a modifiable lvalue as its left operand" and "a cast does not yield an lvalue".
1442: polymorphic base classes need to be exported if they are to be used for exported derivation
1443: polymorphic base classes inherited via virtual derivation need to be exported
1444: polymorphic base classes inherited via virtual derivation need all virtual functions to be exported
1446: non-POD class type passed through ellipsis
1447: a non-POD class type cannot be fetched by va_arg
The ISO C++ standard defines that the non-required arguments of a variadic function must be of type Plain Old Data (POD), such as an int or a char, but not structs or classes.
To avoid the error or warning, the address of a class or struct could be given instead.
1448: the 'u' or 'U' suffix must appear before the 'l' or 'L' suffix in a fixed-point literal
1450: integer operand may cause fixed-point overflow
1451: fixed-point constant is out of range
1452: fixed-point value cannot be represented exactly
1453: constant is too large for long long; given unsigned long long type (nonstandard)
1454: layout qualifier cannot qualify pointer to shared void
1456: a strong using-directive may only appear in a namespace scope
1457: <entity> declares a non-template function -- add <> to refer to a template instance
1458: operation may cause fixed-point overflow
1459: expression must have integral, enum, or fixed-point type
1460: expression must have integral or fixed-point type
1461: function declared with "noreturn" does return
1462: asm name ignored because it conflicts with a previous declaration
1463: class member typedef may not be redeclared
1464: taking the address of a temporary
1465: attributes are ignored on a class declaration that is not also a definition
1466: fixed-point value implicitly converted to floating-point type
1467: fixed-point types have no classification
1468: a template parameter may not have fixed-point type
1469: hexadecimal floating-point constants are not allowed
1471: floating-point value does not fit in required fixed-point type
1472: value cannot be converted to fixed-point value exactly
1473: fixed-point conversion resulted in a change of sign
1474: integer value does not fit in required fixed-point type
1475: fixed-point operation result is out of range
1481: fixed-point value does not fit in required floating-point type
1482: fixed-point value does not fit in required integer type
1483: value does not fit in required fixed-point type
1485: a named-register storage class is not allowed here
1486: <entity> redeclared with incompatible named-register storage class
1487: named-register storage class cannot be specified for aliased variable
1488: named-register storage specifier is already in use
1492: invalid predefined macro entry at line <entity>: <reason>
1493: invalid macro mode name <entity>
1494: incompatible redefinition of predefined macro <entity>
1495: redeclaration of <entity> is missing a named-register storage class
1496: named register is too small for the type of the variable
1497: arrays cannot be declared with named-register storage class
1498: const_cast to enum type is nonstandard
1500: __svc parameter <entity> is not within permitted range (0 to 0xff) for Thumb SVC instruction
1501: too many arguments for __svc or __svc_indirect function
1502: arguments for __svc or __svc_indirect function must have integral type
1503: __svc_indirect function must have arguments
1504: first argument for __svc_indirect function must have integral type
1505: result of __svc or __svc_indirect function must be returned in integer registers
1506: source file <entity> has bad format
1507: error while writing <entity> file: <reason>
1508: cannot overload functions distinguished by function qualifier alone
1509: function qualifier <entity> not permitted on a virtual member function
1510: function "__attribute__((__<entity>__))" present on overridden virtual function <entity> must be present on overridding function
1511: function qualifier <entity> is not identical on overridden virtual function <entity>
1512: function qualifier <entity> present on overridden virtual function <entity> must be present on overridding function
1514: an empty initializer is invalid for an array with unspecified bound
1515: function returns incomplete class type <type>
1516: <entity> has already been initialized; the out-of-class initializer will be ignored
1517: declaration hides <entity>
1519: invalid suffix on fixed-point or floating-point constant
1522: <entity> has no corresponding member operator delete<entity> (to be called if an exception is thrown during initialization of an allocated object)
1523: a thread-local variable cannot be declared with "dllimport" or "dllexport"
1525: an initializer cannot be specified for a flexible array member whose elements have a nontrivial destructor
1526: an initializer cannot be specified for an indirect flexible array member
1528: variable attributes appearing after a parenthesized initializer are ignored
1529: the result of this cast cannot be used as an lvalue
1530: negation of an unsigned fixed-point value
1531: this operator is not allowed at this point; use parentheses
1532: flexible array member initializer must be constant
1533: register names can only be used for register variables
1534: named-register variables cannot have void type
1535: __declspec modifiers not valid for this declaration
1536: parameters cannot have link scope specifiers
1537: multiple link scope specifiers
1538: link scope specifiers can only appear on functions and variables with external linkage
1539: a redeclaration cannot weaken a link scope
1540: link scope specifier not allowed on this declaration
1541: nonstandard qualified name in global scope declaration
1542: implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1543: explicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
1544: conversion from pointer to same-sized integral type (potential portability problem)
1547: only static and extern variables can use thread-local storage
1548: multiple thread-local storage specifiers
1549: virtual <entity> was not defined (and cannot be defined elsewhere because it is a member of an unnamed namespace)
1550: carriage return character in source line outside of comment or character/string literal
1551: expression must have fixed-point type
1552: invalid use of access specifier is ignored
1553: pointer converted to bool
1554: pointer-to-member converted to bool
1555: storage specifier ignored
1556: dllexport and dllimport are ignored on class templates
1557: base class dllexport/dllimport specification differs from that of the derived class
1558: redeclaration cannot add dllexport/dllimport to <entity>
If this message is suppressed, the behavior is as though the dllexport or dllimport had been omitted. For example:
void f(void);
__declspec(dllimport) void f(void) { } /* suppress treats as
                                          void f(void) { } */
1559: dllexport/dllimport conflict with <entity>; dllexport assumed
This indicates that an entity is marked as both dllimport and dllexport. In this case, the compiler assumes that the entity is dllexport.
In the following example, the function definition foo() conflicts with the declaration __declspec(dllimport) void foo(). In this situation, the compiler assumes dllexport.
---test.cpp---
__declspec(dllimport) void foo();
void foo()
{
}
------------
armcc -c test.cpp
"test.cpp", line 3: Warning: #1559-D: dllexport/dllimport conflict with "foo" (declared at line 1); dllexport assumed
fromelf –s test.o
...
# Symbol Name   Value       Bind Sec Type Vis Size
====================================================================
6 _Z3foov       0x00000000  Gb   1   Code Pr  0x4
...
The warning message and the symbol visibility indicate that the function foo() is dllexport assumed.
1560: cannot define dllimport entity
1561: dllexport/dllimport requires external linkage
1562: a member of a class declared with dllexport/dllimport cannot itself be declared with such a specifier
1563: field of class type without a DLL interface used in a class with a DLL interface
1564: parenthesized member declaration is nonstandard
1565: white space between backslash and newline in line splice ignored
1566: dllexport/dllimport conflict with <entity>; dllimport/dllexport dropped
1567: invalid member for anonymous member class -- class <type> has a disallowed member function
1568: nonstandard reinterpret_cast
1569: positional format specifier cannot be zero
1570: a local class cannot reference a variable-length array type from an enclosing function
1571: member <entity> already has an explicit dllexport/dllimport specifier
1572: a variable-length array is not allowed in a function return type
1573: variable-length array type is not allowed in pointer to member of type <type>
1574: the result of a statement expression cannot have a type involving a variable-length array
1575: Load/Store with translation not supported in inline assembler. Use embedded assembler or out-of-line assembler
1576: Flag-setting multiply instructions not supported in inline assembler. Use embedded assembler or out-of-line assembler
1577: Flag-setting MOV/MVN instructions with constant operand not supported in inline assembler. Use embedded assembler or out-of-line assembler
1578: an asm name is ignored on an automatic variable
1593: Could not optimize: Use of unsigned index prevents optimization
1594: Could not optimize: Loop parameters must be integer for full optimization
1604: Could not optimize: Reference to this function inhibits optimization
1613: Could not optimize: Multiple store conflict
1617: Could not optimize: Loop too complex
1621: Optimization: Dead code eliminated
1624: Could not optimize: Too many overlapping conditions for efficient translation
1629: Could not optimize: Iteration count too short for array optimization
1636: Could not optimize: Complicated use of variable
1637: Unknown pragma - ignored
1638: Unable to determine last value of scalar temporary
1639: Use nolstval directive if possible
1641: Could not optimize: Too many data dependency problems
1656: Problem in pragma syntax
1661: Could not optimize: Backward transfers cannot be optimized
1662: Could not optimize: Last value of promoted scalar required
1663: Could not optimize: Branches out of the loop prevent translation
1670: Optimization: If loop converted to for loop
1676: Could not optimize: This statement prevents loop optimization
1679: Optimization: Loop vectorized
1687: Could not optimize: Reduction function suppressed - needs associative transformation
1690: Could not optimize: Unsupported data type for explicit vector operations
1691: Optimization: Loop fused with previous loop
1714: Could not optimize: Outer loop conditionally executes inner loop
1730: No indexing done along this loop
1742: Could not optimize: Feedback of array elements (equivalenced arrays)
1750: Optimization: Loop re-rolled
1759: Could not optimize: Non-unit stride interferes with vector optimization
1771: Could not optimize: Volatile items prevent analysis
1801: Optimization: Function expanded
1824: Could not optimize: Not enough vector operations to justify translation
1885: Could not optimize: Loop bounds exceed array dimensions
1861: Could not optimize: This store into array prevents optimization of outer loop
1866: Could not optimize: Non-integer subscript
1894: Optimization: Iterations peeled from loop in order to avoid dependence
1896: Optimization: Logical clause simplified
1947: Could not optimize: Cannot transform this combination of data types and operations
1978: Could not optimize: Unable to optimize user-selected loop
1979: Could not optimize: This operation inhibits loop transformation
1987: Optimization: Loop switched
1988: Optimization: Alternate code generated
1997: Optimization: Constant-length loop unrolled
2091: Optimization: Loop unrolled
2168: Optimization: Outer loop moved inside inner loop(s)
2170: Optimization: Invariant expression moved outside of outer loop
2189: Optimization: Loop unrolled and rotated
2190: Optimization: Loop unrolled and optimized
2191: Optimization: Some loads lifted to top of loop
2218: Idiom detected and optimized
2300: Might not be able to optimize: Feedback of scalar value from one loop pass to another. Conflict on line <entity>. Loop index is <entity> (<filename>,<entity>)"
2301: Might not be able to optimize: Feedback of scalar value from one loop pass to another. Conflict on line <entity>. Loop index is <entity> (<filename>)
2302: Might not be able to optimizee: Feedback of scalar value from one loop pass to another. Conflict on line <entity>. (<entity>,<filename>)
2303: Might not be able to optimize: Feedback of scalar value from one loop pass to another. Conflict on line <entity>. (<entity>)
2304: Might not be able to optimize: Potential multiple store conflict between loop iterations. Conflict on line <entity>. Loop index is <entity> (<filename>,<entity>)
2305: Might not be able to optimize: Potential multiple store conflict between loop iterations. Conflict on line <entity>. Loop index is <entity> (<filename>)
2306: Might not be able to optimize: Potential multiple store conflict between loop iterations. Conflict on line <entity>. (<entity>,<filename>)
2307: Might not be able to optimize: Potential multiple store conflict between loop iterations. Conflict on line <entity>. (<entity>)
2308: Might not be able to optimize: Potential feedback between loop iterations. Conflict on line <entity>. Loop index is <entity> (<filename>,<entity>)
2309: Might not be able to optimize: Potential feedback between loop iterations. Conflict on line <entity>. Loop index is <entity> (<filename>)
2310: Might not be able to optimize: Potential feedback between loop iterations. Conflict on line <entity>. (<entity>,<filename>)
2311: Might not be able to optimize: Potential feedback between loop iterations. Conflict on line <entity>. (<entity>)
2312: Could not optimize: Potential pointer aliasing - use restrict qualifier if ok. Conflict on line <entity>. Loop index is <entity> (<filename>,<entity>)
2313: Could not optimize: Potential pointer aliasing - use restrict qualifier if ok. Conflict on line <entity>. Loop index is <entity> (<filename>)
2314: Could not optimize: Potential pointer aliasing - use restrict qualifier if ok. Conflict on line <entity>. (<entity>,<filename>)
2315: Could not optimize: Potential pointer aliasing - use restrict qualifier if ok. Conflict on line <entity>. (<entity>)
2351: Loop nest fused with following nest(s)
2438: Could not inline: Void function used in expression
2439: Could not inline: Identifier declaration
2442: Could not inline: Cannot remove function from expression
2516: High Level Optimization halted: assembly code in routine
2519: Unable to determine constant iteration count for this loop
2524: #pragma pop with no matching #pragma push
#pragma push and #pragma pop save and restore the current pragma state.
Each pop must be paired with a push, so an error is raised for the following code:
#pragma push
;
#pragma pop
;
#pragma pop
2525: #pragma push with no matching #pragma pop
#pragma push and #pragma pop save and restore the current pragma state.
Each push must be paired with a pop.
2529: expression must be an integral constant in range <entity> to <entity>
2530: padding added to end of struct <entity>
The compiler can warn of padding added at the end of a struct or between structs. This warning is off by default. You can enable it with --diag_warning 2530 or --remarks.
For example:
typedef struct { 
  int x; 
  char y; 
} A; 
typedef struct { 
  int p; 
  int q; 
} B; 
results in the message:
Warning: #2530-D: padding added to end of struct 'anonymous' 
The compiler can also warn of padding inserted within a struct, see message number 1301.
2531: dllimport/dllexport applied to a member of an unnamed namespace
2533: the <entity> attribute can only appear on functions and variables with external linkage
2534: strict mode is incompatible with treating namespace std as an alias for the global namespace
2535: in expansion of macro "<entity>" <entity>,
2537: in expansion of macro "<entity>" <entity><entity>
2540: invalid symbolic operand name <entity>
2541: a symbolic match constraint must refer to one of the first ten operands
2544: thread-local variable cannot be dynamically initialized
2546: some enumerator values cannot be represented by the integral type underlying the enum type
2547: default argument is not allowed on a friend class template declaration
2548: multicharacter character literal (potential portability problem)
2549: expected a class, struct, or union type
2550: second operand of offsetof must be a field
2551: second operand of offsetof may not be a bit field
2552: cannot apply offsetof to a member of a virtual base
2553: offsetof applied to non-POD types is nonstandard
2554: default arguments are not allowed on a friend declaration of a member function
2555: default arguments are not allowed on friend declarations that are not definitions
2556: redeclaration of <entity> previously declared as a friend with default arguments is not allowed
2557: invalid qualifier for <type> (a derived class is not allowed here)
2558: invalid qualifier for definition of class <type>
2560: wide string literal not allowed
2565: template argument list of <entity> must match the parameter list
2566: an incomplete class type is not allowed
2567: complex integral types are not supported
2570: <entity> was declared "deprecated (<entity>)"
2571: invalid redefinition of <entity>
2574: explicit specialization of <entity> must precede its first use (<entity>)
2575: a sealed class type cannot be used as a base class
2576: duplicate class modifier
2577: a member function cannot have both the "abstract" and "sealed" modifiers
2578: a sealed member cannot be pure virtual
2579: nonvirtual function cannot be declared with "abstract" or "sealed" modifier
2580: member function declared with "override" modifier does not override a base class member
2581: cannot override sealed <entity>
2582: <entity> was declared with the class modifier "abstract"
2662: unrecognized calling convention <entity>, must be one of:
2665: attribute <entity> not allowed on parameter declarations
2666: underlying type of enum type must be an integral type other than bool
2667: some enumerator constants cannot be represented by <type>
2668: <entity> not allowed in current mode
2676: no #pragma start_map_region is currently active: pragma ignored
2677: <entity> cannot be used to name a destructor (a type name is required)
2678: nonstandard empty wide character literal treated as L'\\0'
2679: "typename" may not be specified here
2680: a non-placement operator delete must be visible in a class with a virtual destructor
2681: name linkage conflicts with previous declaration of <entity>
2682: alias creates cycle of aliased entities
2683: subscript must be constant
2684: a variable with static storage duration allocated in a specific register cannot be declared with an initializer
2685: a variable allocated in a specific register must have POD type
2686: predefined meaning of <entity> discarded
2687: declaration hides built-in <entity>
2688: declaration overloads built-in <entity>
2689: static member function not permitted here
2690: the <entity> attribute can only appear on functions and variables with internal linkage
2751: routine is both "inline" and "noinline"
2813: empty dependent statement in if-statement
This remark indicates that an if statement has no dependent statement, and is not followed by an else statement. For example:
if (x <= 0); // remark 2813 is generated here
{
    foo(x);
}
You can enable this remark by using --diag_warning 2813 or --remarks. When using the --remarks option, you can suppress this remark by using --diag_suppress 2813.
2815: empty dependent statement in while-statement
This remark indicates that a while statement has no dependent statement. For example:
while (x != 0);
You can enable this remark by using --diag_warning 2815 or --remarks. When using the --remarks option, you can suppress this remark by using --diag_suppress 2815.
2902: unrecognized Unicode source kind (must be one of UTF-8, UTF-16, UTF-16LE, UTF-16BE)
2903: Unicode character with hex value <entity> not representable in preprocessing output
2917: cannot open <entity> file <entity>
2918: cannot open <entity> file <entity>: <entity>
2934: conversion drops "__restrict" qualifier
2935: unable to obtain mapped memory for <entity>: <entity>
2936: array of elements containing a flexible array member is nonstandard
2938: the initialization of <entity> will be done before that of <entity>
In the C++ standard, member variables are initialized in the order they are declared in the class, not in the order they are written in the initializer list. The compiler produces this warning when the order of the initializations in the initializer list does not match the order of declarations in the class. You can enable this warning with --diag_warning 2938 or --remarks.
For example:
class Foo {
    int x;
    char y;
public:
    Foo() : y(42), x(32) {}
};
results in the message:
Warning: #2938-D: the initialization of member "Foo::x" will be done before that of member "Foo::y"
2939: inheritance kind is not allowed in C
2940: inheritance kind is ignored on an enum specifier
2941: modifier is not allowed on an enum specifier
2942: modifier is ignored on an enum specifier
2943: identifier character cannot be represented in Unicode
2944: header name contains characters that cannot be represented in Unicode
2945: <entity> is not a valid locale name
2946: declaring a void parameter list with a template parameter is nonstandard
2949: <entity> is not a variable
2960: invalid template directory:
2969: "\" followed by white space is not a line splice
2970: this dynamic_cast cannot be done without runtime type information, which is disabled
The compiler produces this error when a dynamic_cast must perform runtime type checking but you have disabled support for RTTI by compiling using the --no_rtti option. For example the following code results in this error:
class Foo {
    virtual int foo() = 0;
};
class Bar {};
Bar *convert(Foo *x) {
    return dynamic_cast<Bar *>(x);
}
2971: conversion to <entity> is ambiguous; direct base selected
2972: an internal buffer would be too large
2973: C++ exception handler used, but exception handling semantics have not been specified
2974: type qualifier ignored on constructor
2981: explicit template arguments ignored
2983: <entity> is not a class type
2984: "delete" applied to a pointer-to-array type treated as delete[]
The compiler produces this warning when the programmer has used the wrong kind of delete operator and the compiler has automatically corrected it. For example, the following code results in this warning:
void f(char (*data)[10]) {
    delete data;
}
2985: "delete" applied to a pointer-to-array type is nonstandard; treated as delete[]
This warning has the same meaning as message number 2984. The compiler generates this instead of 2984 when you compile with --strict on the command line.
2989: type qualifiers are ignored (underlying type is a reference)
2990: <entity>, declared using a local type, must be defined in this translation unit
2991: <entity>, declared using a type with no linkage, must be defined in this translation unit
2997: __builtin_va_arg_pack/__builtin_va_arg_pack_len can appear only in an inline function with an ellipsis parameter
2999: expected a C++ keyword
3001: offset is not constant
3002: unrecognized #pragma comment type <entity>
3006: invalid string in #pragma comment
3011: default arguments of <entity> is incompatible with a declaration in another translation unit
3012: default arguments of <entity> were different during compilation of <entity>
3014: initializer for <entity> is different in another translation unit
3015: initializer for <entity> was different during compilation of <entity>
3016: a designator into a template-dependent type is not allowed
3017: unrecognized conformance kind
3018: expected "on" or "off"
3019: #pragma conform(forScope) stack is empty
3020: no previous #pragma conform(forScope) entry matches <entity>
3021: forScope behavior is nonstandard
3022: forScope behavior is standard
3024: type qualifiers are meaningless here
3028: function call requires one argument
3029: function call requires a real floating-point argument
3033: nonstandard first parameter <entity> of "main", expected "int"
3034: nonstandard number of parameters for "main", expected zero or two parameters
3035: nonstandard second parameter <entity> of "main", expected "char *[]" or "char **"
3039: "packed" attribute ignored on class with non-POD <entity>
3040: error while deleting file <entity>: <entity>
3049: SWP instructions are deprecated in architecture ARMv6 and above
3050: FLDMX/FSTMX instructions are deprecated
3051: instruction is unpredictable in the current instruction set
3052: instruction is unpredictable with MSB < LSB
3053: instruction is unpredictable with the specified immediate value
3054: instruction is unpredictable with the specified condition
3055: instruction is unpredictable in IT block
3056: instruction is unpredictable with the specified special register
3057: instruction is unpredictable with the specified PSR mask
3058: immediate not in range <entity>
3059: immediate not a multiple of <entity>
3060: selected target does not have VFP
3061: unrecognized instruction opcode
3062: expected "<entity>"
3063: expected flag characters from "<entity>"
3064: expected special register for MSR/MRS
3065: deprecated special register name
3066: deprecated special register field specifier (use "<entity>" instead)
3067: MRS cannot select fields, use APSR, CPSR or SPSR directly
3068: expected a condition code
3069: VCVT conversion between these data types not available
3070: destination operand type or register sort incorrect
3071: source operand type or register sort incorrect
3072: data type specifiers do not match a valid encoding for this instruction
3073: missing data type specifier
3074: expected scalar operand
3075: expected data type specifier "<entity>" for destination operand
3076: expected data type specifier "<entity>" for source operand(s)
3077: writeback with no effect
3078: data type specifiers are not allowed on this instruction
3079: invalid instruction width qualifiers or data type specifiers
3080: unsupported special register
3081: expected end of line or a ";"
3082: option to enable GNU-C89-style inlining can be used only when compiling C
3083: function was previously declared without the "gnu_inline" attribute
3084: the "gnu_inline" attribute is ignored on non-inline functions
3092: anonymous unions are only supported in --gnu mode, or when enabled with #pragma anon_unions
3093: anonymous structs are only supported in --gnu mode, or when enabled with #pragma anon_unions
3094: __stack_chk_guard must be data
3095: __stack_chk_fail must be a function
3096: value of constant expression must fit fully within the bitmask <mask>
3097: a trailing return type requires the "auto" type specifier
3098: a trailing return type cannot appear in a nested declarator
3099: a function declarator with a trailing return type must be preceded by a simple "auto" type specifier
3100: "auto" function requires a trailing return type
3101: a member template cannot have a pure specifier
3102: option to control the nullptr keyword can be used only when compiling C++
3103: std::nullptr_t converted to bool
3106: attribute <attribute> does not allow an empty argument list
3107: attribute appears more than once
3108: attribute <attribute> does not apply here
3109: attribute <attribute> does not apply to bit fields
3110: attribute <attribute> requires a bit field
3111: attribute <attribute> does not apply to member functions
3112: attribute <attribute> requires a member function
3113: attribute <attribute> does not apply to virtual functions
3114: attribute <attribute> requires a virtual function
3115: attribute <attribute> does not apply to pure virtual functions
3116: attribute <attribute> requires a pure virtual function
3117: attribute <attribute> does not apply to register variables
3118: attribute <attribute> requires a register variable
3119: attribute <attribute> did not appear on original declaration
3120: attributes are not allowed here
3121: attribute <attribute> must appear in a class definition
3122: "final" applied to a pure virtual function
3123: cannot override "final" <entity>
3124: <entity> previously declared without the carries_dependency attribute
3125: invalid initializer for array <entity>
3127: attribute <attribute> does not apply to function types
3128: attribute <attribute> requires a function type
3129: attribute <attribute> does not apply to nonstatic member functions
3130: attribute <attribute> does not apply to automatic variables
3131: attribute <attribute> requires an automatic variable
3132: attribute <attribute> does not apply to a variable or function with external linkage
3133: attribute <attribute> requires a local variable
3134: attributes ignored here
3135: attribute does not apply to any entity
3136: bad attribute argument substitution
3137: the argument of the "tls_model" attribute must be "global-dynamic", "local-dynamic", "initial-exec", or "local-exec"
3138: the declaration <enntity> specified a different "tls_model" argument
3139: attribute <attribute> does not apply to inline functions
3140: attribute <attribute> requires a inline function
3141: both file names in an include_alias pragma must use the same delimiter characters
3142: comparison between signed and unsigned operands
3143: attribute <attribute> ignored on unnamed type
3144: attribute <attribute> ignored because no definition follows
3145: thread locality is incompatible with a previous declaration of <entity>
3146: this enclosing-function local variable cannot be referenced in this lambda body because an enclosing lambda does not allow implicit captures
3147: this attribute argument contains unmatched parentheses, brackets, or braces
3148: a call to __builtin_fpclassify requires five integral arguments followed by one floating-point argument
3149: the last argument in a call to __builtin_fpclassify must have a real floating-point type
3150: alignment cannot be set to less than the default alignment
3151: attributes are not allowed on explicit instantiations
3152: attribute <attribute> does not apply to a definition
3153: attribute <attribute> requires a definition
3154: standard attributes cannot appear on friend declarations that are not definitions
3155: specified alignment (<n>) is different from alignment (<n>) specified on a previous declaration
3156: alignment attribute must also appear on definition <entity>
3157: <entity> may not be used in the type-id of the alias-declaration
3159: <type> cannot be transparent because its first field has a floating-point type
3160: <type> cannot be transparent because its first field is a bit field
3161: virtual function of a "base_check" class overrides a base class member but lacks the "override" attribute
3162: "hiding" attribute specified on a declaration referred to by the using-declaration <entity>
3163: attribute "hiding" is required on a declaration (in a "base_check" class) that hides <entity>
3164: <entity> is not defined in this translation unit but depends on a local type
3165: <entity> is not defined in this translation unit but depends on a type with no linkage
3166: attribute <attribute> is missing in another translation unit
3167: attribute <attribute> conflicts with another translation unit
3168: the "nonstd_gnu_keywords" option is only valid in GNU C and GNU C++ modes
3169: use of a const variable in a constant expression is nonstandard in C
3170: an initializer cannot be specified for a flexible array member with automatic storage duration
3172: a "final" class type cannot be used as a base class
3173: exported templates are no longer in the standard C++ language
3174: a template-dependent designator is not allowed
3175: second operand of offsetof may not be a field with reference type
3176: long lifetime temporaries are incompatible with other requested newer language features
3177: wide character string literal will not be quoted in diagnostics
3178: missing arguments for attribute <attribute>
3179: options "c++11" and "c++11_sfinae" require a different compiler configuration
3180: template parameter pack not at end of parameter list
3181: a parameter pack declaration is not allowed here
3182: a parameter pack cannot have a default
3184: "value__" cannot be used as the name of an enumerator constant (it is a reserved name in this context)
3185: an explicit enumerator value is required in an enumeration type with boolean underlying type
3187: parameter pack <entity> was referenced but not expanded
3188: pack expansion does not make use of any argument packs
3189: pack <entity> does not have the same number of elements as <entity>
3191: vector_size attribute is not allowed with an enumeration type
3192: a property cannot be both static and virtual
3193: an indexed property cannot be trivial
3194: this declaration cannot appear in a property definition
3195: a qualified function type cannot be used to declare an accessor function
3196: an accessor function cannot have an ellipsis parameter
3197: a "get" accessor was already declared for this property <property>
3198: a "set" accessor was already declared for this property <property>
3199: a "get" accessor cannot have a parameter
3200: return type of "get" accessor does not match property type
3201: return type of "set" accessor must be void
3202: a property cannot declare an empty list of indices
3203: a property index cannot have type void
3204: index type does not match the corresponding parameter in the "set" accessor
3205: index type does not match the corresponding parameter in the "get" accessor
3206: index type is missing in the "set" accessor
3207: index type is missing in the "get" accessor
3208: "set" accessor is missing its value parameter
3209: accessor function has too many parameters
3210: the last parameter of the "set" accessor does not match the property type
3213: #using may only be used at global scope
3214: member name <entity> is reserved by <entity>
3215: expected a "["
3217: a default-indexed property cannot be static
3218: a property accessor cannot be both static and virtual
3219: a top-level visibility specifier cannot appear on a nested type declaration
3220: a top-level visibility specifier requires a type definition
3221: a trivial property cannot have a reference type
3222: a trivial property cannot have a const or volatile type
3223: <entity> was previously declared as a different kind of enumeration type
3226: array of handles is not allowed
3227: handle to array is not allowed
3228: handle to function is not allowed
3229: handle to void is not allowed
3230: handle to handle, pointer, or reference is not allowed
3231: tracking reference to function is not allowed
3233: a field cannot be a tracking reference
3234: a tracking reference cannot be combined with an ordinary reference in this way
3235: a variable with static storage duration cannot have a ref class type
3238: <entity> was previously declared as a different kind of class
3239: <entity> was previously declared as a different kind of class template
3241: a literal data member must be initialized
3242: a literal data member of type <type> is not allowed
3243: const has no effect on a literal data member
3245: const has no effect on an initonly data member
3246: <entity> has no "get" accessor
3247: <entity> has no "set" accessor
3248: a static constructor cannot have parameters
3249: a static constructor cannot be a member template
3250: a compound lvalue is not allowed as an asm output operand
3255: override specifier does not name a base class member function
3256: override specifier designates a nonvirtual member <entity>
3257: member function overrides <entity> which is already overridden by <entity>
3258: at most one visibility specifier is allowed
3259: type <type> used for delegate definition is not a function type
3261: a tracking reference to a delegate type is not allowed
3262: a delegate type is not allowed here
3263: this pack expansion produced an empty list of expressions, and an expression is needed here
3273: accessor function has too many parameters
3274: the type <type> of the parameter of the event accessor does not match the event type (<type>)
3275: the type of the "raise" accessor does not match the event's delegate invocation type
3277: a static conversion function must accept exactly one argument
3278: static operator must have a parameter type T, T&, T%, or T^ with T = <type>
3279: the operand of sizeof... must be a parameter pack name
3280: the sizeof... operator can be used only in a variadic template
3283: a handle to an unscoped enum type is not allowed
3285: a pure specifier ("= 0") followed by a definition is nonstandard
3287: the "&" operator cannot be used to take the address of an object with a ref class type
3292: could not import metadata from file <file>
3297: <type> cannot be a class member
3299: invalid finalizer declaration
3300: a finalizer may not have parameters
3301: a type qualifier is not allowed on a finalizer
3302: a return type may not be specified on a finalizer
3303: a using-declaration may not name a finalizer
3304: a finalizer name must be qualified
3305: qualifier of finalizer name <entity> does not match type <type>
3306: <entity> cannot be used to name a finalizer (a type name is required)
3307: invalid finalizer name for type <type>
3308: finalizer reference is ambiguous -- both <entity> and <entity> could be used
3309: a finalizer can only be a member of a ref class
3311: type used as finalizer name does not match type <type>
3312: a finalizer does not exist for this type
3332: "<entity>" not loaded from default assemblies
3333: list initialization syntax is a C++11 feature
3334: operand of sizeof may not be a ref class type or interface class type
3345: <entity> overridden with reduced access
3346: a reference of type <type> cannot be initialized with a value of type <type>
3360: a property definition must include at least one accessor ("get" or "set")
3361: default-indexed property conflicts with <type>
3362: <entity> cannot be used because it follows a parameter pack and cannot be deduced from the parameters of <entity>
3363: this pack expansion produced more than one expression, and a single expression is needed here
3366: an unnamed parameter pack declaration cannot be parenthesized
3367: variadic templates can be enabled only when compiling C++
3371: a generic parameter cannot have a default
3372: a generic can only have type parameters
3373: to be used with "for each" statements, type <type> must provide nonstatic member function <entity>
3374: "for each" cannot use member <entity> because it is static
3375: in this "for each" statement, no instance of <entity> is callable with an empty argument list
3376: "for each" cannot use member function "MoveNext" because the return type is invalid
3377: a "for each" statement cannot operate on an expression of type <type>
3378: to be used with "for each" statements, type <type> must provide a non-indexed property <property>
3380: in this "for each" statement, <type> is not a valid enumerator (returned by "GetEnumerator" of <type>)
3381: expected "in"
3382: class <type> has no suitable assignment operator (after operator synthesis)
3383: <entity> is not a generic parameter
3384: <entity> is not a generic parameter of the innermost generic parameter list
3385: invalid generic constraint
3388: only "+=" and "-=" are valid for events
3391: name followed by "::typeid" must be a type name
3397: the operand of a handle dynamic_cast must be a handle to a complete class type
3400: an interior pointer cannot be cast to a native pointer
3401: explicit conversion operators can only be declared in ref and value class types
3402: explicit conversion operator cannot be virtual
3403: expression must have arithmetic or unscoped enum type
3404: expression must have arithmetic, unscoped enum, or pointer type
3405: expression must have integral or unscoped enum type
3406: expression must have integral, unscoped enum, or fixed-point type
3407: a built-in binary operator applied to a scoped enumeration requires two operands of the same type
3410: new can only be used with simple value types
3412: new cannot be used on a handle type
3416: too many array bounds
3417: too few array bounds
3418: too few arguments for <entity>
3419: too many arguments for <entity>
3421: no declaration of <entity> accepts the number of generic arguments supplied
3422: invalid delegate initializer -- must be a function
3423: invalid delegate initializer -- more than one function matches the delegate type
3424: invalid delegate initializer -- function does not match the delegate type
3425: invalid delegate initializer -- an object is needed in addition to a function
3427: invalid delegate initializer -- object is not needed for the specified function
3428: invalid delegate initializer -- object has type <type> but type <type> is expected
3430: invalid delegate initializer -- expected either "(<function-address>)" or "(<object-handle>, <member-address>)"
3431: class fails to implement interface member <entity>
3436: a destructor or finalizer declaration cannot include a named override specifier
3437: an override specifier cannot designate a destructor or finalizer
3439: no member designated by the named override specifier matches the type of this member
3440: a static constructor declaration cannot include a named override specifier
3441: a scoped enumeration type must have a name
3442: transfer of control into a finally block is not allowed
3443: return statement inside a finally block is not allowed
3444: try block requires at least one handler or finally clause
3446: a break statement cannot be used in a finally block
3447: a continue statement cannot be used in a finally block
3448: builtin offsetof cannot be used when subscripting is overloaded
3449: duplicate constraint
3450: more than one class constraint: <type> and <type>
3451: more than one constraint clause for <entity>
3452: initonly static data members must have an initializer or be initialized in a static constructor
3453: GNU attributes on a template redeclaration have no effect
3454: GNU attributes on a template redeclaration have no effect (the attributes of the original declaration <entity> apply instead)
3459: __inline and __forceinline are not allowed here
3464: an array of generic parameter type is not allowed
3465: a pointer, handle, or reference to a generic parameter type is not allowed
3466: an initonly field cannot have a ref class type
3467: a reference cannot be bound to an initonly field
3468: taking the address of an initonly field is not allowed
3469: an initonly field can only be modified by the instance constructor of its containing class
3470: a static initonly field can only be modified by the static constructor of its containing class
3471: member function will be invoked on a copy of the initonly field
3472: expression must have pointer or handle type
3473: a move constructor or move assignment operator is used to copy an lvalue here, which may destroy the source object
3475: a ref class type cannot derive from <type>
3477: a sealed class cannot be used as a constraint
3478: the type in a dynamic_cast cannot be a generic type that might be a value type
3479: a universal character name must designate a valid code point
3480: generic constraints do not match those of <entity>
3481: __underlying_type only applies to enumeration types
3482: expected only one operand expression for this cast
3483: Unicode character with hex value <value> not representable in the system default code page
3484: nonstandard conversion of bound pointer-to-member to a function pointer
3485: access specifier <entity> is deprecated -- use <entity> instead
3486: a static accessor function is not permitted in a nonstatic property or event definition
3487: <type> has both a value class and ref class constraint
3488: <type> and <type> involve circular naked type constraints
3489: <type> is not a valid type constraint
3490: precompiled header file <entity> not used (because it is incomplete)
3491: <type> is not a valid generic argument
3492: assembly_info attribute applied to an invalid type
3493: <type> does not satisfy the ref class constraint of generic parameter <type>
3494: <type> does not satisfy the value class constraint of generic parameter <type>
3498: <type> does not satisfy the <type> type constraint of generic parameter <type>
3499: constraint on generic parameter <type> differs from previous declaration (<entity>)
3503: a template argument may not reference a generic type parameter
3504: an expression list is not allowed in this subscript operation (use parentheses around a top-level comma operator)
3506: unrecognized attribute
3510: a delegate may not be declared as a template
3511: a generic cannot be explicitly specialized
3512: a generic cannot be declared in a class template
3513: a template cannot be declared in a generic class
3514: a literal field cannot be declared "static"
3515: "long float" is a nonstandard extension -- use "double" instead
3519: <entity> is not allowed here
3520: a trivial property or event cannot be used to override <entity>
3521: expected an iterator variable name
3522: the iterator type in this "for each" statement is <type>, which is not a pointer type or an iterator-like class type
3523: the iterator type in this "for each" statement is <type>, which is not a pointer type or an iterator-like class type
3524: the iterator type in this "for each" statement is <type>, which is not a pointer type or an iterator-like class type
3525: packing attribute on the parent type is ignored for this field of non-POD type <type>
3526: <entity> not implemented because this declaration is not public and has no named override specifier
3527: this declaration is missing the gnu_inline attribute specified in the previous declaration <entity>
3529: previously-declared <entity> invalid as iterator of "for each" statement
3531: a function type involving a generic parameter cannot have an ellipsis parameter
3532: "virtual" is required to override the matching <entity>
3533: "virtual" is required to implement the matching <entity>
3534: an initonly data member cannot be volatile
3536: a tracking reference to non-const cannot be bound to a constant
3537: attributes ignored here because they do not apply to a declared entity
3539: invalid use of a generic class <type> with pending constraints (probably caused by an invalid metadata file)
3540: a pending constraint clause is only allowed for generic class declarations (but not generic class definitions)
3541: empty initializer list not allowed here
3543: a generic declaration is not allowed here
3544: interface types cannot have member generics
3545: Unicode character not Latin-1, truncated to low-order byte
3546: to be used with range-based "for" statements, type <type> must provide function <entity>
3547: the iterator type in this range-based "for" statement is <type>, which is not a pointer type or an iterator-like class type
3548: the iterator type in this range-based "for" statement is <type>, which is not a pointer type or an iterator-like class type
3549: the iterator type in this range-based "for" statement is <type>, which is not a pointer type or an iterator-like class type
3550: a range-based "for" statement cannot operate on an array of unknown size or incomplete type <type>
3551: return types for "begin" and "end" functions used in a range-based "for" statement must be the same ("begin" return type is <type>, "end" return type is <type>)
3552: <entity>, required to destroy temporary that was eliminated, is inaccessible
3553: in this range-based "for" statement, no instance of <entity> matches the argument list
3554: this range-based "for" statement requires a suitable <entity> function and none was found
3555: this "for each" statement requires a suitable <entity> function and none was found
3557: expected "..."
3558: <type> in __implements list is not an interface
3559: an __implements list must precede virtual function declarations
3560: <type> specified "__implements ..." in its list of bases, but is missing a matching __implements list
3561: old for-init compatibility mode cannot be used with C++11 mode
3562: expected a ")"; pragma ignored
3564: Note: <entity> could have been called but was not considered because it is inaccessible
3566: declaring this unary "operator*" can change the meaning of dereferencing a handle (use static member operators to explicitly indicate applicable types)
3581: an interface class cannot contain a nonstatic data member
3582: #pragma GCC system_header cannot be used in the primary source file
3583: <entity> is too large to be inlined
3585: option to control move operations can be used only when compiling C++
3586: move operations cannot be generated when rvalue constructors are copy constructors
3587: option to control move operations cannot be used when rvalue references are disabled
3591: this declaration hides the nonstandard declaration of <entity> because the underlying types are incompatible
3592: pointer comparison result is constant, because operand can never be null
3593: an object of the incomplete type <type> cannot be value-initialized
3594: a reference cannot be value-initialized
3595: expected a "(" or a "{"
3596: copy-list-initialization cannot use a constructor marked "explicit"
3597: pointer to member of type void is not allowed
3598: pointer to member of reference type is not allowed
3599: pointer to member of handle type is not allowed
3600: a brace-enclosed list is not allowed here
3602: assembly metadata refers to non-existent assembly
3603: attribute <attribute> conflicts with earlier attribute <attribute>
3604: <entity> was previously declared with a different base type
3605: "enum class" and "enum struct" cannot be used here (use plain "enum" instead)
3606: only one level of braces is allowed on an initializer for an object of type <type>
3607: <entity> cannot be used as an enumeration type name
3608: in a lambda with an implicit return type, all return statements must return the same type
3609: a braced-initializer cannot be used with "new auto"
3610: the definition of std::initializer_list does not contain the expected constructor
3611: declaration hides <entity>
3612: invalid template parameter list for std::initializer_list (it should be one ordinary type parameter with no default)
3613: a brace-enclosed list cannot be passed for an ellipsis parameter
3614: an #include <initializer_list> is needed prior to a use of std::initializer_list, including an implicit use
3615: the "inline" keyword cannot be used on a namespace alias declaration
3616: the previous declaration of <entity> was not declared inline
3617: a redeclaration of inline <entity> must be declared inline
3618: the first argument must be an integer constant
3619: a designator for an anonymous union member can only appear within braces corresponding to that anonymous union
3620: function prototype tags can only be enabled when compiling C
3621: braces cannot be omitted for this subobject initializer
3622: invalid narrowing conversion from <type> to <type>
3623: invalid narrowing conversion from <type> to <type>: constant value does not fit in destination type
3624: cast to incomplete array type <type> is not allowed
3625: invalid narrowing conversion from <type> to <type>: constant value cannot be represented exactly in destination type
3626: a parenthesized initializer for a non-class entity must be an expression, not a brace-enclosed list
3627: a brace-enclosed list does not provide a return type for this lambda
3628: the declared exception specification is incompatible with the generated one
3629: scoped enumeration types are a C++11 feature
3630: a function type cannot be value-initialized
3631: list-initialization of an object type <type> is not allowed because the type is incomplete
3632: std::initializer_list has a destructor, and is not supposed to -- library is misconfigured
3633: explicit enum base types are a C++11 feature
3634: this constant expression has type <type> instead of the required <type> type
3635: a "new" of an std::initializer_list object is unlikely to work as expected because the underlying array will be destroyed at the end of the full expression
3637: "noexcept" is ignored on a function type that is not the type of a function declaration
3638: "defined" is always false in a macro expansion in Microsoft mode
3639: <type> cannot be the element type of an initializer list because it is not a complete object type
3640: mismatched delimiters in default argument expression
3641: nonstandard conversion of pointer-to-member to a function pointer
3642: dynamic exception specifications are deprecated
3643: <entity> cannot be partially specialized in the current scope
3644: <entity> was previously declared constexpr
3645: <entity> was previously not declared constexpr
3646: a constexpr variable declaration must be a definition
3647: "constexpr" is not valid here
3648: a constexpr function must contain exactly one return statement
3649: statement may not appear in a constexpr function
3650: statement may not appear in a constexpr constructor
3651: a function cannot be both constexpr and virtual
3652: a constexpr function cannot have a nonliteral return type <type>
3653: a constexpr function cannot have a parameter of nonliteral type <type>
3654: unsequenced uses of <entity> in expression may produce undefined results
3655: the optional third argument of a call to __builtin_assumed_aligned must have integral type
3656: a destructor cannot be constexpr
3657: address supplied for mmap must be aligned on a page boundary:
3658: the body of a constexpr constructor cannot be a function try block
3659: constexpr <entity> provides no initializer for:
3661: calling the default constructor for <type> does not produce a constant value
3662: the default constructor for <type> is not constexpr
3663: a constexpr variable must have a literal type or a reference type
3664: a constructor for a class with virtual bases cannot be constexpr
3665: function call must have a constant value in a constant expression
3666: function "main" may not be declared constexpr
3667: a constexpr member function is only permitted in a literal class type
3668: a class or enumeration type definition cannot appear in a constexpr function or constructor body
3669: only GNU-style attributes are permitted here
3670: nonstandard use of "auto" to both deduce the type from an initializer and to announce a trailing return type
3671: declaring a void parameter list with a qualified void type is nonstandard
3672: the qualifier on this local declaration is ignored
3673: this constant expression has type <type> instead of the required <entity> type
3674: an instantiation of __bases or __direct_bases requires a class type
3675: the argument of __bases and __direct_bases must be a type template parameter
3676: <entity> can only be used in template contexts
3677: constexpr constructor calls non-constexpr <entity>
3678: constructor cannot be constexpr because the initializer of <entity> is not a constant expression
3679: non-constant initializer for constexpr constructor
3680: the generated default constructor for <type> cannot be used in an initializer for its own data member
3681: instantiation of initializer of <entity> depends on its own value
3682: defaulted default constructor cannot be constexpr because the corresponding implicitly declared default constructor would not be constexpr
3683: expression not folded to a constant due to excessive constexpr function call nesting (possible infinite recursion)
3684: invalid binary number
3685: a union can have at most one field initializer -- <entity> also has an initializer
3686: a constexpr static data member cannot be declared with an incomplete type <type>
3687: constexpr constructor of a union must initialize one of its fields
3688: constexpr constructor fails to initialize an anonymous union (defined <entity>)
3689: a constexpr static data member declaration requires an in-class initializer
3690: maximum constexpr depth/count options can be used only when compiling C++
3691: expression not folded to a constant due to excessive constexpr function call complexity
3692: unrestricted union options can be used only when compiling C++
3693: constexpr constructor must initialize direct base class <type>
3694: creation of an std::initializer_list object in a field initializer is unlikely to work as expected because the underlying array will be destroyed at the end of the full expression
3695: "this" cannot be used in a constant expression
3696: an empty initializer is not valid for this union type (which member should be initialized is ambiguous)
3697: "constexpr" is not allowed on an explicit instantiation directive
3698: cannot determine the exception specification of the default constructor due to a circular dependency
3699: anonymous union defined <entity>
3700: this constructor uses the initializer of <entity>, which would result in unbounded recursion
3701: anonymous union defined <entity> cannot be default-initialized because it has a deleted default constructor or destructor
3702: an initializer is not allowed on a local declaration of an extern variable
3703: an initializer is not allowed on a local declaration of a named register variable
3704: expression is not constant due to a dangling pointer (points to a temporary whose lifetime has ended)
3706: constructor delegates directly or indirectly to itself
3707: a delegating constructor cannot have other mem-initializers
3708: a ref-qualifier is not allowed here
3709: overloading two member functions with the same parameter types requires that they both have ref-qualifiers or both lack ref-qualifiers
3710: invalid character in raw string delimiter -- raw string indicator ignored
3711: parenthesis terminating raw string delimiter not found after 16 characters -- raw string indicator ignored
3712: ending delimiter for raw string not found
3713: a parameter pack must be the final template argument in a partial specialization
3714: a pointer-to-member function with type <type> can only be used with an lvalue object
3715: a pointer-to-member function with type <type> can only be used with an rvalue object
3716: the parameter of this defaulted copy-constructor cannot be const because a base or member copy constructor parameter is non-const
3717: the parameter of this defaulted assignment operator cannot be const because a base or member copy assignment parameter is non-const
3718: an anonymous union must contain at least one nonstatic data member
3719: option "delegating_constructors" requires a different compiler configuration
3720: delegating constructors are not permitted with both of --cpp_compat and --exceptions
C4002W: illegal unaligned load or store access - use __packed instead
C4008W: splitting LDM/STM has no benefit
Inappropriate use of the switch --split_ldm. This option has no significant benefit for cached systems, or for processors with a write buffer.
C4009E: unsupported CPU <entity>
C4016W: unknown option '-<entity><entity>': ignored
C4017W: <entity> may be used before being set
The compiler performs data flow analysis at optimization level -O1 and above. You can use this information to identify potential problems in the code such as variables being used before being set. However, this is really a by-product of optimization rather than a feature in its own right. The data flow analysis that detects variables being used before being set only analyzes hardware register use, that is, variables that are held in processor registers. It does not analyze variables or structures that are allocated on the stack, that is, stored in memory rather than in processor registers.
As code (and also register memory usage) generated by the compiler varies with the level of optimization, the warning might appear for code compiled at one level of optimization but not others. You might see it, for example, at -O2, but not -O1.

Note

  • The data flow analysis is not intended to be a fully complete feature. You must only treat C4017W warnings given by the compiler as a guide, and not rely on them to identify faulty code reliably. The compiler never provides as much information as a special purpose tool such as Lint.
  • In ARM Compiler 5.04 and later, this warning is suppressed by default. To enable it, use --diag_warning=C4017.
C4018W: division by zero: <entity>
Constant propagation shows that a divide or remainder operator has a second operand with value 0. It is an error if execution reaches this expression. The compiler returns a result of 0 for a divide by constant 0.
C4038E: Function too large or complicated to compile (0x<num>)
C4041U: I/O error writing '<entity>': <entity>
C4047U: Too many errors
C4048U: out of store while compiling with -g. Allocation size was <entity>, system size is <entity>
C4049U: out of store. Allocation size was <entity>, system size is <entity>
A storage allocation request by the compiler failed. Compilation of the debugging tables requested with the -g option might require a large amount of memory. Recompiling without -g, or with the program split into smaller pieces, might help.
C4050U: Compilation aborted.
C4051E: couldn't write file '<entity>': <entity>
C4052E: couldn't read file '<entity>': <entity>
C4056E: bad option '<s>'
C4057E: bad option '<s1> <s2>'
C4065E: type of input file '<entity>' unknown
C4066E: The code space needed for this object is too large for this version of the compiler
Split the source file into smaller pieces.
C4075E: Can't open <entity> for output
C4078E: stdin ('-') combined with other files
C4079E: <entity> command with no effect
C4301W: configuration file appears to be from a newer version of the compiler
C4302E: configuration file has an invalid version string
C4303E: configuration file was not specified
C4304E: I/O error reading configuration file <file>
C4305E: I/O error writing configuration file <file>
C4306E: could not parse configuration file <file>
C4307E: unable to read configuration file
C4308W: cannot find system include directory
C4309E: automatic configuration failed - cannot find GCC
C4310W: automatic configuration is incomplete - cannot determine sysroot path from GCC
C4311E: automatic configuration failed - cannot find GLD
C4312E: automatic configuration failed - could not execute GCC
C4313E: automatic configuration failed - could not execute GLD
C4314W: gcc command line translation - ignoring option with no translation: <option>
C4315W: gcc command line translation - translation for this command is not fully supported: <option>
C4316W: option is not supported under arm linux: <option>
C4317W: translated cpu or architecture option <option> is not valid
C4318W: unable to read file <file>
C4319W: cannot recognise type of file <file> - file will be ignored
C4320W: cannot find file <file> - file will be ignored
C4321E: automatic configuration failed - could not determine configuration from GCC
C4322W: could not accurately determine library configuration from GCC - configuration might be incomplete
C4323E: automatic configuration failed - GCC internal specs configuration report error: <text>
C4324W: could not determine libstdc++ header file path - specify this manually to ensure that C++ code will compile correctly
C4327W: cannot determine application entry point function - using <value> as default
C4328W: cannot determine library paths from GNU linker - trying to use defaults
C4329W: option is missing an argument : <option>
C4330E: GCC configuration is invalid
C4331W: script file <file> will be treated as a scatter file
C4332E: I/O error reading via file <file>
C4333E: I/O error closing via file <file>
C4334W: invalid GCC version in configuration file - using default
C4335E: cannot retry because configuration file does not provide path to GNU executable
C4336W: compilation failed - retrying with GNU tools
Displayed if an armcc compilation fails and GCC fallback is specified. armcc then attempts to run gcc to complete the compilation.
C4337E: compilation with GNU tools also failed
Displayed if gcc fails during GCC fallback.
C4338W: compilation with GNU tools succeeded
Displayed when GCC fallback succeeds.
C4339W: ambiguous translation mode options specified - using <option>
C4340W: could not obtain license for vectorization (implied by -O3) - defaulting to -fno-tree-vectorize
C4403E: __alloca_state not defined
C4419W: dynamic stack alignment veneer inserted in <entity>
This warning is given when compiling __irq functions for --cpu=Cortex-M3-rev0 to force the stack to be 8-byte aligned on entry into the interrupt.
C4421W: write to string literal
There is a write through a pointer that has been assigned to point at a literal string. The behavior is undefined by the ANSI standard. A subsequent read from the location written might not reflect the write.
C4435E: reference to <entity> not allowed
C4447E: option '-E' and input file '<filename>' type conflict
C4484E: Minimum toplevel array alignment must be 1, 2, 4 or 8
C4486W: option '-<optionchar>' causes input file '<filename>' to be ignored
C4487E: read from variable '<var>' with offset out of bounds
For example :
void foo(void) {
  unsigned int pntr;
  pntr = (unsigned int)&pntr;
  pntr -= 4;
  pntr = *(unsigned int*)pntr;
}
C4488E: write to variable '<var>' with offset out of bounds
C4489E: __vfp_status() intrinsic not supported for targets without VFP
C4490W: instruction set switching using file extension is deprecated
C4493E: Function alignment must be a power of 2 and greater than 1
C4494E: invalid global register number <num>; 1 to <num> allowed
C4497E: invalid syntax for retention constraint: <text>
C4498E: option conflicts with an arm linux targeting option: <option>
Non-ConfidentialPDF file icon PDF versionARM DUI0591E
Copyright © 2011, 2012, 2014, 2015 ARM. All rights reserved.