MISRA C2012:10.8 violation in the sample code

Question

typedef struct{
    sint16 temperature;
    uint32 Setdata;
} VariableA;

VariableA TableData[N];

static uint16 linearinterpolation(const currentdata *pcurData,const VariableA* pTableData)
{   /* Declare local variables */
    sint32 deltaOut;
    sint32 deltaIn;
    uint16 output;
    uint16 idx;
    /* DeltaIn of  temperatures. */
    deltaIn = (sint32)(pTableData[idx].temperature) - (sint32)(pTableData[idx-1].temperature);
    /* DeltaOut of  Setdata */
    deltaOut = (sint32)pTableData[idx].Setdata - (sint32)pTableData[idx-1].Setdata;
    /* Division by 0 protection. */
    if (deltaOut == 0)
    {   /* if the division == 0 */
            output = pTableData[idx-1].Setdata;
    }
    else
    {   /*MISRA C:2012 Rule 10.8 */ 
        output =(uint16)((( deltaOut / deltaIn) *((sint32)(pcurData->temperature) - (sint32)(pTableData[idx-1].temperature))) + (sint32)pTableData[idx-1].Setdata );
    }
    return output; 
}

I have no idea to solve 10.8, does someone can explain and fix it, thank you very much.

MISRA C:2012 Rule 10.8 The value of a composite expression shall not be cast to a different essential type category or a wider essential type
Description
Rule Definition
The value of a composite expression shall not be cast to a different essential type category or a wider essential type.

What are the errors for those of use that don't happen to have misra memorized? — Retired Ninja, Mar 04 '22 at 22:29
Seems to me these might just go away if you make `output` a `uint16` to match the function return type. — Retired Ninja, Mar 04 '22 at 22:54
I am guessing that the clue is in the words "composite expression". Try assigning the result of that expression to a variable of type sint32, (`your_sint32_variable`) and then in a separate statement assign `output = (uint16)your_sint32_variable;` — DavidHoadley, Mar 05 '22 at 10:04
Split very long expressions into several and use temporary variables. Also drop home-made integer types and always use `stdint.h`. — Lundin, Mar 07 '22 at 07:24

Andrew · Answer 1 · 2022-03-05T10:08:41.780

MISRA C:2012 Rule 10.8 states:

The value of a composite expression shall not be cast to a different essential type category or a wider essential type

Looking at your code:

output = (uint16)( ( ( deltaOut / deltaIn )
                   * ( (sint32)( pcurData->temperature) - (sint32)(pTableData[idx-1].temperature) ) )
                 + (sint32)pTableData[idx-1].Setdata );

Lets see...

output is a uint16
The right hand side is cast to uint16
The right hand side is a composite expression in sint32

So:

output = (uint16)( composite expression in sint32 )

Yes, you are NOT violating the guideline R.10.8 because of width - you are casting to a narrower type; however you are violating by casting signed to unsigned within the composite expression.

You have three choices...

Deviate the rule
Modify so that output is sint32 and do all calcs in signed
Are the X and M values all unsigned? Could the calculation be performed in uint32 or uint16?

See profile

score 1 · Accepted Answer · answered Mar 05 '22 at 10:55

There are multiple problems in this line of code:

output = (uint16)(((deltaOut / deltaIn) * ((sint32)(pcurData->temperature) - (sint32)(pTableData[idx-1].temperature))) + (sint32)pTableData[idx-1].Setdata);

MISRA C:2012 Rule 10.8 states that you should not cast the value of a composite expression to a different essential type category or a wider essential type: the composite expression is the whole interpolation expression and the different essential type is uint16, which is probably a typedef on unsigned short. You could use an intermediary variable output32 to store the sint32 result and cast that as output = (uint16)output32;.
Yet this MISRA warning is hiding a much more important problem: the scale operation should be computed as A * B / C with a type large enough to handle A * B, not (A / C) * B using integer arithmetics where rouding will reduce the precision.

If deltaOutis known to be in the range of sint16, you could write:

sint32 deltaTemp = (sint32)pcurData->temperature - (sint32)pTableData[idx-1].temperature;
sint32 adjust32 = deltaOut * deltaTemp / deltaIn;
sint32 output32 = pTableData[idx-1].Setdata + adjust32;
output = (uint16)output32;

Otherwise, you might need 64-bit arithmetics:

sint32 deltaTemp = (sint32)pcurData->temperature - (sint32)pTableData[idx-1].temperature;
sint64 adjust64 = (sint64)deltaOut * (sint64)deltaTemp / (sint64)deltaIn;
sint32 output32 = pTableData[idx-1].Setdata + (sint32)adjust64;
output = (uint16)output32;

If the target has fast floating point hardware, you could compute the interpolation in floating point with float or double arithmetics:

sint32 deltaTemp = (sint32)pcurData->temperature - (sint32)pTableData[idx-1].temperature;
double adjust64 = (double)deltaOut * (double)deltaTemp / (double)deltaIn;
sint32 output32 = pTableData[idx-1].Setdata + (sint32)adjust64;
output = (uint16)output64;

As a rule of thumb, avoid long expressions, define variables for intermediary results and choose their type carefully to avoid overflow or precision loss.

Another remark: what is idx in your function? It seems to be a global variable. You should avoid global variables, especially with such a bland short name.

@Rickykidd: `idx` is not defined inside the function as posted in the question. — chqrlie, Mar 05 '22 at 14:27

MISRA C2012:10.8 violation in the sample code

2 Answers2