This attribute was expected to appear at least once but was not defined for this chip.
This value of this attribute is blank in the chip configuration file.
There are too many attributes for the listed specification in the chip configuration file.
This attribute was expected to appear a certain number of times; but it did not appear for this chip.
This attribute can only be defined once, but has been defined more than once for this chip.
The chip configuration file contains an attribute that is not understood by this version of the compiler. Has the chip configuration file or the driver been replaced with an equivalent component from another version of this compiler?
The chip configuration file incorrectly defines the specified value for this device. If you are modifying this file yourself, take care and refer to the comments at the beginning of this file for a description on what type of values are expected here.
The chip configuration file incorrectly defines the specified range for this device. If you are modifying this file yourself, take care and refer to the comments at the beginning of this file for a description on what type of values are expected here.
The chip configuration file contains a syntax error at the line specified.
The attribute at the line indicated defines an architecture that is unknown to this compiler.
The chipinfo file has a device section without an ARCH
values. The architecture of the device must be specified. Contact Microchip
Technical Support if the chipinfo file has not been modified.
The compiler was successfully activated.
The compiler did not activated successfully.
This compiler has failed to find any activation information and cannot proceed to execute. The compiler can have been installed incorrectly or incompletely. The error code quoted can help diagnose the reason for this failure. You can be asked for this failure code if contacting Microchip for assistance with this problem.
Indicating the version number of the Hexmate being executed.
The suggested usage of Hexmate.
More detailed information is available for a specific option by passing
that option to the -HELP
option.
This is a simple heading that appears before the list of available options for this application.
It looks like you need help. This advisory suggests how to get more information about the options available to this application or the usage of these options.
The number of arguments to a function is unreasonable. This is an internal compiler error. Contact Microchip Technical Support with details.
The length of the optional header in this COFF file was of an incorrect length.
When reading the type of data indicated in this message, it terminated before reaching its specified length.
The specified length of the COFF string table is less than the minimum.
The number of symbols in the symbol table has exceeded the number indicated in the COFF header.
A record of the type specified failed to match its own value.
While reading a file, one of the file’s records ended short of its specified length.
The type indicator of this record did not match any valid types for this file format.
When reading this Microchip COFF file, the optional header within the file header was of an incorrect length.
The end of the file was found while more data was expected. Has this input file been truncated?
A while reading a block of byte data from a UBROF record, the block ended before the expected length.
A while reading a string from a UBROF record, the string ended before the specified length.
This UBROF file did not begin with the correct record.
This UBROF file has a bad time/date stamp.
An end record has a mismatching CRC value in this UBROF file.
A debug record has a bad date component in this UBROF file.
A start of program record or segment record has a bad date component in this UBROF file.
A record type could not be determined when reading this UBROF file.
A block of additional RAM being requested exceeds the size of a bank. Try breaking the block into multiple ranges that do not cross bank boundaries.
The RAM memory range as defined through custom RAM configuration is out of range.
The RAM memory range as defined in the chip configuration file or through custom configuration is out of range.
The compiler is attempting to compile for a device of an architecture that is either unsupported or disabled.
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 persistent
variable has been assigned an initial
value. This is somewhat contradictory as the initial value will be assigned to the
variable during execution of the compiler’s startup code; however, the persistent
qualifier requests that this variable shall be unchanged by the compiler’s startup
code.
This is an internal compiler error. Contact Microchip Technical Support with details.
void (*fp)(int);
fp(23); /* oops -- what function does fp point to? */
A recursive call to the specified function has been found. The call can be direct or indirect (using function pointers) and can be either a function calling itself, or calling another function whose call graph includes the function under consideration.
This variable is declared but has not been used by the program. Consider removing it from the program.
The main function has not been defined. Every C program must have a
function called main()
.
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.
extern long int test;
int test; /* oops -- which is right? int or long int ? */
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.
The working register required here has to be W9, but an other working register was selected.
The working register required here has to be W11, but an other working register was selected.
This option no longer exists in this version of the compiler and has
been ignored. Use the compiler’s --help
option or refer to the
manual to find a replacement option.
The interrupt level for the function specified is too high. Each
interrupt function is assigned a unique interrupt level. This level is considered
when analyzing the call graph and reentrantly called functions. If using the
interrupt_level
pragma, check the value specified.
The directory specified in the setup option does not exist. Create the directory and try again.
A variable qualified as near
must also be qualified with
static
or made global. An auto variable cannot be qualified as
near.
During activation, no matching version number was found on the Microchip activation server database for the serial number specified.
The number of activations of the serial number specified has exceeded the maximum number allowed for the license.
During activation, no matching serial number was found on the Microchip activation server database.
The time-limited license for this compiler has expired.
The compiler has not been correctly activated.
The compiler activation software was unable to connect to the Microchip activation server via the network.
Indicates that this compiler has been activated with an FAE license. This license does not permit the product to be used for the development of commercial applications.
Indicates that this compiler has been activated with an education license. The educational license is only available to educational facilities and does not permit the product to be used for the development of commercial applications.
Indicates that this compiler has been activated with an evaluation license.
The compiler has been installed as a time-limited trial. This trial will end on the date specified.
A command line option that accepts additional parameters was given inappropriate data or insufficient data. For example, an option can expect two parameters with both being integers. Passing a string as one of these parameters or supplying only one parameter could result in this error.
This option has been specified too many times. If possible, try performing these operations over several command lines.
The trial period for this compiler has expired. The compiler is now inoperable until activated with a valid serial number. Contact Microchip to purchase this software and obtain a serial number.
The code sequence specified in a -FIND
option has been
found at this address.
All find, replace and mask attributes in this option must be of the same byte width. Check the parameters supplied to this option. For example, finding 1234h (2 bytes) masked with FFh (1 byte) results in an error; but, masking with 00FFh (2 bytes) works.
An unknown or unsupported INHX format has been requested. Refer to documentation for supported INHX formats.
Data to this option was not entered as whole bytes. Perhaps the data was incomplete or a leading zero was omitted. For example, the value Fh contains only four bits of significant data and is not a whole byte. The value 0Fh contains eight bits of significant data and is a whole byte.
An illegal length of data was given to this option. The value provided to this option exceeds the maximum or minimum bounds required by this option.
This is the compiler configuration file selected during compiler setup.
This can be changed via the HTC_XML
environment variable. This file
is used to determine where the compiler has been installed.
Some of the command line options passed to the driver have now been discontinued in this version of the compiler; however, during a grace period these old options will still be processed by the driver.
An obsolete option was detected. Use --help
or refer to
the manual to find a replacement option that will not result in this advisory
message.
The options passed to the driver resemble those that the Microchip MPLAB 8 IDE would pass to a previous version of this compiler. Some of these options are now obsolete – however, they were still interpreted. It is recommended that you install an updated Microchip options plug-in for the IDE.
Visit our website to see if an upgrade is available to address the issue(s) listed in the previous compiler message. Navigate to the MPLAB XC8 C Compiler page and look for a version upgrade downloadable file. If your version is current, contact Microchip Technical Support for further information.
The code sequence specified in a -FIND
option has been
found at this address.
The chipinfo file has a device section with multiple ARCH values. Only one ARCH value is allowed. If you have not manually edited the chip info file, contact Microchip Technical Support with details.
The assembler attempted to create a cross reference file; but it could not be created. Check that the file’s path name is correct.
The compiler cannot determine the directory where it has been installed.
A pointer that has not yet been assigned a value has been dereferenced. This can result in erroneous behavior at runtime.
The token contained in the USB descriptor file was not recognized.
An option that can take additional parameters was given an invalid parameter value. Check the usage of the option or the syntax or range of the expected parameter.
An attempt has been made to define endpoint 0 in a USB file.
FNALIGN
directive, but one function calls the other, which
implies that must not be aligned. This will occur if a function pointer is assigned
the address of each function, but one function calls the other. For example:
int one(int a) { return a; }
int two(int a) { return two(a)+2; } /* ! */
int (*ip)(int);
ip = one;
ip(23);
ip = two; /* ip references one and two; two calls one */
ip(67);
void (*fp)(int);
fp(23); /* oops -- what function does fp point to? */
The error file specified after the -Efile
or
-E+file
options could not be opened. Check to ensure
that the file or directory is valid and that has read only access.
The start of range address for the --CHECKSUM
option
could not be read. This value must be a hexadecimal number.
The end of range address for the --CHECKSUM
option
could not be read. This value must be a hexadecimal number.
The destination address for the --CHECKSUM
option could
not be read. This value must be a hexadecimal number.
The align operand to the Hexmate
-FIND
option must be positive.
No memory has been specified to cover the banked RAM memory.
No memory has been specified to cover the access bank memory.
The code generator was asked to position a variable, but the size of the variable is not known. This is an internal compiler error. Contact Microchip Technical Support with details.
The code generator could not find space in the banked RAM for the variable specified.
The code generator could not find space in RAM for the psect that holds auto and parameter variables.
The code generator could not find space in RAM for the data psect that holds initialized variables.
-O
or --OUTDIR
options, for
example: --outdir=../../ -o../main.HEX
0x
. For example:
MOV a, F7h ; is this the symbol F7h, or the HEX number 0xF7?
int main(void) {
double src, out;
out = sin(src); /* oops -- what value was in src? */
The call tree analysis by the code generator indicates that the hardware stack can overflow. This should be treated as a guide only. Interrupts, the assembler optimizer and the program structure can affect the stack usage. The stack usage is based on the C program and does not include any call tree derived from assembly code.
--opt=speed,space
MACRO fin
ret
ENDM
MACRO fin ; oops -- was this meant to be a different macro?
reti
ENDM
DS
or
DSU
directive, for example:
DS ONE ; oops -- did you mean DS "ONE"?
int data __at(0x800); /* oops -- is this the correct address? */
struct ONE {
unsigned a;
long b; /* ! */
} one;
struct TWO {
unsigned a;
unsigned b; /* ! */
} two;
struct ONE * oneptr;
oneptr = & two; /* oops -- was ONE meant to be same struct as TWO? */
See error message 1356 for more information.
See error message 1356 for more information.
This message advises that advanced features of the compiler are not be enabled in this Free mode compiler.
interrupt int dacResult; /* oops --
the interrupt qualifier can only be used with functions */
A buffer associated with the ELF/DWARF debug file has overflowed. Contact Microchip Technical Support with details.
A variable has no storage location listed and will be omitted from the debug output. Contact Microchip Technical Support with details.
The map file being read to produce a memory summary is malformed. Either the file has been edited or corrupted, or this is a compiler error – contact Microchip Technical Support with details.
The map file being read to produce a memory summary is malformed. Either the file has been edited or corrupted, or this is a compiler error – contact Microchip Technical Support with details.
The map file being read to produce a memory summary is malformed. Either the file has been edited or corrupted, or this is a compiler error – contact Microchip Technical Support with details.
The map file being read to produce a memory summary is malformed. Either the file has been edited or corrupted, or this is a compiler error – contact Microchip Technical Support with details.
The map file being read to produce a memory summary is malformed. Either the file has been edited or corrupted, or this is a compiler error – contact Microchip Technical Support with details.
A C statement has produced assembly code output whose length exceeds a preset limit. This means that debug information produced by CROMWELL may not be accurate. This warning does not indicate any potential code failure.
A buffer associated with the ELF/DWARF debug file has overflowed. Contact Microchip Technical Support with details.
An ELF file passed to CROMWELL is malformed and cannot be used.
The named SDB file passed to CROMWELL is malformed and cannot be used.
The type of symbol could not be determined from the SDB file passed to CROMWELL. Either the file has been edited or corrupted, or this is a compiler error – contact Microchip Technical Support with details.
The compiler is running as a demo and will be unable to run in PRO mode after the evaluation license has expired in less than one day’s time. After expiration, the compiler can be operated in Free mode indefinitely, but will produce a larger output binary.
The compiler is running as a demo and will be unable to run in PRO mode after the evaluation license has expired in the indicated time. After expiration, the compiler can be operated in Free mode indefinitely, but will produce a larger output binary.
The compiler has encountered more than one source file with the same base name. This can only be the case if the files are contained in different directories. As the compiler and IDEs based the names of intermediate files on the base names of source files, and intermediate files are always stored in the same location, this situation is illegal. Ensure the base name of all source files are unique.
Some options are not available when the compiler operates in Free mode.
The options disabled are typically related to how the compiler is executed, e.g.,
--getoption
and --setoption
, and do not
control compiler features related to code generation.
Some assembler directives, e.g., EXITM
, can only be used
inside macro definitions.
A printf placeholder modifier has been used which is non-standard. Use
the indicated modifier instead. For example, the standard hh
modifier should be used in preference to b
to indicate that the
value should be printed as a char
type.
CROMWELL is passed a list of class names on the command line. If the number of class names passed in is too large, not all will be used and there is the possibility that debugging information will be inaccurate.
CROMWELL found an invalid section in an ELF section header. This section will be skipped.
The extension could not be for the target device family.
A symbol location could not be determined from the SDB file.
The location for the indicated symbol in the SDB file was a register, but the register name was not recognized.
The storage class for the indicated symbol in the SDB file was not recognized.
The size of the symbol indicated in the SDB file does not match the size of its type.
The psect representing either the stack or heap could not be made as large as requested and will be truncated to fit the available memory space.
--INTERRUPT
option are missing or
malformed, for example:
--INTERRUPTS=single,multi
Oops, did you mean single-vector or multi-vector interrupts?
--RUNTIME
option is
malformed, for example:
--RUNTIME=default,speed:0y1234
Oops, that should be 0x1234.
--RUNTIME
option is too large for the selected device.
--RUNTIME=default,speed:0xffffffff
Oops, that value is too large.
The configuration settings for the indicated word have not be supplied in the source code and a default value will be used.
The configuration settings and the value specified with the perform
suboption of the --RUNTIME
options conflict and a default frequency
has been selected.
--OUTPUT=intel:8
Oops, the :8 is not required
This is an internal error. Contact Microchip Technical Support with details.
The linker was asked to place a psect within the range of addresses specified by a class, but the class was either never defined, or contains no memory ranges.
An attribute has been encountered that is valid, but which is not implemented by the parser. It will be ignored by the parser and the attribute will have no effect. Contact Microchip Technical Support with details.
An attribute has been encountered that requires an argument, but this is not present. Contact Microchip Technical Support with details.
An argument to an attribute has been encountered, but it is malformed. Contact Microchip Technical Support with details.
This indicated a bad option passed to the parser. Contact Microchip Technical Support with details.
This indicated the same attribute option being passed to the parser more than once. Contact Microchip Technical Support with details.
The attribute option passed to the parser is malformed. Contact Microchip Technical Support with details.
The qualifier specified in an attribute option is not known. Contact Microchip Technical Support with details.
__attribute__
directive was used but did not specify
an attribute type.
int rv (int a) __attribute__(()) /* oops -- what is the attribute? */
Some qualifiers are valid, but cannot be implemented on some compilers or target devices. This warning indicates that the qualifier will be ignored.
Whitespace characters have been found between a backslash and newline characters and will be ignored.
The indicated address is about to be overwritten by additional data. This would indicate more than one section of code contributing to the same address.
See also message (491). The new form of message also indicates the largest free block that the linker could find. Unless there is a single space large enough to accommodate the psect, the linker will issue this message. Often when there is banking or paging involved the largest free space is much smaller than the total amount of space remaining,
See also message (593). The new form of message also indicates the largest free block that the linker could find. Unless there is a single space large enough to accommodate the psect, the linker will issue this message. Often when there is banking or paging involved the largest free space is much smaller than the total amount of space remaining,
enum
tag with the same name has been
defined, The previous definition is indicated in the message.
enum VALS { ONE=1, TWO, THREE };
enum VALS { NINE=9, TEN }; /* oops -- is VALS the right tag name? */
__at(address)
, cannot be assigned an initial value when
it is defined. Place an assignment to the variable at an appropriate location in
your program.
int foobar __at(0x20) = 0x55; /* oops --
you cannot assign a value to an absolute variable */
int * ip;
int fred, buf[20];
ip = &buf[0] - &fred; /* oops --
second operand must be an address of a "buf" element */
movlw 0x321 ; oops -- is this the right value?
__CONFIG(3, 0x1234); /* config word 3 does not exist on an 18C801 */
_delay
has been used, but the
number of instruction cycles requested is too large. Use this routine multiple times
to achieve the desired delay length.
#include <xc.h>
int main(void) {
delay(0x400000); /* oops -- cannot delay by this number of cycles */
}
’Fixup’ is the process conducted by the linker of replacing symbolic references to operands with an absolute value. This takes place after positioning the psects (program sections or blocks) into the available memory. ‘Fixup overflow’ is when a symbol’s value is too large to fit within the assembler instruction. For example, if an assembler instruction has an 8-bit field to hold an address and the linker determines that the symbol used to represent this address has the value 0x110, then clearly this value cannot be encoded into the instruction.
Fixup errors are often caused by hand-written assembly code. Common mistakes that trigger these errors include failing to mask a full, banked data address in file register instructions, or failing to mask the destination address in jump or call instructions. If this error is triggered by assembly code generated from C source, then it is often that constructs like switch() statements have generated a block of assembly too large for jump instructions to span. Adjusting the default linker options can also causes such errors.
To identify these errors, follow these steps.
-D__DEBUG
option).-Wa,-a
option).Consider the following error message.
main.c: 4: (1356)(linker) fixup overflow referencing psect bssBANK1 (0x100) into 1 byte at 0x7FF0/0x1 -> 0x7FF0 (main.obj 23/0x0)
The file being linked was main.obj. This tells you the assembly list file in which you should be looking is main.lst. The location of the instruction at fault is 0x7FF0. (You can also tell from this message that the instruction is expecting a 1 byte quantity—this size is rounded to the nearest byte—but the value was determined to be 0x100.)
In the assembly list file, search for the address specified in the error message.
61 007FF0 6F00 movwf _foobar,b ;#
and to confirm, look for the symbol referenced in the assembler instruction at this address in the symbol table at the bottom of the same file.
Symbol Table Tue Oct 28 11:06:37 2014
_foobar 0100
In this example, the hand-written PIC18 movwf
instruction causing the problem takes an 8-bit offset into a bank of memory, but
clearly the address 0x100 exceeds this size. The instruction should have been
written as:
MOVWF BANKMASK(_foo)
which masks out the top bits of the address containing the bank information.
If the assembler instruction that caused this error was generated by the compiler, in the assembler list file look back up the file from the instruction at fault to determine which C statement has generated this instruction. You will then need to examine the C code for possible errors.
See message (1356).
The code generator was unable to find a space large enough to hold the temporary variables (scratch variables) for this program.
The code generator was unable to find a space large enough to hold the parameter variables for a particular function.
The code generator was unable to find a space large enough to hold the auto variables for a particular function. Some parameters passed in registers can need to be allocated space in this auto area as well.
#pragma config
was malformed.
#pragma config WDT /* oops -- is WDT on or off? */
config
pragma setting have been issued more
than once with different values.
#pragma config WDT=OFF
#pragma config WDT=ON /* oops -- is WDT on or off? */
#pragma config WDR=ON /* oops -- did you mean WDT? */
#pragma config CONFIG1L=0x46 /* oops -- no 1L register on a 18F4520 */
The file containing value configuration settings could not be found.
#pragma varlocate
was malformed.
#pragma varlocate /* oops -- what do you want to locate & where? */
#pragma varlocate
was malformed.
#pragma varlocate fred /* oops -- which bank for fred? */
An end-of-file marker was encountered inside a _asm
_endasm
block.
Displayed is an assembler advisory message produced by the
MESSG
directive contained in the assembler source.
The proc file for the selected device could not be opened.
The peripheral library is not available for the selected device.
Use of the -fshort-double
options has result in the size
of the double
type being smaller than that of the
float
type. This is not permitted by the C Standard. The
double
type size has been increased to be that indicated.
interrupt_level
is too high for the device
selected.
#pragma interrupt_level 4
// oops - there aren't that many interrupts on this device
The feature indicated is no longer supported by the compiler.
interrupt void isr_lo(void) {
// ...
}
interrupt void isr_hi(void) { // oops, cannot define two ISRs
// ...
}
struct {
unsigned flag :1;
unsigned mode :3;
} foobar = { 1, 100 }; // oops, 100 is too large for a 3 bit object
The compiler was unable to determine the switch strategy to use to
encode a C switch
statement based on the code and your selection
using the #pragma switch
directive. You can need to choose a
different strategy.
#pragma addrqual ingore // oops -- did you mean ignore?
The compiler encodes switch()
statements according to
one of a number of strategies. The specific number and values of the case values,
and the switch expression, as well as the switch
pragma determine
the strategy chosen. This error indicates that no strategy was available to encode
the switch()
statement. Contact Microchip support with program
details.
The compiler encodes switch()
statements according to
one of a number of strategies. The specific number and values of the case values,
and the switch expression, as well as the switch
pragma, determine
the strategy chosen. This error indicates that the strategy that was requested
cannot be used to encode the switch()
statement. Contact Microchip
support with program details.
case 0 ... -2: // oops -- do you mean -2 ... 0 ?
char __attribute__((deprecated)) foobar;
foobar = 9; // oops -- this variable is near end-of-life
#pragma config OSC=11
// oops -- there is no direct association for that value on an 18F2520
// either use OSC=3 or OSC=RC
_delay
in-line function can only take a constant
expression as its argument.
int delay_val = 99;
_delay(delay_val); // oops, argument must be a constant expression
#pragma config WDTPS=138 // oops -- do you mean 128?
#pragma config WDT=ON
#pragma config WDT=OFF // oops -- watchdog on or off?
int theValueOfThePortAfterTheModeBitsHaveBeenSet;
// oops, make your symbol shorter or increase the maximum
// identifier length
const int array[200] = { ... }; // oops -- not on a Baseline part!
A function has been called by main-line (non-interrupt) and interrupt code. If this warning is issued, it highlights that such code currently violates a compiler limitation for the selected device.
The compiler has detected that the call graph for a program could be using more stack space that allocated on the target device. If this is the case, the code can fail. The compiler can only make assumption regarding the stack usage, when interrupts are involved and these lead to a worst-case estimate of stack usage. Confirm the function call nesting if this warning is issued.
--ROM=100-1fff
The above might need to be paged. If the page size is 800h, the above could specified as
--ROM=100-7ff,800-fff,1000-17ff,1800-1fff
The compiler has in-built checks that can determine if combinations of internal code templates have been encountered. Where unique combinations are uncovered when compiling code, this message is issued. This message is not an error or warning and its presence does not indicate possible code failure, but if you are willing to participate, the code you are compiling can be sent to Support to assist with the compiler testing process.
char shared __at(0x7); // oops, this memory is required by the compiler
The compiler must encode a C function call without using a call assembly instruction and the hardware stack (i.e., use a lookup table), but is unable to. A call instruction might be required if the function is called indirectly via a pointer, but if the hardware stack is already full, an additional call will cause a stack overflow.
All
variables are accessed via
routines that are not reentrant. Code might fail if an attempt is made to access
eeprom
eeprom
-qualified variables from interrupt and main-line code.
Avoid accessing eeprom
variables in interrupt functions.
A pointer cannot have targets in both the EEPROM space and ordinary data space.
#pragma varlocate "mySection" fred // oops -- not accepted
The unsupported __attribute__
has been used to indicate
that some code feature is not supported.
The message printed will indicate the feature that is not supported and which should be avoided.
int procInput(auto int inValue) // oops -- no need for auto
{ ...
eeprom
cannot be auto. You can
define static
local objects qualified as eeprom
,
if required.
int main(void) {
eeprom int mode; // oops -- make this static or global
eeprom
cannot have type
bit
.
eeprom bit myEEbit; // oops -- you cannot define bits in EEPROM
far
cannot be assigned an
initial value. Assign the value later in the code.
far int chan = 0x1234; // oops -- you cannot assign a value here
warning
pragma is
below zero or larger than the highest message number available.
#pragma warning disable 1316 13350 // oops -- possibly number 1335?
foobar += ((int (*)(int))0x0)(77);
// oops -- you cannot call a function with a NULL pointer
-mrom
option is
outside of the on-chip, or external, memory range supported by this device.
-mrom=default,+2000-2ffff
Oops -- memory too high, should that be 2fff?
#pragma warning
disable should be a
comma-separated list of message numbers to disable.
#pragma warning disable // oops -- what messages are to be disabled?
Try something like the following.
#pragma warning disable 1362
NULL
pointer and code which checks for
NULL
(i.e., checks to see if the address is valid) can fail.
int foobar __at(0x00);
int * ip;
int main(void)
{
ip = &foobar; // oops -- 0 is not a valid address
xc8 --chip=18f452 --cp=24 main.c
Oops -- the --cp
option is no longer required.
PSECT myTxt,class=CODE,merge=true ; oops -- I think you mean merge=1
merge
flag value to that previously seen.
psect mytext,class=CODE,merge=1
; and later
psect mytext,class=CODE,merge=0
; Oops, can mytext be merged or not?
psect mytext,class=CODE,split=5
Oops, the split
flag argument must be 0 or 1.
state = OPTION; // oops -- you cannot read this register
This is the compiler configuration file that is selected during compiler
setup. This can be changed via the XC_XML
environment variable.
This file is used to determine where the compiler has been installed. See message
1205.
--RUNTIME=default,+ramtest
oops -- what is ramtest?
__xdata int coeff[2]; // that has no meaning for this target
__ydata int coeff[2]; // that has no meaning for this target
switch(input) {
case 0 ... 5: // oops -- ranges of values are not supported
low();
short long
type does not conform to the
CCI Standard. Use the corresponding long type instead.
short long typeMod; // oops -- not a valid type for CCI
__pack int c; // oops -- there aren’t inter-member spaces to pack in an int
-fshort-double=24
oops -- you cannot set this double
size
#inlcude <inc\lcd.h> // oops -- do not indicate directories here
Remove the path information and use the -I
option
to indicate this, for example:
#include <lcd.h>
and issue the -Ilcd
option.
xc8-cc -mcpu=18f4520 --html main.c
Oops, --html
is not a valid option.
int x __attribute__ ((deprecate)) = 0;
oops -- did you mean deprecated
?
int __section("foo") __section("bar") myvar; // oops -- which section should it be in?
__section()
specifier.
int main(void) {
int __section("myData") counter; // oops -- you cannot specify a section for autos
__section()
is not a
valid section name. The section name must conform to normal C identifier rules.
int __section("28data") counter; // oops -- name cannot start with digits
int inline getData(int port) // sorry -- no luck inlining this
{ //...
intrinsic
pragma needs a function name. This pragma
is not needed in most situations. If you mean to in-line a function, see the
inline
keyword or pragma.
#pragma intrinsic // oops -- what function is intrinsically called?
int __section("myData") input; // okay
int __section("myData") output; // okay
int __section("myData") lvl = 0x12; // oops -- not with uninitialized
bit __section("myData") mode; // oops again -- no bits with bytes
// each different object to their own new section
__IDLOC()
, the argument must only consist of
hexadecimal digits with no radix specifiers or other characters. Any character which
is not a hexadecimal digit will be programmed as a 0 in the corresponding location.
__IDLOC(0x51); // oops -- you cannot use the 0x radix modifier
The CMF file being read by Cromwell or the linker is invalid. Unless you have modified or manually generated this file, this is an internal error. Contact Microchip Technical Support with details.
#pragma inline=forced // oops -- no options allowed with this pragma
#pragma message "this is a message from your programmer"
__big_endian
IAR extension for a
variable. The big-endian storage format is not supported by this compiler. Remove
the specification and ensure that other code does not rely on this endianism.
__big_endian int volume; // oops -- this won’t be big endian
You have used the @
address specifier when using the IAR
C extensions. Any address specified is unlikely to be correct on a new architecture.
Review the address in conjunction with your device data sheet. To prevent this
warning from appearing again, use the reviewed address with the
__at()
specifier instead.
typedef struct foo foo_t;
foo_t x; // oops -- you cannot use foo_t until it is fully defined
struct foo {
int i;
};
--EXT
option is not valid.
xc8 --chip=18f8585 x.c --ext=arm --ext=cci
Oops -- valid choices are iar
, cci
and xc8
--EXT
option has been used more than once, with
conflicting arguments. The last use of the option will dictate the C extensions
accepted by the compiler.
xc8 --chip=18f8585 x.c --ext=iar --ext=cci
Oops -- which C extension do you mean?
#advisory "please listen to this good advice"
#advisory
messages
(1445).
#info "the following is for your information only"
This error relates to a duplicate -L
option being passed
to the preprocessor. Unless you are explicitly running this application, consider
this an internal error. Contact Microchip Technical Support with details.
This error relates to a malformed -L
option being
passed to the preprocessor. Unless you are explicitly running this application,
consider this an internal error. Contact Microchip Technical Support with
details.
This error relates to a unknown dependency file format being passed to the preprocessor. Unless you are explicitly running this application, consider this an internal error. Contact Microchip Technical Support with details.
--data-spaces=a
Oops — a is not a valid data space number.
Cromwell must be passed information that indicates the type for each
numbered memory space. This is down via the --code-spaces
and
--data-spaces
options. Unless you are explicitly running this
application, consider this an internal error. Contact Microchip Technical Support
with details.
--code-space=1,2 --data-space=1
Oops — is space 1 code or data?
-mstack
option has been used to specify the maximum
sizes for each stack. A size has been used for each interrupt, but the compiler
cannot see the corresponding interrupt function definition, which means the stack
space can never be used. Ensure that you create the interrupt function for each
interrupt the device supports.
-mstack=reentrant:20:20:auto
Oops, you have asked for two interrupt stacks, but the compiler cannot see both interrupt function definitions.
-mstack
option has been used to specify the maximum
sizes for each stack, but the total amount of memory requested exceeds the amount of
memory available.
-mstack=software:1000:1000:20000
Oops, that is too much stack space for a small device.
-mstack
option has been used to specify the maximum
sizes for each stack, but one or more of the sizes are not a valid value. Use only
decimal values in this option, or the token auto, for a default size.
-mstack=software:30:all:default
Oops, only use decimal numbers or auto
.
-mstack
option. The maximum stack sizes are optional. If used,
specify one size for each interrupt and one for main-line code.
-mstack=reentrant:20:20:auto
Oops, too many sizes for a device with only one interrupt.
int pushState(int a) {
int cnt __at(0x100); // oops -- you cannot specify an address ...
This message warns you that not all optimizations are enabled in the Standard operating mode.
The peripheral libraries do not have code present for the device you have selected. Disable the option that links in the peripheral library.
Function profiling is only available for PIC18 or enhanced mid-range devices. If you are not using such a device, do not attempt to use function profiling.
Function profiling requires a level of hardware stack. The entire stack has been used by this program so not all functions can be profiled. The indicated function will not have profiling code embedded into it, and it will not contribute to the profiling information displayed by MPLAB X IDE.
The managed stack option allows conversion of function calls that would exceed the hardware stack depth to calls that will use a lookup table. This option cannot be enabled if the reentrant function model is also enabled. If you attempt to use both the managed stack and reentrant function model options, this message will be generated. Code will be compiled with the stack management option disabled. Either disable the reentrant function model or the managed stack option.
The target device does not support reentrant functions. The program will be compiled so that stack-based data is placed on a compiled stack.
int test(); // oops--this should define the parameters
...
test(12, input);
static
local objects instead of auto objects.
reentrant int addOffset(int offset) {
int report[400]; // oops--this will never fit on the software stack
The compiler has been unable to generate code for this statement. This is essentially a “can’t generate code” error message (message 712), but the reason for this inability to compile relates to there not being enough registers available. See message 712 for suggested workarounds.
const
-qualified type is being used
to write a value, but the compiler knows that this pointer has targets (the first of
which is indicated) that have been qualified const
. This could lead
to code failure or other error messages being generated.
void keepTotal(char * cp) {
*cp += total;
}
char c;
const char name[] = "blender";
keepTotal(&c);
keepTotal(&name[2]); // oops--will write a read-only object
—output=elf:3
Oops, there is no elf
flag of 3.
This elf
suboption and its flags are usually issued
by the MPLAB X IDE plugin. Contact Microchip Technical Support with details of the
compiler and IDE if this error is issued.
reentrant
(or software
) specifier
was used with a function (indicated) that cannot be encoded to use the software
stack. The specifier will be ignored and the function will use the compiled stack.
reentrant int main(void) // oops--main cannot be reentrant
{ ...
char label[] = “What??!”; // you do know that’s a trigraph
// sequence, right?
NULL
. That pointer has been used to call a function. The call
will not be made.
int (*fp)(int, int);
result = fp(8,10); // oops--this pointer has not been initialized
The compiler is ignoring an invocation of the
-mcodeoffset
option. The printed description will indicate
whether the option is being ignored because the compiler has seen this option
previously or the compilation mode does not support its use.
const char c = ‘x’;
char * cp = &c; // will produce warning 359 about address assignment
*cp = 0x44; // oops--you ignored the warning above, now you are
// actually going to write using the pointer?
char myArray[5] = { 0 };
// elsewhere
char myArray[5] = {0,2,4,6,8}; // oops--previously initialized
// with zeros, now with different values
eeprom
qualifier was used but there is no EEPROM on
the target device. Any instances of this qualifier will be ignored.
eeprom int serialNo; // oops--no EEPROM on this device
int xy_map[3][3] = { }; // oops--did you mean to supply values?
(1481) call from non-reentrant function, “*”, to “*” might corrupt parameters (Code Generator)
If several functions can be called indirectly by the same function pointer, they are called ‘buddy’ functions, and the parameters to buddy functions are aligned in memory. This allows the parameters to be loaded without knowing exactly which function was called by the pointer (as is often the case). However, this means that the buddy functions cannot directly or indirectly call each other.
// fpa can call any of these, so they are all buddies
int (*fpa[])(int) = { one, two, three };
int one(int x) {
return three(x+1); // oops--one() cannot call buddy three()
}
unsigned char nfo[6] __at(0x80);
unsigned char nfo2[6] __at(0x7b); //oops--this overlaps nfo
__pack
qualifier has no affect on auto or
static
local structures and has been ignored.
int setInput(void) {
__pack struct { //oops--this will not be packed
unsigned x, y;
} inputData;
...
btfsc status,2
brw next ;oops--this instruction cannot be safely used
call update
This compiler’s license does not allow the requested compiler operating
mode. Since the --nofallback
option is enabled, the compiler has
produced this error and will not fall back to a lower operating mode. If you believe
that you are entitled to use the compiler in the requested mode, this error
indicates that your compiler might not be activated correctly.
sizeof
operator in expressions that need to be evaluated by the
preprocessor.
#if sizeof(int *) == 3 // oops - you can't take the size of a pointer type
#define MAX 40
#endif
This message is emitted in the situation where the indicated function's software-stack data has exceeded the theoretical maximum allowable size. Data outside this stack space will only be accessible by some instructions that could attempt to access it. In some situations the excess data can be retrieved, your code will work as expected, and you can ignore this warning. This is likely if the function calls a reentrant function that returns a large object, like a structure, on the stack. At other times, instructions that are unable to access this data will, in addition to this warning, trigger an error message at the assembly stage of the build process, and you will need to look at reducing the amount of stack data defined by the function.
ENDIF
directive associated with the last
IF
or ELSIF
directive previously encountered.
psect mytext,class=CODE,reloc=2
movlw 20h
IF TEST_ONLY
movlw 00h
movwf _mode,c ; oops--where does the IF end?
psect nexttext,class=CODE,reloc=2
ENDIF
directive that
does not have any corresponding IF
or ELSIF
directive.
psect mytext,class=CODE,reloc=2
movlw 20h
IF TEST_ONLY
movlw 00h
ENDIF
ENDIF ; oops--what does this terminate?
--RUNTIME
option is not
available for the selected device.
xc8 --CHIP=MCP19114 --RUNTIME=+osccal main.c
Oops, the osccal
suboption is not available for
this device.
This advisory message ensures you are aware of the changes in 32-bit floating-point library code operation that might lead to an increase in code size.
This advisory message ensures you are aware of the changes in 32-bit floating-point library code operation which might lead to the Can’t Find Space error message that has been issued.
NORMALIZE32
operator has been used on an operand
that is not a literal constant.
NORMALIZE(_foobar) ; oops--that must be a literal constant operand
addfsr 1, 6 ; oops--the offset must be between 0 to 3
void *
)
pointers.
void * vp;
vp++; // oops—how can this be incremented without knowing what it points to?
void interrupt lo_isr(void) { // oops — was this meant to be a low_priority interrupt?
…
}
void interrupt hi_isr(void) {
…
}
NULL
has been dereferenced.
Assign the pointer a valid address before doing so.
char * cp, c;
c = *cp; // oops —what is cp pointing to?
float myFloat = 100f*3.2; // oops — is ‘100f’ mean to be a hex or floating-point value?