new smatch

          --- old/usr/src/tools/smatch/src/ident-list.h
          +++ new/usr/src/tools/smatch/src/ident-list.h

   1    1  
   2    2  #define IDENT(n) __IDENT(n## _ident, #n, 0)
   3    3  #define IDENT_RESERVED(n) __IDENT(n## _ident, #n, 1)
   4    4  
   5    5  /* Basic C reserved words.. */
   6    6  IDENT_RESERVED(sizeof);
   7    7  IDENT_RESERVED(if);
   8    8  IDENT_RESERVED(else);
   9    9  IDENT_RESERVED(return);
  10   10  IDENT_RESERVED(switch);
  11   11  IDENT_RESERVED(case);
  12   12  IDENT_RESERVED(default);
  13   13  IDENT_RESERVED(break);
  14   14  IDENT_RESERVED(continue);
  15   15  IDENT_RESERVED(for);
  16   16  IDENT_RESERVED(while);
  17   17  IDENT_RESERVED(do);
  18   18  IDENT_RESERVED(goto);
  19   19  
  20   20  /* C typenames. They get marked as reserved when initialized */
  21   21  IDENT(struct);
  22   22  IDENT(union);
  23   23  IDENT(enum);
  24   24  IDENT(__attribute); IDENT(__attribute__);
  25   25  IDENT(volatile); IDENT(__volatile); IDENT(__volatile__);
  26   26  IDENT(double);
  27   27  
  28   28  /* C storage classes. They get marked as reserved when initialized */
  29   29  IDENT(static);

  30   30  
  31   31  /* C99 keywords */
  32   32  IDENT(restrict); IDENT(__restrict); IDENT(__restrict__);
  33   33  IDENT(_Bool);
  34   34  IDENT(_Complex);
  35   35  IDENT_RESERVED(_Imaginary);
  36   36  
  37   37  /* C11 keywords */
  38   38  IDENT(_Alignas);
  39   39  IDENT_RESERVED(_Alignof);
  40      -IDENT_RESERVED(_Atomic);
       40 +IDENT(_Atomic);
  41   41  IDENT_RESERVED(_Generic);
  42   42  IDENT(_Noreturn);
  43   43  IDENT_RESERVED(_Static_assert);
  44   44  IDENT(_Thread_local);
  45   45  
  46   46  /* Special case for L'\t' */
  47   47  IDENT(L);
  48   48  
  49   49  /* Extended gcc identifiers */
  50   50  IDENT(asm); IDENT_RESERVED(__asm); IDENT_RESERVED(__asm__);

  51   51  IDENT(alignof); IDENT_RESERVED(__alignof); IDENT_RESERVED(__alignof__); 

  52   52  IDENT_RESERVED(__sizeof_ptr__);
  53   53  IDENT_RESERVED(__builtin_types_compatible_p);
  54   54  IDENT_RESERVED(__builtin_offsetof);
  55   55  IDENT_RESERVED(__label__);
  56   56  
  57   57  /* Preprocessor idents.  Direct use of __IDENT avoids mentioning the keyword
  58   58   * itself by name, preventing these tokens from expanding when compiling
  59   59   * sparse. */
  60   60  IDENT(defined);
  61   61  IDENT(once);
       62 +IDENT(__has_attribute);
       63 +IDENT(__has_builtin);
  62   64  __IDENT(pragma_ident, "__pragma__", 0);
  63   65  __IDENT(_Pragma_ident, "_Pragma", 0);
  64   66  __IDENT(__VA_ARGS___ident, "__VA_ARGS__", 0);
  65      -__IDENT(__LINE___ident, "__LINE__", 0);
  66      -__IDENT(__FILE___ident, "__FILE__", 0);
  67      -__IDENT(__DATE___ident, "__DATE__", 0);
  68      -__IDENT(__TIME___ident, "__TIME__", 0);
  69   67  __IDENT(__func___ident, "__func__", 0);
  70   68  __IDENT(__FUNCTION___ident, "__FUNCTION__", 0);
  71   69  __IDENT(__PRETTY_FUNCTION___ident, "__PRETTY_FUNCTION__", 0);
  72      -__IDENT(__COUNTER___ident, "__COUNTER__", 0);
  73   70  
  74   71  /* Sparse commands */
  75   72  IDENT_RESERVED(__context__);
  76   73  IDENT_RESERVED(__range__);
  77   74  
  78   75  /* Magic function names we recognize */
  79   76  IDENT(memset); IDENT(memcpy);
  80   77  IDENT(copy_to_user); IDENT(copy_from_user);
  81   78  IDENT(main);
  82   79  
  83   80  #undef __IDENT
  84   81  #undef IDENT
  85   82  #undef IDENT_RESERVED
    

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX