The executing compiler application has encountered too many errors and
will exit immediately. Other uncompiled source files will be processed, but the
compiler applications that would normally be executed in due course will not be run.
The number of errors that can be accepted is controlled using the
-fmax-errors
option (see Max Errors Option.
The executing compiler application has emitted a message (advisory/warning/error), but there is no description available in the message description file (MDF) to print. This could be because the MDF is out-of-date, or the message issue has not been translated into the selected language.
The compiler has attempted to load the messages for the selected language, but the message description file (MDF) was corrupted and could not be read correctly.
#if
or similar block was not terminated with a
matching #endif
, for example:
#if INPUT /* error flagged here */
int main(void)
{
run();
} /* no #endif was found in this module */
#else
or #elif
has been used in the
same conditional block as a #else
. These can only follow a
#if
, for example:
#ifdef FOO
result = foo;
#else
result = bar;
#elif defined(NEXT) /* the #else above terminated the #if */
result = next(0);
#endif
#elif
, #else
or
#endif
directive must be preceded by a matching
#if
line. If there is an apparently corresponding
#if
line, check for things like extra #endif
s,
or improperly terminated comments, for example:
#ifdef FOO
result = foo;
#endif
result = bar;
#elif defined(NEXT) /* the #endif above terminated the #if */
result = next(0);
#endif
This is a programmer generated error; there is a directive causing a deliberate error. This is normally used to check compile time defines, etc. Remove the directive to remove the error, but first determine why the directive is there.
#assert
directive has
evaluated to zero. This is a programmer induced error.
#assert SIZE == 4 /* size should never be 4 */
#endasm
operator has been encountered, but there was
no previous matching #asm
, for example:
void cleardog(void)
{
clrwdt
#endasm /* in-line assembler ends here, only where did it begin? */
}
#asm
directives. Check for a
missing or misspelled #endasm
directive, for example:
#asm
MOVE r0, #0aah
#asm ; previous #asm must be closed before opening another
SLEEP
#endasm
#
directive. It is
probably a misspelling of a directive token, for example:
#indef DEBUG /* oops -- that should be #undef DEBUG */
#if
,
#ifdef
, and #ifndef
must have an argument. The
argument to #if
should be an expression, while the argument to
#ifdef
or #ifndef
should be a single name, for
example:
#if /* oops -- no argument to check */
output = 10;
#else
output = 20;
#endif
#include
is
invalid. The argument to #include
must be a valid file name, either
enclosed in double quotes " "
or angle brackets <
>
. Spaces should not be included and the closing quote or bracket
must be present. There should be nothing else on the line other than comments, for
example:
#include stdio.h /* oops -- should be: #include <stdio.h> */
CPP should be invoked with at most two file arguments. Contact Microchip Technical Support if the preprocessor is being executed by a compiler driver.
#define ONE 1
/* elsewhere: */
/* Is this correct? It will overwrite the first definition. */
#define ONE one
#define FOO(a, 2b) bar(a, 2b) /* 2b is not to be! */
A macro definition contains a string that lacks a closing quote.
#undef
must be a valid name. It must
start with a letter, for example:
#undef 6YYY /* this isn’t a valid symbol name */
The named macro has been defined in such a manner that expanding it causes a recursive expansion of itself.
#define FUNC(a, b) func(a+b)
FUNC(5, 6; /* oops -- where is the closing bracket? */
#if
expression should only occur in
syntactically correct places. This error is probably caused by omission of an
operator, for example:
#if FOO BAR /* oops -- did you mean: #if FOO == BAR ? */
The preprocessor filled up its expression evaluation stack in a
#if
expression. Simplify the expression – it probably contains
too many parenthesized subexpressions.
This is an internal compiler error. Contact Microchip Technical Support with details.
#if
expression
that is incorrectly placed (two binary operators are not separated by a value), for
example:
#if FOO * % BAR == 4 /* what is "* %" ? */
#define BIG
#endif
Expressions in #if
lines are evaluated using a stack
with a size of 128. It is possible for very complex expressions to overflow this.
Simplify the expression.
#if
expression found mismatched
parentheses. Check the expression for correct parenthesizing, for example:
#if ((A) + (B) /* oops -- a missing ), I think */
#define ADDED
#endif
#if
expression that does not match up with a corresponding ?
operator,
for example:
#if XXX : YYY /* did you mean: #if COND ? XXX : YYY */
#if
expression that should
not be there. Valid characters are the letters, digits and those comprising the
acceptable operators, for example:
#if YYY /* what are these characters doing here? */
int m;
#endif
#if
expression
that should not be there. Valid characters are the letters, digits and those
comprising the acceptable operators, for example:
#if ^S YYY /* what is this control characters doing here? */
int m;
#endif
#if
expressions, for example:
/* no string operations allowed by the preprocessor */
#if MESSAGE > "hello"
#define DEBUG
#endif
defined()
pseudo-function in a preprocessor
expression requires its argument to be a single name. The name must start with a
letter and should be enclosed in parentheses, for example:
/* oops -- defined expects a name, not an expression */
#if defined(a&b)
input = read();
#endif
#if
expression has an illegal operator. Check for
correct syntax, for example:
#if FOO = 6 /* oops -- should that be: #if FOO == 5 ? */
#if
statement, for
example: #if FOO == \34
#define BIG
#endif
sizeof()
. The
preprocessor can only evaluate sizeof()
with basic types, or
pointers to basic types, for example:
#if sizeof(unt) == 2 /* should be: #if sizeof(int) == 2 */
i = 0xFFFF;
#endif
sizeof()
in a #if
expression, for example:
/* To sign, or not to sign, that is the error. */
#if sizeof(signed unsigned int) == 2
i = 0xFFFF;
#endif
sizeof()
was used in a preprocessor
#if
expression, but no type was specified. The argument to
sizeof()
in a preprocessor expression must be a valid simple
type, or pointer to a simple type, for example:
#if sizeof() /* oops -- size of what? */
i = 0;
#endif
The preprocessor has made an internal error in evaluating a
sizeof()
expression. Check for a malformed type specifier. This
is an internal error. Contact Microchip Technical Support with details.
sizeof()
in a #if
expression. Probable causes
are mismatched parentheses and similar things, for example:
#if sizeof(int == 2) // oops - should be: #if sizeof(int) == 2
i = 0xFFFF;
#endif
The preprocessor has tried to evaluate an expression with an operator it does not understand. This is an internal error. Contact Microchip Technical Support with details.
##
that is neither a letter nor a digit. Because the result of
this operator must be a legal token, the operands must be tokens containing only
letters and digits, for example:
/* the ’ character will not lead to a valid token */
#define cc(a, b) a ## ’b
##
that is neither a letter nor a digit. Because the
result of this operator must be a legal token, the operands must be tokens
containing only letters and digits, for example:
/* the ’ character will not lead to a valid token */
#define cc(a, b) a ## ’b
/* Here the comment begins. I’m not sure where I end, though
}
xc8 @communds
should that be:
xc8 @commands
An output file could not be created. Confirm the spelling and path of the file specified on the command line.
#if
, #ifdef
, etc., blocks can only be
nested to a maximum of 32.
A filename constructed while looking for an include file has exceeded the length of an internal buffer. Because this buffer is 4096 bytes long, this is unlikely to happen.
A maximum of 7 directories can be specified for the preprocessor to search for include files. The number of directories specified with the driver is too many.
A macro can only have up to 31 parameters, per the C Standard.
The total length of a macro expansion has exceeded the size of an internal table. This table is normally 32768 bytes long. Thus any macro expansion must not expand to a total of more than 32K bytes.
This is an internal compiler error. Contact Microchip Technical Support with details.
There were too many arguments supplied in a macro invocation. The maximum number allowed is 31.
This is an internal compiler error. Contact Microchip Technical Support with details.
A macro argument has exceeded the length of an internal buffer. This buffer is normally 4096 bytes long.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
A preprocessor control line (one starting with a #
) has
been encountered while expanding a macro. This should not happen.
This warning is either the result of user-defined
#warning
preprocessor directive, or the driver encountered a
problem reading the map file. If the latter, contact Microchip Technical Support
with details
#if defined(END)
#define NEXT
#endif END /* END would be better in a comment here */
#include
file name had to be converted to lowercase
before it could be opened, for example:
#include <STDIO.H> /* oops -- should be: #include <stdio.h> */
In Windows versions this means the file to be included actually exists
and is spelled the same way as the #include
filename; however, the
case of each does not exactly match. For example, specifying #include
“code.c”
will include Code.c, if it is found. In
Linux versions this warning could occur if the file wasn’t found.
The list of values to the preprocessor (CPP) -S
option
is incomplete. This should not happen if the preprocessor is being invoked by the
compiler driver. The values passed to this option represent the sizes of
char
, short
, int
,
long
, float
and double
types.
There were too many values supplied to the -S
preprocessor option. See message 166.
The option given to the component which caused the error is not recognized.
There is an unexpected character after #
.
#undef
was not
already defined. This warning can be disabled with some compilers. This warning can
be avoided with code like:
#ifdef SYM
#undef SYM /* only undefine if defined */
#endif
#define ADD(a, b) (a+b)
ADD(1, 2, 3) /* oops -- only two arguments required */
#
(not to be confused with
the leading #
used for preprocessor control lines) must be followed
by a formal macro parameter, for example:
#define str(x) #y /* oops -- did you mean x instead of y? */
If you need to stringize a token, you will need to define a special macro to do it, for example:
#define __mkstr__(x) #x
then use __mkstr__(token)
wherever you need
to convert token
into a string.
#if
expression was not a defined
preprocessor macro. For the purposes of this expression, its value has been taken as
zero. This warning can be disabled with some compilers. Example:
#if FOO+BAR /* e.g. FOO was never #defined */
#define GOOD
#endif
#if CHAR == ’ab’
#define MULTI
#endif
#if
expression, there is a division by zero
which has been treated as yielding zero, for example:
#if foo/0 /* divide by 0: was this what you were intending? */
int a;
#endif
A new line is missing at the end of the line. Each line, including the last line, must have a new line at the end. This problem is normally introduced by editors.
A macro name specified in a -U
option to the
preprocessor was not initially defined, and thus cannot be undefined.
output = 0; /* a comment that was left unterminated
flag = TRUE; /* next comment:
hey, where did this line go? */
Comments begun inside an included file must end inside the included file.
struct TEST test;
struct TEST * sp;
sp = test; /* oops -- did you mean: sp = &test; ? */
struct LAYOUT layout;
int i;
layout = i; /* int cannot be converted to struct */
Note that even if a structure only contains an int
, for example, it cannot be assigned to an int
variable and vice
versa.
int a, b, c, d;
a = b(c+d); /* b is not a function -- did you mean a = b*(c+d) ? */
A function-qualified interrupt cannot be called from other functions. It can only be called by a hardware (or software) interrupt. This is because an interrupt function has special function entry and exit code that is appropriate only for calling from an interrupt. An interrupt function can call other non-interrupt functions.
int get_value(void);
int main(void)
{
int input;
input = get_value(6); /* oops --
parameter should not be here */
}
void add(int a, int b);
add(5, 7, input); /* call has too many arguments */
void add(int a, int b);
add(5); /* this call needs more arguments */
int a;
switch(input) {
case a: /* oops!
cannot use variable as part of a case label */
input++;
}
int array[12.5]; /* oops -- twelve and a half elements, eh? */
int i, array[10];
i = array[3.5]; /* oops --
exactly which element do you mean? */
void
, for example:
lip = (long [])input; /* oops -- possibly: lip = (long *)input */
This symbol has been used in the program, but has not been defined or declared. Check for spelling errors if you think it has been defined.
This identifier is not a variable; it can be some other kind of object, i.e., a label.
if(a == b /* the closing parenthesis is missing here */
b = 0; /* the error is flagged here */
a /=% b; /* oops -- possibly that should be: a /= b; */
.
” , for example:
int a;
a.b = 9; /* oops -- a is not a structure */
A structure or union member name must follow a dot “.
”
or an arrow (“->
”).
struct WHAT what; /* a definition for WHAT was never seen */
if
,
while
statements or to boolean operators like
!
and &&
must be a scalar integral
type, for example:
struct FORMAT format;
if(format) /* this operand must be a scaler type */
format.a = 0;
&
operator, for example:
int * proc(register int in)
{
int * ip = ∈
/* oops -- in cannot have an address to take */
return ip;
}
&
operator is not one that denotes memory storage (“an lvalue”) and therefore its
address cannot be defined, for example:
ip = &8; /* oops -- you cannot take the address of a literal */
int array[10];
int * ip;
char c;
array = ip; /* array is not a variable, it cannot be written to */
A typecast does not yield an lvalue, for example:
/* the contents of c cast to int is only a intermediate value */
(int)c = 1;
However, you can write this using pointers:
*(int *)&c = 1
bit b;
int * ip;
ip = &b; /* oops -- cannot take the address of a bit object */
void run(void)
{
step();
return 1; /* either run should not be void, or remove the 1 */
}
This operator requires operands that are of integral type only.
A void
expression has no value and therefore you cannot
use it anywhere an expression with a value is required, i.e., as an operand to an
arithmetic operator.
A simple type (i.e., not an array or structure) is required as an operand to this operator.
int * ip;
char * cp, * cp2;
cp = flag ? ip : cp2; /* result of ? : will be int * or char * */
Possibly, you meant something like:
cp = flag ? (char *)ip : cp2;
The operands of this operator are of incompatible types.
This is an internal compiler error. Contact Microchip Technical Support with details.
It is illegal to use the sizeof()
operator with the C
__bit
type. When used against a type, the
sizeof()
operator gives the number of bytes required to store
an object that type. Therefore its usage with the __bit
type make
no sense and it is an illegal operation.
pragma pack
requires a decimal number as argument.
This specifies the alignment of each member within the structure. Use this with
caution as some processors enforce alignment and will not operate correctly if word
fetches are made on odd boundaries, for example:
#pragma pack /* what is the alignment value */
Possibly, you meant something like:
#pragma pack 2
The pragma interrupt_level
requires an argument to
indicate the interrupt level. It will be the value 1 for mid-range devices, or 1 or
2 or PIC18 devices.
pragma switch
requires an argument of auto, direct
or simple, for example:
#pragma switch /* oops -- this requires a switch mode */
Possibly, you meant something like:
#pragma switch simple
pragma psect
requires an argument of the form
oldname = newname
where
oldname
is an existing psect name known to the
compiler and newname
is the desired new name, for example:
#pragma psect /* oops -- this requires an psect to redirect */
Possibly, you meant something like:
#pragma psect text=specialtext
inline pragma
expects the name of a function to
follow. The function name must be recognized by the code generator for it to be
expanded; other functions are not altered, for example:
#pragma inline /* what is the function name? */
Possibly, you meant something like:
#pragma inline memcpy
printf_check pragma
expects the name of a function
to follow. This specifies printf-style format string checking for the function, for
example:
#pragma printf_check /* what function is to be checked? */
Possibly, you meant something like:
#pragma printf_check sprintf
Pragmas for all the standard printf-like function are already
contained in <stdio.h>
.
e
or E
, for example:
float f;
f = 1.234e; /* oops -- what is the exponent? */
0x
should follow at least one of the HEX digits
0-9 and A-F or a-f, for example:
a = 0xg6; /* oops -- was that meant to be a = 0xf6 ? */
0b
format
specifier, for example:
i = 0bf000; /* oops -- f000 is not a base two value */
0X
or 0x
. For example:
int a = 058; /* leading 0 implies octal which has digits 0 - 7 */
An illegal #
preprocessor has been detected. Likely, a
directive has been misspelled in your code somewhere.
char c = "; /* the character value of what? */
c = ’12’; /* oops -- only one character can be specified */
The only context in which two successive dots can appear is as part of the ellipsis symbol, which must have 3 dots (an ellipsis is used in function prototypes to indicate a variable number of parameters).
Either .. was meant to be an ellipsis symbol which would require you to add an extra dot, or it was meant to be a structure member operator which would require you to remove one dot.
c = a; /* oops -- did you mean c = ’a’; ? */
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
__at()
operator, used to associate an absolute address with a
variable, for example:
int address;
char LOCK __at(address);
int twice(int a)
{
return a*2;
}
/* only one prototype & definition of rv can exist */
long twice(long a)
{
return a*2;
}
typedef
declaration, because it
does not reserve any storage that can be initialized, for example:
/* oops -- uint is a type, not a variable */
typedef unsigned int uint = 99;
int a; /* a filescope variable called "a" */
int a; /* attempting to define another of the same name */
Note that variables with the same name, but defined with different scopes, are legal; but; not recommended.
/* three elements, but four initializers */
int ivals[3] = { 2, 4, 6, 8};
int iarray[10] = {{’a’, ’b’, ’c’};
/* oops -- one two many {s */
switch()
operator must have an expression that is
either an integral type or an enumerated value, e.g:
double d;
switch(d) { /* oops -- this must be integral */
case ’1.0’:
d = 0;
}
break
or continue
statement has been
found that is not enclosed in an appropriate control structure. A continue can only
be used inside a while
, for
, or do
while
loop, while break
can only be used inside those
loops or a switch
statement, for example:
switch(input) {
case 0:
if(output == 0)
input = 0xff;
} /* oops! this should not be here; it closed the switch */
break; /* this should be inside the switch */
default
label is allowed to be in a
switch()
statement. You have more than one, for example:
switch(a) {
default: /* if this is the default case... */
b = 9;
break;
default: /* then what is this? */
b = 10;
break;
A label has been encountered called default
, but it is
not enclosed by a switch
statement. A default label is only legal
inside the body of a switch
statement.
If there is a switch
statement before this default
label, there could be one too many closing braces in the switch
code. That would prematurely terminate the switch
statement. See
message 246.
A case
label has been encountered, but there is no
enclosing switch
statement. A case
label can only
appear inside the body of a switch
statement.
If there is a switch
statement before this
case
label, there might be one too many closing braces in the
switch
code. That would prematurely terminate the switch
statement, for example:
switch(input) {
case ’0’:
count++;
break;
case ’1’:
if(count>MAX)
count= 0;
} /* oops -- this shouldn’t be here */
break;
case ’2’: /* error flagged here */
start:
if(a > 256)
goto end;
start: /* error flagged here */
if(a == 0)
goto start; /* which start label do I jump to? */
else
keyword has been encountered that cannot be
associated with an if
statement. This can mean there is a missing
brace or other syntactic error, for example:
/* here is a comment which I have forgotten to close...
if(a > b) {
c = 0;
/* ... that will be closed here, thus removing the "if" */
else /* my "if" has been lost */
c = 0xff;
void set(char a)
{
PORTA = a;
/* the closing brace was left out here */
void clear(void) /* error flagged here */
{
PORTA = 0;
}
extern int array[5];
int array[10]; /* oops -- has it 5 or 10 elements? */
/* this is supposedly calc’s prototype */
extern int calc(int, int);
int calc(int a, long int b) /* hmmm -- which is right? */
{ /* error flagged here */
return sin(b/a);
}
extern int calc(int); /* this is supposedly calc’s prototype */
int calc(int a, int b) /* hmmm -- which is right? */
{ /* error flagged here */
return a + b;
}
This is an internal compiler error. Contact Microchip Technical Support with details.
struct {
int a, b, c;
} data;
if(data.d) /* oops -- there is no member d in this structure */
return;
A pointer declaration can only have 16 levels of indirection.
register
, for example:
void process(static int input)
typedef
. Remove the redundant qualifier. For example:
typedef volatile int vint;
/* oops -- this results in two volatile qualifiers */
volatile vint very_vol;
far
and
near
, for example:
far near int spooky; /* oops -- choose far or near, not both */
enum
tag has not been defined, for example:
enum WHAT what; /* a definition for WHAT was never seen */
struct
or
union
has already been used in this struct
or
union
, for example:
struct {
int a;
int b;
int a; /* oops -- a different name is required here */
} input;
struct {
int a;
} ms;
struct {
int a;
} ms; /* was this meant to be the same name as above? */
struct {
int a;
int get(int); /* should be a pointer: int (*get)(int); */
} object;
struct FREG {
char b0:1; /* these must be part of an int, not char */
char :6;
char b7:1;
} freg;
struct {
unsigned first: /* oops -- should be: unsigned first; */
unsigned second;
} my_struct;
If this was meant to be a structure with bit-fields, then the following illustrates an example:
struct {
unsigned first : 4; /* 4 bits wide */
unsigned second: 4; /* another 4 bits */
} my_struct;
struct {
/* no additional qualifiers can be present with members */
static int first;
} ;
auto int foo; /* auto not permitted with global variables */
int power(static int a) /* parameters cannot be static */
{
return foo * a;
}
extern static int where; /* so is it static or extern? */
int float input; /* is it int or float? */
register
qualifier, for example:
register int gi; /* this cannot be qualified register */
int process(register int input) /* this is okay */
{
return input + gi;
}
int
and double
can be qualified
with long. long char lc; /* what? */
int
can be modified with short
,
for example: short float sf; /* what? */
signed
and unsigned
cannot be used together in the same declaration, as they have opposite meaning, for
example:
signed unsigned int confused; /* which is it? */
unsigned
, for
example: unsigned float uf; /* what? */
/* K&R-style non-prototyped function definition */
int kandr(a, b, ...)
int a, b;
{
A type specifier is required for a prototyped argument. It is not acceptable to just have an identifier.
int plus(int a, b) /* oops -- a is prototyped, b is not */
int b;
{
return a + b;
}
/* cannot have two parameters called "a" */
int calc(int a, int a)
/* oops -- a is initialized when proc is called */
extern int proc(int a = 9);
int * farray[](); /* oops -- should be: int (* farray[])(); */
A function cannot return a function. It can return a function pointer. A
function returning a pointer to a function could be declared like this: int
(* (name()))()
. Note the many parentheses that are necessary to
make the parts of the declaration bind correctly.
A function can return only a scalar (simple) type or a structure. It cannot return an array.
/* This should be, for example: int arr[][7] */
int get_element(int arr[2][])
{
return array[1][6];
}
int array[0]; // oops -- you cannot have an array of size 0
void interrupt(void) /* what is the name of this function? */
{
}
This declarator is too complex for the compiler to handle. Examine the declaration and find a way to simplify it. If the compiler finds it too complex, so will anybody maintaining the code.
__bit
objects, or a
pointer to bit
variable, for example:
bit barray[10]; /* wrong -- no bit arrays */
bit * bp; /* wrong -- no pointers to bit variables */
void
. Only a function can be void,
for example:
int a;
void b; /* this makes no sense */
/* variables cannot be qualified interrupt */
interrupt int input;
const
or volatile
. This can indicate that you
have forgotten a star, *
, that is indicating that the function
should return a pointer to a qualified object, for example:
const char ccrv(void) /* const * char ccrv(void) perhaps? */
{ /* error flagged here */
return ccip;
}
int process(input)
int unput; /* oops -- that should be int input; */
{
}
A function parameter cannot be a function. It can be a pointer to a
function, so perhaps a *
has been omitted from the declaration.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This expression has caused overflow of the compiler’s internal stack and should be rearranged or split into two expressions.
This could be an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
#asm
block.
This probably means the #endasm
is missing or misspelled, for
example:
#asm
MOV r0, #55
MOV [r1], r0
} /* oops -- where is the #endasm */
int main(void)
{
init();
run(); /* is that it? What about the close brace */
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
The parser was unable to allocate memory for the longest string encountered, as it attempts to sort and merge strings. Try reducing the number or length of strings in this module.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
There are too many case labels in this switch
statement.
The maximum allowable number of case labels in any one switch
statement is 511.
There are too many symbols for the assembler’s symbol table. Reduce the number of symbols in your program.
process(carray[idx); /* oops --
should be: process(carray[idx]); */
A closing quote was expected for the indicated string.
The indicated token was expected by the parser.
/* the function block must follow, not a semicolon */
int get_value(a, b);
while(a) {
b = a-- /* oops -- where is the semicolon? */
} /* error is flagged here */
Note: Omitting a semicolon from statements not preceding a close brace or keyword typically results in some other error being issued for the following code which the parser assumes to be part of the original statement.
/* oops! no opening brace after the prototype */
void process(char c)
return max(c, 10) * 2; /* error flagged here */
}
char carray[4] = { 1, 2, 3, 4; /* oops -- no closing brace */
(
, was expected here. This
must be the first token after a while
, for
,
if
, do
or asm
keyword, for
example:
if a == b /* should be: if(a == b) */
b = 0;
asm
statement must be a string
enclosed in parentheses, for example:
asm(nop); /* that should be asm("nop");
while
is expected at the end of a
do
statement, for example:
do {
func(i++);
} /* do the block while what condition is true? */
if(i > 5) /* error flagged here */
end();
case
label, or after the
keyword default
. This often occurs when a semicolon is accidentally
typed instead of a colon, for example:
switch(input) {
case 0; /* oops -- that should have been: case 0: */
state = NEW;
goto
,
for example:
if(a)
goto 20;
/* this is not BASIC -- a valid C label must follow a goto */
enum
, must come either an identifier
that is, or will be, defined as an enum
tag, or an opening brace,
for example:
enum 1, 2; /* should be, for example: enum {one=1, two }; */
struct
or union
keyword, for example:
struct int a; /* this is not how you define a structure */
You might mean something like:
struct {
int a;
} my_struct;
/* oops -- missed a placeholder? */
printf("%d - %d", low, high, median);
printf()
style format string, and it is not
syntactically correct. If not corrected, this will cause unexpected behavior at
runtime, for example:
printf("%l", lll); /* oops -- possibly: printf("%ld", lll); */
long
argument is required for this
format specifier. Check the number and order of format specifiers and corresponding
arguments, for example:
printf("%lx", 2); // possibly you meant: printf("%lx", 2L);
long long
argument is required for this format
specifier. Check the number and order of format specifiers and corresponding
arguments, for example:
printf("%llx", 2); // possibly you meant: printf("%llx", 2LL);
printf("%d", 1.23); /* wrong number or wrong placeholder */
%f
or similar, and requires a floating-point expression. Check
for missing or extra format specifiers or arguments to printf.
printf("%f", 44); /* should be: printf("%f", 44.0); */
A pointer argument is required for this format specifier. Check the number and order of format specifiers and corresponding arguments.
printf("%d - %d", low); /* oops! where is the other value to print? */
pragma interrupt_level
must have an argument from 0
to 7; however, mid-range devices only use level 1. PIC18 devices can use levels 1 or
2. For example:
#pragma interrupt_level 9 /* oops -- the level is too high */
void interrupt isr(void)
{
/* isr code goes here */
}
pragma strings
was passed a qualifier that was not
identified, for example:
/* oops -- should that be #pragma strings const ? */
#pragma strings cinst
#pragma printf_check
was passed a qualifier that
could not be identified, for example:
/* oops -- should that be const not cinst? */
#pragma printf_check(printf) cinst
pragma
directive was encountered, for
example:
#pragma rugsused myFunc w /* I think you meant regsused */
char * cp = "hi"
"there"; /* this is okay, but is it what you had intended? */
The last line in the file is missing the newline (operating system dependent character) from the end. Some editors will create such files, which can cause problems for include files. The C standard requires all source files to consist of complete lines only.
The application tried to create or open the named file, but it could not be created. Check that all file path names are correct.
extern
has an
initializer. This overrides the extern
storage class, because to
initialize an object it is necessary to define (i.e., allocate storage for) it, for
example:
extern int other = 99; /* if it’s extern and not allocated
storage, how can it be initialized? */
char
array is being initialized with a string literal
larger than the array. Hence there is insufficient space in the array to safely
append a null terminating character, for example:
char foo[5] = "12345"; /* the string stored in foo won’t have
a null terminating, i.e.
foo = [’1’, ’2’, ’3’, ’4’, ’5’] */
return
statement with a value, or
if the function is not to return a value, declare it void
, for
example:
int mydiv(double a, int b)
{
if(b != 0)
return a/b; /* what about when b is 0? */
} /* warning flagged here */
return
statement that does not specify a return value, for
example:
int get_value(void)
{
if(flag)
return val++;
return;
/* what is the return value in this instance? */
}
while(1) /* how does this loop finish? */
process();
flag = FINISHED; /* how do we get here? */
int input; /* input has filescope */
void process(int a)
{
int input; /* local blockscope input */
a = input; /* this will use the local variable. Is this right? */
extern
declaration. This is
legal but is invariably not desirable as it restricts the scope of the function
declaration to the function body. This means that if the compiler encounters another
declaration, use, or definition of the extern
object later in the
same file, it will no longer have the earlier declaration and thus will be unable to
check that the declarations are consistent. This can lead to strange behavior of
your program or signature errors at link time. It will also hide any previous
declarations of the same thing, again subverting the compiler’s type checking. As a
general rule, always declare extern
variables and functions outside
any other functions. For example:
int process(int a)
{
/* this would be better outside the function */
extern int away;
return away + a;
}
An auto variable should not have qualifiers such as
near
or far
associated with it. Its storage
class is implicitly defined by the stack organization. An auto variable can be
qualified with static
, but it is then no longer auto.
int process(input)
int input; /* warning flagged here */
{
}
This would be better written:
int process(int input)
{
}
The indicated object was never used in the function or module being
compiled. Either this object is redundant, or the code that was meant to use it was
excluded from compilation or misspelled the name of the object. Note that the
symbols rcsid
and sccsid
are never reported as
being unused.
float
, the compiler converts this to a double
.
This is because the default C type conversion conventions provide that when a
floating-point number is passed to a non-prototyped function, it is converted to
double
. It is important that the function declaration be
consistent with this convention, for example:
double inc_flt(f) /* f will be converted to double */
float f; /* warning flagged here */
{
return f * 2;
}
The size of an external array evaluates to zero. This is probably due to the array not having an explicit dimension in the extern declaration.
A pointer qualified far has been assigned to a default pointer, or a pointer qualified near, or a default pointer has been assigned to a pointer qualified near. This can result in truncation of the pointer and loss of information, depending on the memory model in use.
signed char sc;
unsigned int ui;
ui = sc; /* if sc contains 0xff, ui will contain 0xffff for example */
will perform a sign extension of the char variable to the longer type. If you do not want this to take place, use a cast, for example:
ui = (unsigned char)sc;
double dd;
int i;
i = dd; /* is this really what you meant? */
If you do intend to use an expression like this, then indicate that this is so by a cast:
i = (int)dd;
&
address operator, for example:
int * ip;
int i;
ip = i; /* oops -- did you mean ip = &i ? */
If you do intend to use an expression like this, then indicate that this is so by a cast:
ip = (int *)i;
*
dereference operator, for example:
int * ip;
int i;
i = ip; /* oops -- did you mean i = *ip ? */
If you do intend to use an expression like this, indicate your intention by a cast:
i = (int)ip;
long input;
char * cp;
cp = &input; /* is this correct? */
This is a common way of accessing bytes within a multi-byte variable. To indicate that this is the intended operation of the program, use a cast:
cp = (char *)&input; /* that’s better */
This warning can also occur when converting between pointers to objects that have the same type, but which have different qualifiers, for example:
char * cp;
/* yes, but what sort of characters? */
cp = "I am a string of characters";
If the default type for string literals is const char
*
, then this warning is quite valid. This should be written:
const char * cp;
cp = "I am a string of characters"; /* that’s better */
Omitting a qualifier from a pointer type is often disastrous and almost certainly not what you intend.
int i, * ip, input[10];
i = input[-2]; /* oops -- this element doesn’t exist */
ip = &input[5];
i = ip[-2]; /* this is okay */
extern
or static
, as appropriate. For example:
/* I can prevent an error arising from calls below */
extern void set(long a, int b);
int main(void)
{
/* at this point, a prototype for set() has already been seen */
set(10L, 6);
}
&
has been applied to an array.
Because using the name of an array gives its address anyway, this is unnecessary and
has been ignored, for example:
int array[5];
int * ip;
/* array is a constant, not a variable; the & is redundant. */
ip = &array;
&
has been applied to a
function. Because using the name of a function gives its address anyway, this is
unnecessary and has been ignored, for example:
extern void foo(void);
int main(void)
{
void(*bar)(void);
/* both assignments are equivalent */
bar = &foo;
bar = foo; /* the & is redundant */
}
const
or code
cannot
be assigned to or modified in any other way by your program. The effect of
attempting to modify such an object is compiler specific.
const int out = 1234; /* "out" is read only */
out = 0; /* oops -- writing to a read-only object */
char * get_addr(void)
{
char c;
/* returning this is dangerous; the pointer could be dereferenced */
return &c;
}
The operands of this operator are of different pointer types. This probably means you have used the wrong pointer, but if the code is actually what you intended, use a typecast to suppress the error message.
extern
, possibly
through an implicit declaration. It has now been redeclared static
,
but this redeclaration is invalid.
int main(void)
{
/* at this point the compiler assumes set is extern... */
set(10L, 6);
}
/* now it finds out otherwise */
static void set(long a, int b)
{
PORTA = a + b;
}
/* param should be: "int array[]" or "int *" */
int get_first(int array[10])
{ /* warning flagged here */
return array[0];
}
int
, the compiler still treats it as unsigned, for example:
struct {
signed int sign: 1; /* oops -- this must be unsigned */
signed int value: 7;
} ;
/* here ling is assumed to be int */
unsigned char bar = (unsigned ling) ’a’;
int
has been assumed. This declaration is not illegal, but it is preferable to include a
basic type to make it clear what is intended, for example:
char c;
i; /* don’t let the compiler make assumptions, use : int i */
func(); /* ditto, use: extern int func(int); */
unsigned char a;
/* thinks: chat & b are unsigned, but where is the comma? */
unsigned chat b;
unsigned
type was expected where a
signed
type was given and was implicitly converted to
unsigned
, for example:
unsigned int foo = -1;
/* the above initialization is implicitly treated as:
unsigned int foo = (unsigned) -1; */
int
., for example:
int i = (signed) 2; /* (signed) assumed to be (signed int) */
This is an internal compiler error. Contact Microchip Technical Support with details.
The linker has encountered a top level node in the call graph that is referenced from lower down in the call graph. This probably means the program has indirect recursion, which is not allowed when using a compiled stack.
This type of file could not be created. Is the file, or a file by this name, already in use?
This is an internal compiler error. Ensure that the object file is a valid object file. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This message is produced by the dump
or
xstrip
utilities and indicates that the object file is not a
valid object file, or that it has been truncated. Contact Microchip Technical
Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
There has been more than one linker -g
option, or the
-g
option did not have any arguments following. The arguments
specify how the segment addresses are calculated.
The map file name has been specified to the linker for a second time. This should not occur if you are using a compiler driver. If invoking the linker manually, ensure that only one instance of this option is present on the command line.
This linker -o
flag is illegal, or another
-o
option has been encountered. A -o
option to
the linker must be immediately followed by a filename with no intervening space.
There have been too many -p
options passed to the
linker, or a -p
option was not followed by any arguments. The
arguments of separate -p
options can be combined and separated by
commas.
The -Q
linker option requires the machine type for an
argument.
The -U
(undefine) option needs an argument.
The -W
option (listing width) needs a numeric
argument.
The symbol file name has been specified to the linker for a second time. This should not occur if you are using a compiler driver. If invoking the linker manually, ensure that only one instance of either of these options is present on the command line.
The maximum number of errors before aborting must be specified following
the -j
linker option.
Improper usage of the command-line linker. If you are not invoking the linker directly, this could be an internal compiler error, and you should contact Microchip Technical Support with details.
The linker has detected an attempt to write its output file over one of its input files. This cannot be done, because it needs to simultaneously read and write input and output files.
This is an internal compiler error. The object code format of an object file is invalid. Ensure it is a valid object file. Contact Microchip Technical Support with details.
The -F
option for objtohex has been supplied an invalid
argument. If you are not invoking this tool directly, this is an internal compiler
error, and you should contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
The first value to the OBJTOHEX -n,m
HEX
length/rounding option is invalid.
The second value to the OBJTOHEX -n,m
HEX
length/rounding option is invalid.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This option requires an integer argument in either base 8, 10, or 16. If you are not invoking this tool directly, this is an internal compiler error and you should contact Microchip Technical Support with details.
This option requires an integer argument in either base 8, 10, or 16. If you are not invoking this tool directly, this is an internal compiler error and you should contact Microchip Technical Support with details.
The combination of options supplied to OBJTOHEX is invalid.
Code in some things must start at zero. Here it doesn’t.
A write error occurred on the named file. This probably means you have run out of disk space.
The linker encountered an error trying to read this file.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
The object file passed to OBJTOHEX has relocation items in it. This can indicate it is the wrong object file, or that the linker or OBJTOHEX have been given invalid options. The object output files from the assembler are relocatable, not absolute. The object file output of the linker is absolute.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
This object file has no end record. This probably means it is not an object file. Contact Microchip Technical Support if the object file was generated by the compiler.
There is an error in an object file. This is either an invalid object file, or an internal error in the linker. Contact Microchip Technical Support with details if the object file was created by the compiler.
This is an internal compiler error. Contact Microchip Technical Support with details.
The object file passed to OBJTOHEX or the librarian is corrupted. Contact Microchip Technical Support with details.
There is a syntax error in a list read by OBJTOHEX. The list is read from standard input in response to an option.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
A list supplied to OBJTOHEX is syntactically incorrect.
This option requires an integer argument in either base 8, 10, or 16. If
you are invoking objtoexe
directly then check this argument.
Otherwise, this can be an internal compiler error and you should contact Microchip
Technical Support with details.
Improper usage of the command-line tool objtohex
. If
you are not invoking this tool directly, this is an internal compiler error and you
should contact Microchip Technical Support with details.
There are too many symbols in the symbol table, which has a limit of * symbols. Change some global symbols to local symbols to reduce the number of symbols.
-G
) to the linker is
invalid, for example: -GA/f0+10
Did you forget the radix?
-GA/f0h+10
This psect has had its start address specified more than once.
A class spec needs an =
sign, e.g.,
-Ctext=ROM
.
-S
specification is invalid, it
should be a valid number, in decimal, octal, or hexadecimal radix. The radix is
specified by a trailing O
, for octal, or H
for
HEX. A leading 0x
can also be used for hexadecimal. Case in not
important for any number or radix. Decimal is the default, for example:
-SCODE=f000
Did you forget the radix?
-SCODE=f000h
-D
specification, giving a delta value
to a class, is invalid, for example:
-DCODE
What is the delta value for this class? Possibly, you meant something like:
-DCODE=2
The delta value supplied to a -D
specification is
invalid. This value should an integer of base 8, 10, or 16.
-A
specification, giving address ranges
to the linker, is invalid, for example:
-ACODE
What is the range for this class? Possibly, you meant:
-ACODE=0h-1fffh
-A
specification, giving address ranges
to the linker, is invalid, for example:
-ACODE=
What is the range for this class? Possibly, you meant:
-ACODE=0h-1fffh
-A
specification is invalid:
it should be a valid number, in decimal, octal, or hexadecimal radix. The radix is
specified by a trailing O
(for octal) or H
for
HEX. A leading 0x
can also be used for hexadecimal. Case in not
important for any number or radix. Decimal is default, for example:
-ACODE=1fff-3fffh
Did you forget the radix?
-ACODE=1fffh-3fffh
-
, between the high and
low addresses in a -A
linker option, for example:
-AROM=1000h
Possibly, you meant:
-AROM=1000h-1fffh
-A
specification is invalid:
it should be a valid number, in decimal, octal, or hexadecimal radix. The radix is
specified by a trailing O
, for octal, or H
for
HEX. A leading 0x
can also be used for hexadecimal. Case in not
important for any number or radix. Decimal is the default, for example:
-ACODE=0h-ffff
Did you forget the radix?
-ACODE=0h-ffffh
-A
specification is
invalid: it should be a valid number, in decimal, octal, or hexadecimal radix. The
radix is specified by a trailing O
(for octal) or
H
for HEX. A leading 0x
can also be used for
hexadecimal. Case in not important for any number or radix. Decimal is default, for
example: -AENTRY=0-0FFh-1FF
Did you forget the radix?
-AENTRY=0-0FFh-1FFh
-A
specification is invalid:
it should be a valid number, in decimal, octal, or hexadecimal radix. The radix is
specified by a trailing O
(for octal) or H
for
HEX. A leading 0x
can also be used for hexadecimal. Case in not
important for any number or radix. Decimal is default, for example:
-ACODE=0h-3fffh/a000
Did you forget the radix?
-ACODE=0h-3fffh/a000h
-A
specification is
invalid, for example: -AENTRY=0-0FFhxf
Did you forget the radix?
-AENTRY=0-0FFhxfh
-A
spec is invalid. A valid -A
spec should be something like:
-AROM=1000h-1FFFh
This psect has been listed in a -P
option, but is not
defined in any module within the program. Alternatively, the psect is defined using
the local
psect flag, but with no class
flag; and,
so, cannot be linked to an address. Check the assembly list file to ensure that the
psect exists and that it is does not specify the local psect flag.
-p
option is not a validly formed
decimal, octal, or HEX number, nor is it the name of an existing psect. A HEX number
must have a trailing H
, for example:
-pbss=f000
Did you forget the radix?
-pbss=f000h
-p
option is badly formatted, for example:
-pbss=data+f000
Did you forget the radix?
-pbss=data+f000h
The %
operator in a -p
option (for
rounding boundaries) must have a number after it.
-Pmypsect=1000h/.
-Pmypsect=./1000h
Both of these options are valid and equivalent. However, the following usage is ambiguous:
-Pmypsect=./.
What is the link or load address of this psect?
This psect is not relocated on the required boundary. Check the
relocatability of the psect and correct the -p
option. if
necessary.
This psect has a relocatability requirement that is not met by the load
address given in a -p
option. For example, if a psect must be on a
4K byte boundary, you could not start it at 100H.
The creation of the output file failed when removing an intermediate file.
The creation of the output file failed when renaming an intermediate file.
This is an internal compiler error. Contact Microchip Technical Support with details.
This is an internal compiler error. Contact Microchip Technical Support with details.
The linker has found an undefined symbol in the FNBREAK
record for a non-reentrant function. Contact Microchip Technical Support if this is
not handwritten assembler code.
The linker has found an undefined symbol in the FNINDIR
record for a non-reentrant function. Contact Microchip Technical Support if this is
not handwritten assembler code.
The linker has found an undefined symbol in the FNADDR
record for a non-reentrant function. Contact Microchip Technical Support if this is
not handwritten assembler code.
The linker has found an undefined symbol in the FNCALL
record for a non-reentrant function. Contact Microchip Technical Support if this is
not handwritten assembler code.
The linker has found an undefined symbol in the FNROOT
record for a non-reentrant function. Contact Microchip Technical Support if this is
not handwritten assembler code.
The linker has found an undefined symbol in the FNSIZE
record for a non-reentrant function. Contact Microchip Technical Support if this is
not handwritten assembler code.
reentrant
keyword (if supported with this compiler) or
recode to avoid recursion, for example:
int test(int a)
{
if(a == 5) {
/* recursion cannot be supported by some compilers */
return test(a++);
}
return 0;
}
reentrant
keyword, if this compiler supports it, or recode
to avoid using local variables or parameters, or duplicate the function, for
example:
void interrupt my_isr(void)
{
scan(6); /* scan is called from an interrupt function */
}
void process(int a)
{
scan(a); /* scan is also called from main-line code */
}
#pragma interrupt_level 1
void foo(void)
{
...
}
#pragma interrupt_level 1
void interrupt bar(void)
{
// this function never calls foo()
}
The FNCONF
assembler directive which specifies to the
linker information regarding the auto/parameter block was never seen. This is
supplied in the standard runtime files if necessary. This error can imply that the
correct run-time startup module was not linked. Ensure you have used the
FNCONF
directive if the runtime startup module is
hand-written.
The linker has seen two conflicting FNCONF
directives.
This directive should be specified only once and is included in the standard runtime
startup code which is normally linked into every program.
The linker was asked to relocate (fixup) an item that would not fit back into the space after relocation. See the following error message (1356) for more information.
The linker was asked to relocate (fixup) an item that would not fit back into the space after relocation. See the following error message (1356) for more information.
This is an internal compiler error. Contact Microchip Technical Support with details.
The specified symbol has been equated to an external symbol which, in turn, has been equated to the first symbol.
extern int get_value(int in);
/* and in another module: */
/* this is different to the declaration */
int get_value(int in, char type)
{
A common symbol has been defined to be in more than one psect.
_next:
MOVE r0, #55
MOVE [r1], r0
_next: ; oops -- choose a different name
The linker will issue this warning if the symbol (C or assembler) was defined multiple times in different modules. The names of the modules are given in the error message. Note that C identifiers often have an underscore prepended to their name after compilation.
This is an internal compiler error. Contact Microchip Technical Support with details.
class=
options to the
PSECT
directive, or use of the -C
option to
the linker, for example:
psect final,class=CODE
finish:
/* elsewhere: */
psect final,class=ENTRY
with
flag. The psect it has been placed with does not exist,
for example:
psect starttext,class=CODE,with=rext
; was that meant to be with text?
The selector
value for this psect has been defined more
than once.
This psect has had its type defined differently by different modules. This probably means you are trying to link incompatible object modules, i.e., linking 386 flat model code with 8086 real mode code.
psect spdata,class=RAM,space=0
ds 6
; elsewhere:
psect spdata,class=RAM,space=1
global
psect has been defined with two different
delta
values, for example:
psect final,class=CODE,delta=2
finish:
; elsewhere:
psect final,class=CODE,delta=1
A class has been defined in two different memory spaces. Either rename one of the classes or, if they are the same class, place them in the same memory space.
One of the main tasks the linker performs is positioning the blocks (or
psects) of code and data that is generated from the program into the memory
available for the target device. This error indicates that the linker was unable to
find an area of free memory large enough to accommodate one of the psects. The error
message indicates the name of the psect that the linker was attempting to position
and the segment name which is typically the name of a class which is defined by a
-A
linker option issued by the compiler driver. Typically psect
names which are, or include, text
relate to program code. Names
such as bss
or data
refer to variable blocks. This
error can be due to two reasons.
First, the size of the program or the program’s data has exceeded the total amount of space on the selected device. In other words, some part of your device’s memory has completely filled. If this is the case, then the size of the specified psect must be reduced.
The second cause of this message is when the total amount of memory needed by the psect being positioned is sufficient, but that this memory is fragmented in such a way that the largest contiguous block is too small to accommodate the psect. The linker is unable to split psects in this situation. That is, the linker cannot place part of a psect at one location and part somewhere else. Thus, the linker must be able to find a contiguous block of memory large enough for every psect. If this is the cause of the error, then the psect must be split into smaller psects if possible.
To find out what memory is still available, generate and look in the map file. Search for the string UNUSED ADDRESS RANGES. Under this heading, look for the name of the segment specified in the error message. If the name is not present, then all the memory available for this psect has been allocated. If it is present, there will be one address range specified under this segment for each free block of memory. Determine the size of each block and compare this with the number of words specified in the error message.
Psects containing code can be reduced by using all the compiler’s optimizations, or restructuring the program. If a code psect must be split into two or more small psects, this requires splitting a function into two or more smaller functions (which can call each other). These functions can need to be placed in new modules.
Psects containing data can be reduced when invoking the compiler
optimizations, but the effect is less dramatic. The program can need to be rewritten
so that it needs less variables. If the default linker options must be changed, this
can be done indirectly through the driver using the driver -Wl,
option. If a data psect cannot be positioned, then you typically need to reduce the
total size of variables being used.
For example, after receiving the message:
Can’t find 0x34 words (0x34 withtotal) for psect text in segment CODE (error)
look in the map file for the ranges of unused memory.
UNUSED ADDRESS RANGES
CODE 00000244-0000025F
00001000-0000102f
RAM 00300014-00301FFB
In the CODE
segment, there is 0x1c (0x25f-0x244+1)
bytes of space available in one block and 0x30 available in another block. Neither
of these are large enough to accommodate the psect text
which is
0x34 bytes long. Notice that the total amount of memory available is larger than
0x34 bytes. If the function that is encoded into the text
psect can
be split into two smaller functions, there is a chance the program will link
correctly.
This psect is absolute and should not have an address specified in a
-P
option. Either remove the abs
psect flag,
or remove the -P
linker option.
The origin of this psect is defined more than once. There is most likely
more than one -p
linker option specifying this psect.
-P
option given to the linker is malformed. This
option specifies placement of a psect, for example:
-Ptext=10g0h
Possibly, you meant:
-Ptext=10f0h
It is not legal to specify both the link and location of a psect as within a class, when that psect was also defined using a with psect flag.
The psect has more bytes in it than the maximum allowed as specified
using the size
psect flag.
The maximum address of the psect exceeds the limit placed on it using
the limit
psect flag. Either the psect needs to be linked at a
different location or there is too much code/data in the psect.
The symbol following is undefined at link time. This could be due to spelling error, or failure to link an appropriate module.