Question

我想知道为什么我使用的静态分析器工具无法检测到以下简单错误（可能是变量）：

    S08 GPS_Nmea::handler(GPS_INF *pGps, U08 *pRcvd) {
      S08 sErr;
      U08 byte;
      U08 mask = 0;
      U08 stat_mask;

      while (Q08_GetLength(&gps_q)) {
        sErr = Q08_Read(&gps_q, &byte, 1);
        if (sErr != Q_OK)
          continue;
        if ((EPBEXSTN.RS_Settings.D == RS485_NMEA_OUT) ||
            (EPBEXSTN.RS_Settings2.D == RS485_NMEA_OUT) ||
            (EPBEXSTN.RS_Settings3.D == RS485_NMEA_OUT)) {
          if (ts.p_dev != 0)
            ts.p_dev->write(&byte, 1);
        }
        sErr = _gps_fsm(byte);
        if (sErr == TRUE) {
          sErr = _gps_parse(gps_buf, pGps, &stat_mask);
          gps_rx_state = GPS_ST_WAIT;

          if (stat_mask == STR_RMC)
            mask |= STR_RMC;
          if (stat_mask == STR_GGA)
            mask |= STR_GGA;
          mask |= STR_ANY;
        }
      }

      if (pRcvd != NULL)
        *pRcvd = mask;

      return RC_ERR_NONE;
    }

S08 GPS_Nmea::_gps_parse (char* pBuf, GPS_INF* pGps, U08* pRcvd)
{
    S08 sErr;

    if ((memcmp(pBuf, "$GPRMC", 6) == 0) ||
        (memcmp(pBuf, "$GLRMC", 6) == 0) ||
        (memcmp(pBuf, "$GNRMC", 6) == 0))
    {
        APP_PRINTF (GPS_TRACE, ("-I- gps: $xxRMC parse\r\n"));
        //APP_PRINTF (GPS_TRACE, ("-I- gps: string - %s\r\n", gps_buf));

        GpsTmp = *pGps;
        sErr = _gprmc_parse (pBuf, &GpsTmp);
        if (sErr == RC_ERR_NONE)
        {
            *pGps = GpsTmp;
            *pRcvd = STR_RMC;

            if (pGps->valid == FALSE)
                APP_PRINTF (GPS_WARNING, ("-W- gps_lib: gps data isn't valid\r\n"));
        }
        else
        {
            APP_PRINTF (GPS_ERROR, ("-E- gps_lib: _gprmc_parse() error\r\n"));
            clr_struct (pGps);
        }

        return sErr;
    }
    else if ((memcmp(pBuf, "$GPGGA", 6) == 0) ||
             (memcmp(pBuf, "$GLGGA", 6) == 0) ||
             (memcmp(pBuf, "$GNGGA", 6) == 0))
    {
        APP_PRINTF (GPS_TRACE, ("-I- gps: $xxGGA parse\r\n"));
        //APP_PRINTF (GPS_TRACE, ("-I- gps: string - %s\r\n", gps_buf));

        GpsTmp = *pGps;
        sErr = _gpgga_parse (pBuf, &GpsTmp);
        if (sErr == RC_ERR_NONE)
        {
            *pGps = GpsTmp;
            *pRcvd = STR_GGA;
        }
        else
        {
            APP_PRINTF (GPS_ERROR, ("-E- gps_lib: _gpgga_parse() error\r\n"));
            clr_struct (pGps);
        }

        return sErr;
    }
    else if ((memcmp(pBuf, "$GPGSV", 6) == 0) ||
             (memcmp(pBuf, "$GLGSV", 6) == 0) ||
             (memcmp(pBuf, "$GNGSV", 6) == 0) )
  {
    APP_PRINTF (GPS_TRACE, ("-I- gps: $xxGSV parse\r\n"));

        sErr = _gpgsv_parse (pBuf);
        if (sErr == RC_ERR_NONE)
        {
        }
        else
        {
            APP_PRINTF (GPS_ERROR, ("-E- gps_lib: _gpgga_parse() error\r\n"));
        }
        return sErr;
  }
    else if ((memcmp(pBuf, "$GPGSA", 6) == 0) ||
             (memcmp(pBuf, "$GLGSA", 6) == 0) ||
             (memcmp(pBuf, "$GNGSA", 6) == 0) )
  {
    APP_PRINTF (GPS_TRACE, ("-I- gps: $xxGSA parse\r\n"));
        GpsTmp = *pGps;
        sErr = _gpgsa_parse (pBuf, &GpsTmp);
        if (sErr == RC_ERR_NONE)
        {
            *pGps = GpsTmp;
            *pRcvd = STR_GSA;
        }
    else
        {
            APP_PRINTF (GPS_ERROR, ("-E- gps_lib: _gpgga_parse() error\r\n"));
        }
        return sErr;
  }
    else if ((memcmp(pBuf, "$GPZDA", 6) == 0) ||
             (memcmp(pBuf, "$GLZDA", 6) == 0) ||
             (memcmp(pBuf, "$GNZDA", 6) == 0) )
  {
    APP_PRINTF (GPS_TRACE, ("-I- gps: $xxZDA parse\r\n"));
        GpsTmp = *pGps;
        sErr = _gpzda_parse (pBuf);
        if (sErr == RC_ERR_NONE)
        {
            *pGps = GpsTmp;
            *pRcvd = STR_ZDA;
        }
    else
        {
            APP_PRINTF (GPS_ERROR, ("-E- gps_lib: _gpzda_parse() error\r\n"));
        }
        return sErr;
  }
    else if (memcmp(pBuf, "$PMTK705", 8) == 0) 
  {
    APP_PRINTF (GPS_TRACE, ("-I- gps: $PMTK705 parse\r\n"));
    int ver_len = strlen(pBuf+9) - 4;
    if (ver_len > sizeof(tsk_gps.gps_version)-1)
      ver_len = sizeof(tsk_gps.gps_version)-1;
    memcpy(tsk_gps.gps_version,pBuf+9,ver_len);
        return RC_ERR_NONE;
  }
    else if (memcmp(pBuf, "$PMTKSPF", 8) == 0) 
  {
    static U08 jamming_active_cnt = 0;
    static U08 jamming_prev_state = FALSE;
    APP_PRINTF (GPS_TRACE, ("-I- gps: $PMTKSPF parse\r\n"));
    tsk_gps.jamming_pmtk_to = 0;
    if (memcmp(pBuf, "$PMTKSPF,3", 10) == 0)
    { if (jamming_active_cnt < 60) jamming_active_cnt ++; }
    else
    { if (jamming_active_cnt != 0) jamming_active_cnt --; }
    if (jamming_active_cnt > 30)
    {
      if (bsp.m_DevInfo.jamming_gps)
      {
        tsk_gps.jamming_data = TRUE;
        if (jamming_prev_state == FALSE)
        {
          ev_bus.add(GLOB_EV_JAMMING_GPS);
        }
      }
      jamming_prev_state = TRUE;
    }
    else
      jamming_prev_state = FALSE;
        return RC_ERR_NONE;
  }
#if defined (MAKE_ERA)
    else if (memcmp(pBuf, "$PSTMGETALGOOK", 14) == 0)
  {
        if (memcmp(pBuf+15, "1,1", 3) == 0)
    {
            pGps->fde_status = 1;
        }
    else
        {
            pGps->fde_status = 0;
        }
        return sErr;
  }
#endif
    else
    {
        gps_buf[6] = 0;
        //APP_PRINTF (GPS_WARNING, ("-W- gps: undef string - %s\r\n", gps_buf));
    }

    return RC_ERR_DATA;
}

