Array Index Types & Warning (752) in XC8 v2.10 C99

Question

First question, so I hope its understandable!

I am initialising a pointer to a compound literal, which is an array of struct pointers. I can then use this pointer as I would normally an array of pointers.

typedef struct
{
    uint32_t test1;
    uint32_t test2;
    uint32_t test3;
    uint32_t test4;
    uint32_t test5;
    uint32_t test6;
    uint32_t test7;
    uint32_t test8;
    uint32_t test9;
    uint32_t test10;
    uint32_t test11;
} TestStruct;

TestStruct* TestStructArray = (TestStruct[])
{
    {
        .test1 = 69,
    },
    {
        .test1 = 69,
    },
    {
        .test1 = 0,
    },
};

When I try to loop through this array later, I use a variable of type size_t for the loop counter, and access the members of the array using the [] array notation.

void main(void)
{
    size_t ArrIdx = 0U;
    while(TestStructArray[ArrIdx].test1 != 0U) \\\\\ <-- warning: (752) conversion to shorter data type
    {
        LocalTestFunction();
        ArrIdx++;
    }
}

When the array size falls below some sort of size threshold, the compiler give the following warning: (752) conversion to shorter data type. Adding more members to the struct, or more members to the array of struct removes the warning. ie.. In this example, initialising another member of the array removes the compiler error.

This warning seems to be pointing to the line where I access the array members with the index of type size_t. It seems that the type used by the compiler for array index's is not constant, and actually depends on the size of the array. This makes it very difficult to prevent truncation or unused memory.

I have compiled this test code in a completely new project and the behaviour remains.

Am I going crazy or have I found some interesting quirk with the optimization?

My build environment is as follows:

MPLAB X v5.35
XC8 v2.10
C99 Standard and Link in C library
Warning Level : -9
Device: PIC18F46K20
Optimisation: Space (PRO)

Example Project

This loop while(TestStructArray[ArrIdx].test1 != 0U) invokes undefined behavior because the compound literal does not have an element with the test1 equal to 0. — Vlad from Moscow, Apr 16 '20 at 22:40
Full warning message is shown: "warning: (752) conversion to shorter data type" I realise the loop will run forever, it is just an example. — jfcroft245, Apr 16 '20 at 22:41
Care to explain that, @VladfromMoscow? It doesn't look like the OP's loop will terminate, but I don't see the UB you see. (Note that `ArrIdx` is not modified in the loop body.) — John Bollinger, Apr 16 '20 at 22:42
And he may have shown less than the full array, too. And whatever he left out of the loop may include all needed protection against overrunning the array. We can only speak with any confidence about what is actually presented in the question. — John Bollinger, Apr 16 '20 at 22:47
Corrected the loop to show realistic code...There was missing code when I stripped it out for the example! — jfcroft245, Apr 16 '20 at 22:47
There are many threads about this warning at microchip.com forums. — Barmar, Apr 16 '20 at 22:48
It seems like a common problem with XC8. I suspect you can ignore it, but I suggest you read through those threads. — Barmar, Apr 16 '20 at 22:49
@Barmar Found a few of them already, but I just want to be certain that this is a compiler error, and no fault of my own. — jfcroft245, Apr 16 '20 at 22:49
@Mike Same problem! I think the error is for the `[ArrIdx]` part of that line — jfcroft245, Apr 17 '20 at 09:12

score 0 · Accepted Answer · answered Apr 16 '20 at 23:06

This warning seems to be pointing to the line where I access the array members with the index of type size_t. It seems that the type used by the compiler for array index's is not constant, and actually depends on the size of the array.

C does not have any sense of an inherent index type of an array. It is allowed to access an array via an index expression of any integer type, and that does not imply any conversion of the index to a particular integer type.

Am I going crazy or have I found some interesting quirk with the optimization?

I think you have discovered a quirk of the compiler, but it's not clear whether that's related to optimization. Nor is it clear whether the warning signals any bona fide risk. From a C language perspective, however, I see nothing wrong with the code fragments you've posted, neither individually nor together, in C99 or later.

Looks like I will have to settle for some dodgy "#pragma warning disable"'s for now! Good to hear that the code seems fine. — jfcroft245, Apr 16 '20 at 23:12
FWIW, I suspect the issue is related to XC8's representation of the `TestStructArray` pointer, and with the pointer addition inherent in the indexing operator. It would make sense that XC is basically leaking implementation details with the warning. My best guess would be that as long as your code has well-defined behavior with respect to C (i.e. as long as you don't overrun the array bounds) then you'll be fine. But I emphasize that that's a ***guess***. — John Bollinger, Apr 16 '20 at 23:19

cup · Answer 2 · 2020-04-18T11:38:14.233

0

If you look at the XC8 user manual (mine is 1.42 on page 149), it says that an int is 16 bits, therefore at a guess, the default int is 16-bits.

Add ULL at the end of the declarations
When comparing against 32 bits, use 0ULL.

edited Apr 18 '20 at 11:38

answered Apr 18 '20 at 11:13

cup

7,589
4
19
42

Array Index Types & Warning (752) in XC8 v2.10 C99

2 Answers2