List of the armcc error and warning messages

The error and warning messages for armcc are.

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 <stdio.h>
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 ")"

For example:

int main(void
{

where there is a missing ).

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:

char a =’abcd’;

results in an error.

Note

Only one character is permitted in a single-quoted string. For more than one character, double quotes must be used. Strings must be assigned to an appropriate variable such as a[].

27
character value is out of range

For example:

char foo[] = {"\xBBBB" };

results in the message:

Warning: #27-D: character value is out of range
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 such as for example, if the identifier which must immediately follow a preprocessor command is missing. For example, a missing identifier after #define results in:

Error: #40: expected an identifier

This error can also occur when C code containing C++ keywords is compiled with the C++ compiler, for example:

int *new(void *p) { return p; }

causes an error because new is a keyword in C++.

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>

Macro has been defined twice (with different replacement strings).

If it is necessary to do this, undefine the macro (#undef) before the second definition.

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)

There is no way to control this error directly by a compiler option, but you can use conditional preprocessing. For example:

#ifdef TEST_EQUALS_ZERO
#define TEST 0
#else
#define TEST 1
#endif

Compiling with armcc -c foo.c defines TEST to be 1 (the default).

Compiling with armcc -c -DTEST_EQUALS_ZERO foo.c defines TEST to be 0.

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:

typedef enum
{
  Bit31 = 0x80000000
} Bits;

when compiled in C mode generates the this message as a warning.

Note

The behavior of the compiler has changed between past versions and also when using --enum_is_int and --strict switches.

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 in the Compiler Reference:

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 allowed in --c99 mode.

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, for example, printf(), must follow at least one parameter. 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
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
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>

This incorrect C code:

typedef enum { e } E;
typedef enum { f } F;
E g(void);
F g(void);

is a discretionary error in all modes, and can be downgraded from an Error to a Warning with --diag_warning 147, or suppressed completely with --diag_suppress 147.

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. The following message is reported:

Error: #169: expected a declaration
170
pointer points outside of underlying object
171
invalid type conversion
172
external/internal linkage conflict with previous declaration

Errors about linkage disagreements where functions are implicitly declared as extern and then later re-declared as static are suppressed unless compiled with --strict.

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 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:

unsigned long foo = 0x1234;
printf("%0lX", foo);

or perhaps:

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.

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 (for example, char or int) value and zero always evaluates to false.

187
use of "=" where "==" may have been intended

Example:

int main(void)
{
  int a;
  const int b =1;
  if (a=b)
}
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 just to inform the user that the type qualifier has no effect, although the code is still legal. The warning is suppressible with --diag_suppress 191.

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> that includes 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 C, the only types permitted for a bit field are int, signed int, and unsigned int.

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:

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 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 a instance of a const structure or structure containing a const that has not been correctly initialized. You must either initialise it correctly for every instance or provide a constructor to initialise 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 { ... } ; ;

which probably resulted from some macro usage:

#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 in ANSI C mode, this error might be produced by a function declaration f(V) where V is a void type.

In the special syntax f(<void>) that indicates that f is a function taking no arguments, the keyword <void> is required. The name of a void type cannot be used instead.

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 member be named using a qualified name and a & character such as for &A::f.

The front end previously accepted nonstandard forms like &f, or even simply f, as a concession to existing practice. This usage now produces a discretionary error.

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 the example, y is an initialized variable that is in scope (but unused) in the other cases.

The C++ Standard says in section 6.7:

"It is possible to transfer into a block, but not in a way that bypasses declarations with initialization. A program that jumps from a point where a local variable with automatic storage duration is not in scope to a point where it is in scope is ill-formed unless the variable has POD type (3.9) and is declared without an initializer (8.5)."

Note

The transfer from the condition of a switch statement to a case label is considered a jump in this respect.

The usual way to fix this is to enclose the case that declares y in braces:

case 1:   {
  int y = 1;
  z = y + z;
}
break;

Because y is a POD (Plain Old Data) type, so an alternative is to not use initialization:

case 1:
 int y;
 y = 1;
 z = y + z;
 break;
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 Introducing the ARM® Compiler toolchain:

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 pvfn 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 Compiler Reference:

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

ARM function qualifiers include qualifiers such as __svc, __pure and __irq amongst others.

See the following in the Compiler Reference:

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 the ARM compilers, and 0 to 0xFF for the Thumb compilers.

For standard semihosting SVCs, 0x123456 is used for ARM, 0xAB is used for Thumb.

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 Reference states:

"All substructures of a packed structure must be declared using __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;

correctly results in the message:

Error: #1031: Definition of "ChildStruct" in packed "ParentStruct" must be __packed

See the following in the Compiler Reference:

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 Compiler Reference:

1042
<entity> cannot be dynamically initialized when compiled position independent
1043
<entity> cannot be const because it contains a mutable member
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
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:

  • the coprocessor number is accidentally omitted from an MCR or MRC instruction

  • an invalid coprocessor number/coprocessor register number has been given.

An example of correct use is shown below:

void foo()
{
  int reg0;
  __asm
  {
    MRC p15, 0, reg0, c1, c0, 0
  }
}
1113
Inline assembler not permitted when generating Thumb code

The Thumb inline assembler is deprecated when compiling for ARM architecture v7 (ARMv7) or later, that is, most processors in the Cortex™ series.

The inline assembler does not support Thumb(-1) or Thumb-2, or all the ARMv6 instructions. However, the inline assembler does still support the (ARM-only) ARMv4T, ARMv5TE, and a subset of the new ARMv6 instructions (only the ARMv6 media instructions), so legacy inline assembly code continues to build correctly.

This warning is intended as a reminder to consider using the embedded assembler or built-in intrinsics instead of inline assembler. If you cannot change your code but require elimination of the warning, suppress the warning or compile the module for an earlier cpu such as ARMv6.

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. The ll suffix means that the constant is treated as a (64-bit) long long type rather than a signed long.

To eliminate the warning, explicitly add the ll or LL suffix to your constants. For example:

int foo(unsigned int bar) 
{ 
  return (bar == 2147483648LL); 
} 

See the following in the Compiler Reference:

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 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

When LDM and STM instructions are used in inline assembler the compiler expands these into a number of 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 LDM or STM instructions, however it is possible that in some cases that 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 (the controlling expression for if, while, for or the first operand of a conditional expression, an expression contains one of:

  • 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 (==).

In either case if the operator is intended adding an explicit comparison against 0 might suppress the warning.

This warning can be suppressed with the --diag_suppress 1293 option.

Example:

int main(void) 
{ 
  int a,b; 
  if (a=b) 
} 
1294
Old-style function <entity>

The compilers accept both old-style and new-style function declarations.

The difference between an old-style and a new-style function declaration is as follows.

// 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 initialiser might not be portable.

This warns that there is a constant that does not follow the strict rules of ANSI C even though there is a clause to permit it in the ANSI C specification.

Example compiled with --c90 switch:

const int foo_table[] = { (int)"foo", 0, 1, 2}; 

This is not ANSI C standard compliant. Compiling with --diag_suppress 1296 suppresses the warning.

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++, 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 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
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 warn against the use of non-PI code constructs and that a subsequent link step might fail.

For example, 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.

For example, 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 FAQ What does Error: L6248E: cannot have address type relocation mean?.

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
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 C++ ISO Specification defines that the non-required arguments of a variadic function must be of type POD (plain-old-data), 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 dllimport or dllexport has 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
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
2523
use of inline assembler is deprecated

The inline assembler is deprecated when compiling for ARMv7 or later, that is, most processors in the Cortex™ series.

The inline assembler does not support Thumb(-1) or Thumb-2, or all the ARMv6 instructions. However, the inline assembler does still support the (ARM-only) ARMv4T, ARMv5TE, and a subset of the new ARMv6 instructions (only the ARMv6 media instructions), so legacy inline assembly code continues to build correctly.

This warning is intended as a reminder to consider using the embedded assembler or built-in intrinsics instead of inline assembler. If you cannot change your code but require elimination of the warning, suppress the warning or compile the module for an earlier CPU such as ARMv6.

Caution

Attempting to compile some inline assembler for Thumb (armcc --thumb) might result in ARM instructions being generated in some cases.

2524
#pragma pop with no matching #pragma push
2525
#pragma push with no matching #pragma 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 and can be enabled 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 structs, see 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
Copyright © 2011 ARM. All rights reserved.ARM DUI 0591A
Non-ConfidentialID061811