错误说明：在stat_mask函数（第44行）中统一的变量handler()在被调用的_gps_parse()函数（第59行）中也可以保持不变。（对于静态分析工具来说，这似乎是一个明显的错误，但是我使用的所有工具都没有指出我这一点。

编辑1。完整的源代码已添加： gpc_nmea.cpp 在这里您可以看到功能

使用的分析器工具为PVS Studio

编辑2。 这是包含该错误的简化代码：

include <stdio.h>

void func(int a, int *px) {
    if (a == 1) 
    {
        *px = 1;
    }
}

int main (void)
{    
    int x;
    func(2, &x);
    printf(x);
}

有人可以建议我使用任何能够指出变量x可能未初始化的分析工具吗？不能相信人类仍然没有这样的解决方案。

Answer 1

是的，目前PVS-Studio分析仪无法检测到此错误。情况似乎很简单，但实际上这种分析非常复杂。我们正在不断改进过程间分析和数据流分析。我们希望能及时发现此类错误。

P.S。在这种情况下，静态分析器通常会屈服，因为它们无法考虑所有互连并跟踪变量的变化。动态代码分析器很好地执行了未初始化变量的搜索。尝试其中一种动态分析仪。

P.P.S。，但不要尝试选择使用什么：静态或动态分析。静态分析器可以发现一些错误，动态分析器可以发现其他错误。这些方法完美地互补。更多详细信息：Static and Dynamic Code Analysis。

Answer 2

由于您实际上是在条件中写入*pRcvd，因此静态分析器可能无法轻松确定此条件是否会评估为false。特别是如果条件中的值来自链接库。

我可以想象，如果不确定，静态分析器可能决定根本不发出警告。由于错误肯定警告很烦人，如果警告过多，人们往往会忽略警告。

尽管从理论上讲可能会捕获到这样的错误，但假设可以在编译时确定，但这样做可能非常困难，因此可能无法在静态分析器中实现。

为什么我的静态分析仪找不到潜在的未初始化读取？

2 个答案: