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

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;
}

错误解释：在 handler() 函数（第 44 行）中初始化的变量 stat_mask 也可以在被调用的 _gps_parse() 函数中保持不变（第 59 行）。似乎是一个明显的错误（对于静态分析工具），但 none 我使用的工具指出了这一点。

编辑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

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

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

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

Answer 2

是的，目前 PVS-Studio 分析器无法检测到此错误。案例看似很简单，其实这样的分析却相当复杂。我们正在不断改进过程间分析和数据流分析。我们希望及时也能检测到此类错误。

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

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

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

Why did my static analyzer fail to find potential uninitialized read?

c++

static-analysis