LCOV - code coverage report
Current view: top level - build-llvm/tools/clang/include/clang/Sema - AttrParsedAttrKinds.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 1049 1224 85.7 %
Date: 2017-09-14 15:23:50 Functions: 1 1 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
       2             : |*                                                                            *|
       3             : |* Attribute name matcher                                                     *|
       4             : |*                                                                            *|
       5             : |* Automatically generated file, do not edit!                                 *|
       6             : |*                                                                            *|
       7             : \*===----------------------------------------------------------------------===*/
       8             : 
       9     2546263 : static AttributeList::Kind getAttrKind(StringRef Name, AttributeList::Syntax Syntax) {
      10     2546263 :   if (AttributeList::AS_GNU == Syntax) {
      11     2504894 :   switch (Name.size()) {
      12             :   default: break;
      13          87 :   case 3:        // 3 strings to match.
      14         174 :     switch (Name[0]) {
      15             :     default: break;
      16          14 :     case 'f':    // 1 string to match.
      17          14 :       if (memcmp(Name.data()+1, "ar", 2) != 0)
      18             :         break;
      19             :       return AttributeList::AT_MipsLongCall;     // "far"
      20           4 :     case 'h':    // 1 string to match.
      21           4 :       if (memcmp(Name.data()+1, "ot", 2) != 0)
      22             :         break;
      23             :       return AttributeList::AT_Hot;      // "hot"
      24          69 :     case 'p':    // 1 string to match.
      25          69 :       if (memcmp(Name.data()+1, "cs", 2) != 0)
      26             :         break;
      27             :       return AttributeList::AT_Pcs;      // "pcs"
      28             :     }
      29             :     break;
      30       10686 :   case 4:        // 7 strings to match.
      31       21372 :     switch (Name[0]) {
      32             :     default: break;
      33          19 :     case 'c':    // 1 string to match.
      34          19 :       if (memcmp(Name.data()+1, "old", 3) != 0)
      35             :         break;
      36             :       return AttributeList::AT_Cold;     // "cold"
      37         441 :     case 'h':    // 1 string to match.
      38         441 :       if (memcmp(Name.data()+1, "ost", 3) != 0)
      39             :         break;
      40             :       return AttributeList::AT_CUDAHost;         // "host"
      41        2007 :     case 'm':    // 1 string to match.
      42        2007 :       if (memcmp(Name.data()+1, "ode", 3) != 0)
      43             :         break;
      44             :       return AttributeList::AT_Mode;     // "mode"
      45          14 :     case 'n':    // 1 string to match.
      46          14 :       if (memcmp(Name.data()+1, "ear", 3) != 0)
      47             :         break;
      48             :       return AttributeList::AT_MipsShortCall;    // "near"
      49        7145 :     case 'p':    // 1 string to match.
      50        7145 :       if (memcmp(Name.data()+1, "ure", 3) != 0)
      51             :         break;
      52             :       return AttributeList::AT_Pure;     // "pure"
      53          93 :     case 'u':    // 1 string to match.
      54          93 :       if (memcmp(Name.data()+1, "sed", 3) != 0)
      55             :         break;
      56             :       return AttributeList::AT_Used;     // "used"
      57         966 :     case 'w':    // 1 string to match.
      58         966 :       if (memcmp(Name.data()+1, "eak", 3) != 0)
      59             :         break;
      60             :       return AttributeList::AT_Weak;     // "weak"
      61             :     }
      62             :     break;
      63      170137 :   case 5:        // 6 strings to match.
      64      340274 :     switch (Name[0]) {
      65             :     default: break;
      66         188 :     case 'a':    // 1 string to match.
      67         188 :       if (memcmp(Name.data()+1, "lias", 4) != 0)
      68             :         break;
      69             :       return AttributeList::AT_Alias;    // "alias"
      70      169893 :     case 'c':    // 2 strings to match.
      71      339786 :       switch (Name[1]) {
      72             :       default: break;
      73          90 :       case 'd':  // 1 string to match.
      74          90 :         if (memcmp(Name.data()+2, "ecl", 3) != 0)
      75             :           break;
      76             :         return AttributeList::AT_CDecl;  // "cdecl"
      77      169803 :       case 'o':  // 1 string to match.
      78      169803 :         if (memcmp(Name.data()+2, "nst", 3) != 0)
      79             :           break;
      80             :         return AttributeList::AT_Const;  // "const"
      81             :       }
      82             :       break;
      83          26 :     case 'i':    // 1 string to match.
      84          26 :       if (memcmp(Name.data()+1, "func", 4) != 0)
      85             :         break;
      86             :       return AttributeList::AT_IFunc;    // "ifunc"
      87          30 :     case 'n':    // 2 strings to match.
      88          60 :       switch (Name[1]) {
      89             :       default: break;
      90          25 :       case 'a':  // 1 string to match.
      91          25 :         if (memcmp(Name.data()+2, "ked", 3) != 0)
      92             :           break;
      93             :         return AttributeList::AT_Naked;  // "naked"
      94           5 :       case 'o':  // 1 string to match.
      95           5 :         if (memcmp(Name.data()+2, "svm", 3) != 0)
      96             :           break;
      97             :         return AttributeList::AT_OpenCLNoSVM;    // "nosvm"
      98             :       }
      99             :       break;
     100             :     }
     101             :     break;
     102      770942 :   case 6:        // 15 strings to match.
     103     1541884 :     switch (Name[0]) {
     104             :     default: break;
     105        1014 :     case 'b':    // 1 string to match.
     106        1014 :       if (memcmp(Name.data()+1, "locks", 5) != 0)
     107             :         break;
     108             :       return AttributeList::AT_Blocks;   // "blocks"
     109           7 :     case 'c':    // 1 string to match.
     110           7 :       if (memcmp(Name.data()+1, "ommon", 5) != 0)
     111             :         break;
     112             :       return AttributeList::AT_Common;   // "common"
     113        1018 :     case 'd':    // 1 string to match.
     114        1018 :       if (memcmp(Name.data()+1, "evice", 5) != 0)
     115             :         break;
     116             :       return AttributeList::AT_CUDADevice;       // "device"
     117        4122 :     case 'f':    // 1 string to match.
     118        4122 :       if (memcmp(Name.data()+1, "ormat", 5) != 0)
     119             :         break;
     120             :       return AttributeList::AT_Format;   // "format"
     121         114 :     case 'g':    // 1 string to match.
     122         114 :       if (memcmp(Name.data()+1, "lobal", 5) != 0)
     123             :         break;
     124             :       return AttributeList::AT_CUDAGlobal;       // "global"
     125           4 :     case 'k':    // 1 string to match.
     126           4 :       if (memcmp(Name.data()+1, "ernel", 5) != 0)
     127             :         break;
     128             :       return AttributeList::AT_RenderScriptKernel;       // "kernel"
     129         704 :     case 'm':    // 3 strings to match.
     130        1408 :       switch (Name[1]) {
     131             :       default: break;
     132         654 :       case 'a':  // 1 string to match.
     133         654 :         if (memcmp(Name.data()+2, "lloc", 4) != 0)
     134             :           break;
     135             :         return AttributeList::AT_Restrict;       // "malloc"
     136          17 :       case 'i':  // 1 string to match.
     137          17 :         if (memcmp(Name.data()+2, "ps16", 4) != 0)
     138             :           break;
     139             :         return AttributeList::AT_Mips16;         // "mips16"
     140          33 :       case 's':  // 1 string to match.
     141          33 :         if (memcmp(Name.data()+2, "_abi", 4) != 0)
     142             :           break;
     143             :         return AttributeList::AT_MSABI;  // "ms_abi"
     144             :       }
     145             :       break;
     146        3630 :     case 'p':    // 2 strings to match.
     147        7260 :       if (Name[1] != 'a')
     148             :         break;
     149        7260 :       switch (Name[2]) {
     150             :       default: break;
     151        3630 :       case 'c':  // 1 string to match.
     152        3630 :         if (memcmp(Name.data()+3, "ked", 3) != 0)
     153             :           break;
     154             :         return AttributeList::AT_Packed;         // "packed"
     155           0 :       case 's':  // 1 string to match.
     156           0 :         if (memcmp(Name.data()+3, "cal", 3) != 0)
     157             :           break;
     158             :         return AttributeList::AT_Pascal;         // "pascal"
     159             :       }
     160             :       break;
     161         151 :     case 's':    // 2 strings to match.
     162         302 :       switch (Name[1]) {
     163             :       default: break;
     164         145 :       case 'h':  // 1 string to match.
     165         145 :         if (memcmp(Name.data()+2, "ared", 4) != 0)
     166             :           break;
     167             :         return AttributeList::AT_CUDAShared;     // "shared"
     168           5 :       case 'i':  // 1 string to match.
     169           5 :         if (memcmp(Name.data()+2, "gnal", 4) != 0)
     170             :           break;
     171             :         return AttributeList::AT_AVRSignal;      // "signal"
     172             :       }
     173             :       break;
     174      759240 :     case 't':    // 1 string to match.
     175      759240 :       if (memcmp(Name.data()+1, "arget", 5) != 0)
     176             :         break;
     177             :       return AttributeList::AT_Target;   // "target"
     178         932 :     case 'u':    // 1 string to match.
     179         932 :       if (memcmp(Name.data()+1, "nused", 5) != 0)
     180             :         break;
     181             :       return AttributeList::AT_Unused;   // "unused"
     182             :     }
     183             :     break;
     184      589926 :   case 7:        // 18 strings to match.
     185     1179852 :     switch (Name[0]) {
     186             :     default: break;
     187           5 :     case '_':    // 1 string to match.
     188           5 :       if (memcmp(Name.data()+1, "_const", 6) != 0)
     189             :         break;
     190             :       return AttributeList::AT_Const;    // "__const"
     191        7631 :     case 'a':    // 2 strings to match.
     192       15262 :       switch (Name[1]) {
     193             :       default: break;
     194        2778 :       case 'b':  // 1 string to match.
     195        2778 :         if (memcmp(Name.data()+2, "i_tag", 5) != 0)
     196             :           break;
     197             :         return AttributeList::AT_AbiTag;         // "abi_tag"
     198        4853 :       case 'l':  // 1 string to match.
     199        4853 :         if (memcmp(Name.data()+2, "igned", 5) != 0)
     200             :           break;
     201             :         return AttributeList::AT_Aligned;        // "aligned"
     202             :       }
     203             :       break;
     204          12 :     case 'b':    // 1 string to match.
     205          12 :       if (memcmp(Name.data()+1, "ounded", 6) != 0)
     206             :         break;
     207             :       return AttributeList::IgnoredAttribute;    // "bounded"
     208         111 :     case 'c':    // 1 string to match.
     209         111 :       if (memcmp(Name.data()+1, "leanup", 6) != 0)
     210             :         break;
     211             :       return AttributeList::AT_Cleanup;  // "cleanup"
     212          10 :     case 'f':    // 1 string to match.
     213          10 :       if (memcmp(Name.data()+1, "latten", 6) != 0)
     214             :         break;
     215             :       return AttributeList::AT_Flatten;  // "flatten"
     216          25 :     case 'm':    // 1 string to match.
     217          25 :       if (memcmp(Name.data()+1, "insize", 6) != 0)
     218             :         break;
     219             :       return AttributeList::AT_MinSize;  // "minsize"
     220      576751 :     case 'n':    // 4 strings to match.
     221     1153502 :       switch (Name[1]) {
     222             :       default: break;
     223      576745 :       case 'o':  // 3 strings to match.
     224     1153490 :         switch (Name[2]) {
     225             :         default: break;
     226      529718 :         case 'd':        // 1 string to match.
     227      529718 :           if (memcmp(Name.data()+3, "ebug", 4) != 0)
     228             :             break;
     229             :           return AttributeList::AT_NoDebug;      // "nodebug"
     230       47004 :         case 'n':        // 1 string to match.
     231       47004 :           if (memcmp(Name.data()+3, "null", 4) != 0)
     232             :             break;
     233             :           return AttributeList::AT_NonNull;      // "nonnull"
     234          23 :         case 't':        // 1 string to match.
     235          23 :           if (memcmp(Name.data()+3, "hrow", 4) != 0)
     236             :             break;
     237             :           return AttributeList::AT_NoThrow;      // "nothrow"
     238             :         }
     239             :         break;
     240           6 :       case 'v':  // 1 string to match.
     241           6 :         if (memcmp(Name.data()+2, "_weak", 5) != 0)
     242             :           break;
     243             :         return AttributeList::IgnoredAttribute;  // "nv_weak"
     244             :       }
     245             :       break;
     246         669 :     case 'o':    // 2 strings to match.
     247        1338 :       switch (Name[1]) {
     248             :       default: break;
     249         607 :       case 'b':  // 1 string to match.
     250         607 :         if (memcmp(Name.data()+2, "jc_gc", 5) != 0)
     251             :           break;
     252             :         return AttributeList::AT_ObjCGC;         // "objc_gc"
     253          62 :       case 'p':  // 1 string to match.
     254          62 :         if (memcmp(Name.data()+2, "tnone", 5) != 0)
     255             :           break;
     256             :         return AttributeList::AT_OptimizeNone;   // "optnone"
     257             :       }
     258             :       break;
     259         146 :     case 'r':    // 2 strings to match.
     260         146 :       if (memcmp(Name.data()+1, "eg", 2) != 0)
     261             :         break;
     262         292 :       switch (Name[3]) {
     263             :       default: break;
     264           4 :       case 'c':  // 1 string to match.
     265           4 :         if (memcmp(Name.data()+4, "all", 3) != 0)
     266             :           break;
     267             :         return AttributeList::AT_RegCall;        // "regcall"
     268         142 :       case 'p':  // 1 string to match.
     269         142 :         if (memcmp(Name.data()+4, "arm", 3) != 0)
     270             :           break;
     271             :         return AttributeList::AT_Regparm;        // "regparm"
     272             :       }
     273             :       break;
     274         193 :     case 's':    // 2 strings to match.
     275         386 :       switch (Name[1]) {
     276             :       default: break;
     277          88 :       case 'e':  // 1 string to match.
     278          88 :         if (memcmp(Name.data()+2, "ction", 5) != 0)
     279             :           break;
     280             :         return AttributeList::AT_Section;        // "section"
     281         105 :       case 't':  // 1 string to match.
     282         105 :         if (memcmp(Name.data()+2, "dcall", 5) != 0)
     283             :           break;
     284             :         return AttributeList::AT_StdCall;        // "stdcall"
     285             :       }
     286             :       break;
     287        4373 :     case 'w':    // 1 string to match.
     288        4373 :       if (memcmp(Name.data()+1, "eakref", 6) != 0)
     289             :         break;
     290             :       return AttributeList::AT_WeakRef;  // "weakref"
     291             :     }
     292             :     break;
     293        4912 :   case 8:        // 14 strings to match.
     294        9824 :     switch (Name[0]) {
     295             :     default: break;
     296          17 :     case 'N':    // 1 string to match.
     297          17 :       if (memcmp(Name.data()+1, "SObject", 7) != 0)
     298             :         break;
     299             :       return AttributeList::AT_ObjCNSObject;     // "NSObject"
     300         482 :     case 'a':    // 1 string to match.
     301         482 :       if (memcmp(Name.data()+1, "nnotate", 7) != 0)
     302             :         break;
     303             :       return AttributeList::AT_Annotate;         // "annotate"
     304          97 :     case 'c':    // 1 string to match.
     305          97 :       if (memcmp(Name.data()+1, "onstant", 7) != 0)
     306             :         break;
     307             :       return AttributeList::AT_CUDAConstant;     // "constant"
     308          91 :     case 'f':    // 1 string to match.
     309          91 :       if (memcmp(Name.data()+1, "astcall", 7) != 0)
     310             :         break;
     311             :       return AttributeList::AT_FastCall;         // "fastcall"
     312         102 :     case 'i':    // 2 strings to match.
     313         204 :       if (Name[1] != 'b')
     314             :         break;
     315         204 :       switch (Name[2]) {
     316             :       default: break;
     317          57 :       case 'a':  // 1 string to match.
     318          57 :         if (memcmp(Name.data()+3, "ction", 5) != 0)
     319             :           break;
     320             :         return AttributeList::AT_IBAction;       // "ibaction"
     321          45 :       case 'o':  // 1 string to match.
     322          45 :         if (memcmp(Name.data()+3, "utlet", 5) != 0)
     323             :           break;
     324             :         return AttributeList::AT_IBOutlet;       // "iboutlet"
     325             :       }
     326             :       break;
     327          63 :     case 'l':    // 1 string to match.
     328          63 :       if (memcmp(Name.data()+1, "ockable", 7) != 0)
     329             :         break;
     330             :       return AttributeList::AT_Lockable;         // "lockable"
     331        3614 :     case 'n':    // 4 strings to match.
     332        7228 :       if (Name[1] != 'o')
     333             :         break;
     334        7228 :       switch (Name[2]) {
     335             :       default: break;
     336           2 :       case 'c':  // 1 string to match.
     337           2 :         if (memcmp(Name.data()+3, "ommon", 5) != 0)
     338             :           break;
     339             :         return AttributeList::AT_NoCommon;       // "nocommon"
     340         316 :       case 'i':  // 1 string to match.
     341         316 :         if (memcmp(Name.data()+3, "nline", 5) != 0)
     342             :           break;
     343             :         return AttributeList::AT_NoInline;       // "noinline"
     344          10 :       case 'm':  // 1 string to match.
     345          10 :         if (memcmp(Name.data()+3, "ips16", 5) != 0)
     346             :           break;
     347             :         return AttributeList::AT_NoMips16;       // "nomips16"
     348        3286 :       case 'r':  // 1 string to match.
     349        3286 :         if (memcmp(Name.data()+3, "eturn", 5) != 0)
     350             :           break;
     351             :         return AttributeList::AT_NoReturn;       // "noreturn"
     352             :       }
     353             :       break;
     354         427 :     case 's':    // 2 strings to match.
     355         854 :       switch (Name[1]) {
     356             :       default: break;
     357         415 :       case 'e':  // 1 string to match.
     358         415 :         if (memcmp(Name.data()+2, "ntinel", 6) != 0)
     359             :           break;
     360             :         return AttributeList::AT_Sentinel;       // "sentinel"
     361          12 :       case 'y':  // 1 string to match.
     362          12 :         if (memcmp(Name.data()+2, "sv_abi", 6) != 0)
     363             :           break;
     364             :         return AttributeList::AT_SysVABI;        // "sysv_abi"
     365             :       }
     366             :       break;
     367          19 :     case 't':    // 1 string to match.
     368          19 :       if (memcmp(Name.data()+1, "hiscall", 7) != 0)
     369             :         break;
     370             :       return AttributeList::AT_ThisCall;         // "thiscall"
     371             :     }
     372             :     break;
     373        7086 :   case 9:        // 13 strings to match.
     374       14172 :     switch (Name[0]) {
     375             :     default: break;
     376         896 :     case 'd':    // 2 strings to match.
     377         896 :       if (memcmp(Name.data()+1, "ll", 2) != 0)
     378             :         break;
     379        1792 :       switch (Name[3]) {
     380             :       default: break;
     381         335 :       case 'e':  // 1 string to match.
     382         335 :         if (memcmp(Name.data()+4, "xport", 5) != 0)
     383             :           break;
     384             :         return AttributeList::AT_DLLExport;      // "dllexport"
     385         561 :       case 'i':  // 1 string to match.
     386         561 :         if (memcmp(Name.data()+4, "mport", 5) != 0)
     387             :           break;
     388             :         return AttributeList::AT_DLLImport;      // "dllimport"
     389             :       }
     390             :       break;
     391        1229 :     case 'e':    // 1 string to match.
     392        1229 :       if (memcmp(Name.data()+1, "nable_if", 8) != 0)
     393             :         break;
     394             :       return AttributeList::AT_EnableIf;         // "enable_if"
     395          10 :     case 'f':    // 1 string to match.
     396          10 :       if (memcmp(Name.data()+1, "lag_enum", 8) != 0)
     397             :         break;
     398             :       return AttributeList::AT_FlagEnum;         // "flag_enum"
     399         357 :     case 'i':    // 1 string to match.
     400         357 :       if (memcmp(Name.data()+1, "nterrupt", 8) != 0)
     401             :         break;
     402             :       return AttributeList::AT_Interrupt;        // "interrupt"
     403          14 :     case 'l':    // 1 string to match.
     404          14 :       if (memcmp(Name.data()+1, "ong_call", 8) != 0)
     405             :         break;
     406             :       return AttributeList::AT_MipsLongCall;     // "long_call"
     407        3364 :     case 'm':    // 3 strings to match.
     408        6728 :       switch (Name[1]) {
     409             :       default: break;
     410        3286 :       case 'a':  // 1 string to match.
     411        3286 :         if (memcmp(Name.data()+2, "y_alias", 7) != 0)
     412             :           break;
     413             :         return AttributeList::AT_MayAlias;       // "may_alias"
     414           8 :       case 'i':  // 1 string to match.
     415           8 :         if (memcmp(Name.data()+2, "cromips", 7) != 0)
     416             :           break;
     417             :         return AttributeList::AT_MicroMips;      // "micromips"
     418          70 :       case 's':  // 1 string to match.
     419          70 :         if (memcmp(Name.data()+2, "_struct", 7) != 0)
     420             :           break;
     421             :         return AttributeList::AT_MSStruct;       // "ms_struct"
     422             :       }
     423             :       break;
     424        1170 :     case 's':    // 2 strings to match.
     425        2340 :       switch (Name[1]) {
     426             :       default: break;
     427           3 :       case 'e':  // 1 string to match.
     428           3 :         if (memcmp(Name.data()+2, "lectany", 7) != 0)
     429             :           break;
     430             :         return AttributeList::AT_SelectAny;      // "selectany"
     431        1166 :       case 'w':  // 1 string to match.
     432        1166 :         if (memcmp(Name.data()+2, "iftcall", 7) != 0)
     433             :           break;
     434             :         return AttributeList::AT_SwiftCall;      // "swiftcall"
     435             :       }
     436             :       break;
     437          34 :     case 't':    // 1 string to match.
     438          34 :       if (memcmp(Name.data()+1, "ls_model", 8) != 0)
     439             :         break;
     440             :       return AttributeList::AT_TLSModel;         // "tls_model"
     441          11 :     case 'v':    // 1 string to match.
     442          11 :       if (memcmp(Name.data()+1, "ecreturn", 8) != 0)
     443             :         break;
     444             :       return AttributeList::AT_VecReturn;        // "vecreturn"
     445             :     }
     446             :     break;
     447       39923 :   case 10:       // 12 strings to match.
     448       79846 :     switch (Name[0]) {
     449             :     default: break;
     450          89 :     case 'a':    // 1 string to match.
     451          89 :       if (memcmp(Name.data()+1, "lloc_size", 9) != 0)
     452             :         break;
     453             :       return AttributeList::AT_AllocSize;        // "alloc_size"
     454        1686 :     case 'c':    // 3 strings to match.
     455        3372 :       switch (Name[1]) {
     456             :       default: break;
     457          17 :       case 'a':  // 1 string to match.
     458          17 :         if (memcmp(Name.data()+2, "pability", 8) != 0)
     459             :           break;
     460             :         return AttributeList::AT_Capability;     // "capability"
     461        1669 :       case 'o':  // 2 strings to match.
     462        3338 :         if (Name[2] != 'n')
     463             :           break;
     464        3338 :         switch (Name[3]) {
     465             :         default: break;
     466          26 :         case 's':        // 1 string to match.
     467          26 :           if (memcmp(Name.data()+4, "umable", 6) != 0)
     468             :             break;
     469             :           return AttributeList::AT_Consumable;   // "consumable"
     470        1643 :         case 'v':        // 1 string to match.
     471        1643 :           if (memcmp(Name.data()+4, "ergent", 6) != 0)
     472             :             break;
     473             :           return AttributeList::AT_Convergent;   // "convergent"
     474             :         }
     475             :         break;
     476             :       }
     477             :       break;
     478        1517 :     case 'd':    // 2 strings to match.
     479        3034 :       if (Name[1] != 'e')
     480             :         break;
     481        3034 :       switch (Name[2]) {
     482             :       default: break;
     483        1504 :       case 'p':  // 1 string to match.
     484        1504 :         if (memcmp(Name.data()+3, "recated", 7) != 0)
     485             :           break;
     486             :         return AttributeList::AT_Deprecated;     // "deprecated"
     487          13 :       case 's':  // 1 string to match.
     488          13 :         if (memcmp(Name.data()+3, "tructor", 7) != 0)
     489             :           break;
     490             :         return AttributeList::AT_Destructor;     // "destructor"
     491             :       }
     492             :       break;
     493        1273 :     case 'f':    // 1 string to match.
     494        1273 :       if (memcmp(Name.data()+1, "ormat_arg", 9) != 0)
     495             :         break;
     496             :       return AttributeList::AT_FormatArg;        // "format_arg"
     497        4904 :     case 'g':    // 2 strings to match.
     498        9808 :       switch (Name[1]) {
     499             :       default: break;
     500        3961 :       case 'n':  // 1 string to match.
     501        3961 :         if (memcmp(Name.data()+2, "u_inline", 8) != 0)
     502             :           break;
     503             :         return AttributeList::AT_GNUInline;      // "gnu_inline"
     504         943 :       case 'u':  // 1 string to match.
     505         943 :         if (memcmp(Name.data()+2, "arded_by", 8) != 0)
     506             :           break;
     507             :         return AttributeList::AT_GuardedBy;      // "guarded_by"
     508             :       }
     509             :       break;
     510          14 :     case 's':    // 1 string to match.
     511          14 :       if (memcmp(Name.data()+1, "hort_call", 9) != 0)
     512             :         break;
     513             :       return AttributeList::AT_MipsShortCall;    // "short_call"
     514       30440 :     case 'v':    // 2 strings to match.
     515       60880 :       switch (Name[1]) {
     516             :       default: break;
     517          15 :       case 'e':  // 1 string to match.
     518          15 :         if (memcmp(Name.data()+2, "ctorcall", 8) != 0)
     519             :           break;
     520             :         return AttributeList::AT_VectorCall;     // "vectorcall"
     521       30425 :       case 'i':  // 1 string to match.
     522       30425 :         if (memcmp(Name.data()+2, "sibility", 8) != 0)
     523             :           break;
     524             :         return AttributeList::AT_Visibility;     // "visibility"
     525             :       }
     526             :       break;
     527             :     }
     528             :     break;
     529       16292 :   case 11:       // 15 strings to match.
     530       32584 :     switch (Name[0]) {
     531             :     default: break;
     532          83 :     case 'a':    // 2 strings to match.
     533         166 :       if (Name[1] != 'l')
     534             :         break;
     535         166 :       switch (Name[2]) {
     536             :       default: break;
     537          43 :       case 'i':  // 1 string to match.
     538          43 :         if (memcmp(Name.data()+3, "gn_value", 8) != 0)
     539             :           break;
     540             :         return AttributeList::AT_AlignValue;     // "align_value"
     541          40 :       case 'l':  // 1 string to match.
     542          40 :         if (memcmp(Name.data()+3, "oc_align", 8) != 0)
     543             :           break;
     544             :         return AttributeList::AT_AllocAlign;     // "alloc_align"
     545             :       }
     546             :       break;
     547         316 :     case 'c':    // 2 strings to match.
     548         632 :       switch (Name[1]) {
     549             :       default: break;
     550         294 :       case 'f':  // 1 string to match.
     551         294 :         if (memcmp(Name.data()+2, "_consumed", 9) != 0)
     552             :           break;
     553             :         return AttributeList::AT_CFConsumed;     // "cf_consumed"
     554          22 :       case 'o':  // 1 string to match.
     555          22 :         if (memcmp(Name.data()+2, "nstructor", 9) != 0)
     556             :           break;
     557             :         return AttributeList::AT_Constructor;    // "constructor"
     558             :       }
     559             :       break;
     560         359 :     case 'd':    // 1 string to match.
     561         359 :       if (memcmp(Name.data()+1, "iagnose_if", 10) != 0)
     562             :         break;
     563             :       return AttributeList::AT_DiagnoseIf;       // "diagnose_if"
     564          35 :     case 'g':    // 1 string to match.
     565          35 :       if (memcmp(Name.data()+1, "uarded_var", 10) != 0)
     566             :         break;
     567             :       return AttributeList::AT_GuardedVar;       // "guarded_var"
     568         275 :     case 'n':    // 4 strings to match.
     569         550 :       switch (Name[1]) {
     570             :       default: break;
     571         164 :       case 'o':  // 3 strings to match.
     572         328 :         switch (Name[2]) {
     573             :         default: break;
     574         153 :         case '_':        // 1 string to match.
     575         153 :           if (memcmp(Name.data()+3, "sanitize", 8) != 0)
     576             :             break;
     577             :           return AttributeList::AT_NoSanitize;   // "no_sanitize"
     578           6 :         case 'd':        // 1 string to match.
     579           6 :           if (memcmp(Name.data()+3, "uplicate", 8) != 0)
     580             :             break;
     581             :           return AttributeList::AT_NoDuplicate;  // "noduplicate"
     582           5 :         case 'm':        // 1 string to match.
     583           5 :           if (memcmp(Name.data()+3, "icromips", 8) != 0)
     584             :             break;
     585             :           return AttributeList::AT_NoMicroMips;  // "nomicromips"
     586             :         }
     587             :         break;
     588         111 :       case 's':  // 1 string to match.
     589         111 :         if (memcmp(Name.data()+2, "_consumed", 9) != 0)
     590             :           break;
     591             :         return AttributeList::AT_NSConsumed;     // "ns_consumed"
     592             :       }
     593             :       break;
     594         205 :     case 'o':    // 1 string to match.
     595         205 :       if (memcmp(Name.data()+1, "bjc_bridge", 10) != 0)
     596             :         break;
     597             :       return AttributeList::AT_ObjCBridge;       // "objc_bridge"
     598        1603 :     case 'u':    // 1 string to match.
     599        1603 :       if (memcmp(Name.data()+1, "navailable", 10) != 0)
     600             :         break;
     601             :       return AttributeList::AT_Unavailable;      // "unavailable"
     602       13356 :     case 'v':    // 1 string to match.
     603       13356 :       if (memcmp(Name.data()+1, "ector_size", 10) != 0)
     604             :         break;
     605             :       return AttributeList::AT_VectorSize;       // "vector_size"
     606          60 :     case 'w':    // 2 strings to match.
     607         120 :       switch (Name[1]) {
     608             :       default: break;
     609           7 :       case 'a':  // 1 string to match.
     610           7 :         if (memcmp(Name.data()+2, "rn_unused", 9) != 0)
     611             :           break;
     612             :         return AttributeList::AT_WarnUnused;     // "warn_unused"
     613          53 :       case 'e':  // 1 string to match.
     614          53 :         if (memcmp(Name.data()+2, "ak_import", 9) != 0)
     615             :           break;
     616             :         return AttributeList::AT_WeakImport;     // "weak_import"
     617             :       }
     618             :       break;
     619             :     }
     620             :     break;
     621      267127 :   case 12:       // 4 strings to match.
     622      534254 :     switch (Name[0]) {
     623             :     default: break;
     624        1613 :     case 'a':    // 1 string to match.
     625        1613 :       if (memcmp(Name.data()+1, "vailability", 11) != 0)
     626             :         break;
     627             :       return AttributeList::AT_Availability;     // "availability"
     628      265500 :     case 'o':    // 2 strings to match.
     629      531000 :       switch (Name[1]) {
     630             :       default: break;
     631          55 :       case 'b':  // 1 string to match.
     632          55 :         if (memcmp(Name.data()+2, "jc_boxable", 10) != 0)
     633             :           break;
     634             :         return AttributeList::AT_ObjCBoxable;    // "objc_boxable"
     635      265445 :       case 'v':  // 1 string to match.
     636      265445 :         if (memcmp(Name.data()+2, "erloadable", 10) != 0)
     637             :           break;
     638             :         return AttributeList::AT_Overloadable;   // "overloadable"
     639             :       }
     640             :       break;
     641          14 :     case 'p':    // 1 string to match.
     642          14 :       if (memcmp(Name.data()+1, "reserve_all", 11) != 0)
     643             :         break;
     644             :       return AttributeList::AT_PreserveAll;      // "preserve_all"
     645             :     }
     646             :     break;
     647      602432 :   case 13:       // 13 strings to match.
     648     1204864 :     switch (Name[0]) {
     649             :     default: break;
     650      601404 :     case 'a':    // 2 strings to match.
     651     1202808 :       switch (Name[1]) {
     652             :       default: break;
     653         290 :       case 'd':  // 1 string to match.
     654         290 :         if (memcmp(Name.data()+2, "dress_space", 11) != 0)
     655             :           break;
     656             :         return AttributeList::AT_AddressSpace;   // "address_space"
     657      601114 :       case 'l':  // 1 string to match.
     658      601114 :         if (memcmp(Name.data()+2, "ways_inline", 11) != 0)
     659             :           break;
     660             :         return AttributeList::AT_AlwaysInline;   // "always_inline"
     661             :       }
     662             :       break;
     663          37 :     case 'c':    // 1 string to match.
     664          37 :       if (memcmp(Name.data()+1, "allable_when", 12) != 0)
     665             :         break;
     666             :       return AttributeList::AT_CallableWhen;     // "callable_when"
     667         218 :     case 'i':    // 1 string to match.
     668         218 :       if (memcmp(Name.data()+1, "nit_priority", 12) != 0)
     669             :         break;
     670             :       return AttributeList::AT_InitPriority;     // "init_priority"
     671         302 :     case 'l':    // 2 strings to match.
     672         604 :       switch (Name[1]) {
     673             :       default: break;
     674          74 :       case 'a':  // 1 string to match.
     675          74 :         if (memcmp(Name.data()+2, "unch_bounds", 11) != 0)
     676             :           break;
     677             :         return AttributeList::AT_CUDALaunchBounds;       // "launch_bounds"
     678         228 :       case 'o':  // 1 string to match.
     679         228 :         if (memcmp(Name.data()+2, "ck_returned", 11) != 0)
     680             :           break;
     681             :         return AttributeList::AT_LockReturned;   // "lock_returned"
     682             :       }
     683             :       break;
     684         335 :     case 'p':    // 2 strings to match.
     685         670 :       switch (Name[1]) {
     686             :       default: break;
     687          14 :       case 'r':  // 1 string to match.
     688          14 :         if (memcmp(Name.data()+2, "eserve_most", 11) != 0)
     689             :           break;
     690             :         return AttributeList::AT_PreserveMost;   // "preserve_most"
     691         321 :       case 't':  // 1 string to match.
     692         321 :         if (memcmp(Name.data()+2, "_guarded_by", 11) != 0)
     693             :           break;
     694             :         return AttributeList::AT_PtGuardedBy;    // "pt_guarded_by"
     695             :       }
     696             :       break;
     697          13 :     case 'r':    // 1 string to match.
     698          13 :       if (memcmp(Name.data()+1, "eturns_twice", 12) != 0)
     699             :         break;
     700             :       return AttributeList::AT_ReturnsTwice;     // "returns_twice"
     701          94 :     case 's':    // 2 strings to match.
     702         188 :       switch (Name[1]) {
     703             :       default: break;
     704          38 :       case 'e':  // 1 string to match.
     705          38 :         if (memcmp(Name.data()+2, "t_typestate", 11) != 0)
     706             :           break;
     707             :         return AttributeList::AT_SetTypestate;   // "set_typestate"
     708          56 :       case 'w':  // 1 string to match.
     709          56 :         if (memcmp(Name.data()+2, "ift_context", 11) != 0)
     710             :           break;
     711             :         return AttributeList::AT_SwiftContext;   // "swift_context"
     712             :       }
     713             :       break;
     714          19 :     case 'v':    // 1 string to match.
     715          19 :       if (memcmp(Name.data()+1, "ec_type_hint", 12) != 0)
     716             :         break;
     717             :       return AttributeList::AT_VecTypeHint;      // "vec_type_hint"
     718          10 :     case 'x':    // 1 string to match.
     719          10 :       if (memcmp(Name.data()+1, "ray_log_args", 12) != 0)
     720             :         break;
     721             :       return AttributeList::AT_XRayLogArgs;      // "xray_log_args"
     722             :     }
     723             :     break;
     724        6713 :   case 14:       // 11 strings to match.
     725       13426 :     switch (Name[0]) {
     726             :     default: break;
     727         358 :     case 'a':    // 2 strings to match.
     728         716 :       switch (Name[1]) {
     729             :       default: break;
     730         312 :       case 'c':  // 1 string to match.
     731         312 :         if (memcmp(Name.data()+2, "quired_after", 12) != 0)
     732             :           break;
     733             :         return AttributeList::AT_AcquiredAfter;  // "acquired_after"
     734          46 :       case 's':  // 1 string to match.
     735          46 :         if (memcmp(Name.data()+2, "sume_aligned", 12) != 0)
     736             :           break;
     737             :         return AttributeList::AT_AssumeAligned;  // "assume_aligned"
     738             :       }
     739             :       break;
     740           6 :     case 'c':    // 1 string to match.
     741           6 :       if (memcmp(Name.data()+1, "udart_builtin", 13) != 0)
     742             :         break;
     743             :       return AttributeList::IgnoredAttribute;    // "cudart_builtin"
     744          24 :     case 'd':    // 1 string to match.
     745          24 :       if (memcmp(Name.data()+1, "evice_builtin", 13) != 0)
     746             :         break;
     747             :       return AttributeList::IgnoredAttribute;    // "device_builtin"
     748           5 :     case 'i':    // 1 string to match.
     749           5 :       if (memcmp(Name.data()+1, "ntel_ocl_bicc", 13) != 0)
     750             :         break;
     751             :       return AttributeList::AT_IntelOclBicc;     // "intel_ocl_bicc"
     752         298 :     case 'l':    // 1 string to match.
     753         298 :       if (memcmp(Name.data()+1, "ocks_excluded", 13) != 0)
     754             :         break;
     755             :       return AttributeList::AT_LocksExcluded;    // "locks_excluded"
     756          11 :     case 'n':    // 1 string to match.
     757          11 :       if (memcmp(Name.data()+1, "o_split_stack", 13) != 0)
     758             :         break;
     759             :       return AttributeList::AT_NoSplitStack;     // "no_split_stack"
     760        5940 :     case 'o':    // 2 strings to match.
     761        5940 :       if (memcmp(Name.data()+1, "bjc_", 4) != 0)
     762             :         break;
     763       11880 :       switch (Name[5]) {
     764             :       default: break;
     765          25 :       case 'e':  // 1 string to match.
     766          25 :         if (memcmp(Name.data()+6, "xception", 8) != 0)
     767             :           break;
     768             :         return AttributeList::AT_ObjCException;  // "objc_exception"
     769        5915 :       case 'o':  // 1 string to match.
     770        5915 :         if (memcmp(Name.data()+6, "wnership", 8) != 0)
     771             :           break;
     772             :         return AttributeList::AT_ObjCOwnership;  // "objc_ownership"
     773             :       }
     774             :       break;
     775          45 :     case 'p':    // 1 string to match.
     776          45 :       if (memcmp(Name.data()+1, "t_guarded_var", 13) != 0)
     777             :         break;
     778             :       return AttributeList::AT_PtGuardedVar;     // "pt_guarded_var"
     779          26 :     case 't':    // 1 string to match.
     780          26 :       if (memcmp(Name.data()+1, "est_typestate", 13) != 0)
     781             :         break;
     782             :       return AttributeList::AT_TestTypestate;    // "test_typestate"
     783             :     }
     784             :     break;
     785        4438 :   case 15:       // 13 strings to match.
     786        8876 :     switch (Name[0]) {
     787             :     default: break;
     788         445 :     case 'a':    // 3 strings to match.
     789         890 :       switch (Name[1]) {
     790             :       default: break;
     791         241 :       case 'c':  // 1 string to match.
     792         241 :         if (memcmp(Name.data()+2, "quired_before", 13) != 0)
     793             :           break;
     794             :         return AttributeList::AT_AcquiredBefore;         // "acquired_before"
     795         204 :       case 'm':  // 2 strings to match.
     796         204 :         if (memcmp(Name.data()+2, "dgpu_num_", 9) != 0)
     797             :           break;
     798         408 :         switch (Name[11]) {
     799             :         default: break;
     800         102 :         case 's':        // 1 string to match.
     801         102 :           if (memcmp(Name.data()+12, "gpr", 3) != 0)
     802             :             break;
     803             :           return AttributeList::AT_AMDGPUNumSGPR;        // "amdgpu_num_sgpr"
     804         102 :         case 'v':        // 1 string to match.
     805         102 :           if (memcmp(Name.data()+12, "gpr", 3) != 0)
     806             :             break;
     807             :           return AttributeList::AT_AMDGPUNumVGPR;        // "amdgpu_num_vgpr"
     808             :         }
     809             :         break;
     810             :       }
     811             :       break;
     812        3171 :     case 'e':    // 1 string to match.
     813        3171 :       if (memcmp(Name.data()+1, "xt_vector_type", 14) != 0)
     814             :         break;
     815             :       return AttributeList::AT_ExtVectorType;    // "ext_vector_type"
     816           8 :     case 'n':    // 1 string to match.
     817           8 :       if (memcmp(Name.data()+1, "ot_tail_called", 14) != 0)
     818             :         break;
     819             :       return AttributeList::AT_NotTailCalled;    // "not_tail_called"
     820         216 :     case 'o':    // 3 strings to match.
     821         432 :       switch (Name[1]) {
     822             :       default: break;
     823         145 :       case 'b':  // 1 string to match.
     824         145 :         if (memcmp(Name.data()+2, "jc_root_class", 13) != 0)
     825             :           break;
     826             :         return AttributeList::AT_ObjCRootClass;  // "objc_root_class"
     827          71 :       case 'w':  // 2 strings to match.
     828          71 :         if (memcmp(Name.data()+2, "nership_", 8) != 0)
     829             :           break;
     830         142 :         switch (Name[10]) {
     831             :         default: break;
     832          42 :         case 'h':        // 1 string to match.
     833          42 :           if (memcmp(Name.data()+11, "olds", 4) != 0)
     834             :             break;
     835             :           return AttributeList::AT_Ownership;    // "ownership_holds"
     836          29 :         case 't':        // 1 string to match.
     837          29 :           if (memcmp(Name.data()+11, "akes", 4) != 0)
     838             :             break;
     839             :           return AttributeList::AT_Ownership;    // "ownership_takes"
     840             :         }
     841             :         break;
     842             :       }
     843             :       break;
     844          21 :     case 'p':    // 1 string to match.
     845          21 :       if (memcmp(Name.data()+1, "aram_typestate", 14) != 0)
     846             :         break;
     847             :       return AttributeList::AT_ParamTypestate;   // "param_typestate"
     848          19 :     case 'r':    // 1 string to match.
     849          19 :       if (memcmp(Name.data()+1, "eturns_nonnull", 14) != 0)
     850             :         break;
     851             :       return AttributeList::AT_ReturnsNonNull;   // "returns_nonnull"
     852          43 :     case 's':    // 1 string to match.
     853          43 :       if (memcmp(Name.data()+1, "coped_lockable", 14) != 0)
     854             :         break;
     855             :       return AttributeList::AT_ScopedLockable;   // "scoped_lockable"
     856          54 :     case 't':    // 1 string to match.
     857          54 :       if (memcmp(Name.data()+1, "ype_visibility", 14) != 0)
     858             :         break;
     859             :       return AttributeList::AT_TypeVisibility;   // "type_visibility"
     860         461 :     case 'u':    // 1 string to match.
     861         461 :       if (memcmp(Name.data()+1, "nlock_function", 14) != 0)
     862             :         break;
     863             :       return AttributeList::AT_ReleaseCapability;        // "unlock_function"
     864             :     }
     865             :     break;
     866        3974 :   case 16:       // 5 strings to match.
     867        7948 :     switch (Name[0]) {
     868             :     default: break;
     869          36 :     case 'i':    // 1 string to match.
     870          36 :       if (memcmp(Name.data()+1, "nternal_linkage", 15) != 0)
     871             :         break;
     872             :       return AttributeList::AT_InternalLinkage;  // "internal_linkage"
     873        3682 :     case 'n':    // 2 strings to match.
     874        7364 :       switch (Name[1]) {
     875             :       default: break;
     876        3672 :       case 'e':  // 1 string to match.
     877        3672 :         if (memcmp(Name.data()+2, "on_vector_type", 14) != 0)
     878             :           break;
     879             :         return AttributeList::AT_NeonVectorType;         // "neon_vector_type"
     880          10 :       case 's':  // 1 string to match.
     881          10 :         if (memcmp(Name.data()+2, "_consumes_self", 14) != 0)
     882             :           break;
     883             :         return AttributeList::AT_NSConsumesSelf;         // "ns_consumes_self"
     884             :       }
     885             :       break;
     886         218 :     case 'p':    // 1 string to match.
     887         218 :       if (memcmp(Name.data()+1, "ass_object_size", 15) != 0)
     888             :         break;
     889             :       return AttributeList::AT_PassObjectSize;   // "pass_object_size"
     890          38 :     case 'r':    // 1 string to match.
     891          38 :       if (memcmp(Name.data()+1, "eturn_typestate", 15) != 0)
     892             :         break;
     893             :       return AttributeList::AT_ReturnTypestate;  // "return_typestate"
     894             :     }
     895             :     break;
     896         191 :   case 17:       // 6 strings to match.
     897         382 :     switch (Name[0]) {
     898             :     default: break;
     899          23 :     case 'a':    // 2 strings to match.
     900          46 :       switch (Name[1]) {
     901             :       default: break;
     902           6 :       case 'n':  // 1 string to match.
     903           6 :         if (memcmp(Name.data()+2, "alyzer_noreturn", 15) != 0)
     904             :           break;
     905             :         return AttributeList::AT_AnalyzerNoReturn;       // "analyzer_noreturn"
     906          17 :       case 's':  // 1 string to match.
     907          17 :         if (memcmp(Name.data()+2, "sert_capability", 15) != 0)
     908             :           break;
     909             :         return AttributeList::AT_AssertCapability;       // "assert_capability"
     910             :       }
     911             :       break;
     912         107 :     case 'o':    // 2 strings to match.
     913         214 :       switch (Name[1]) {
     914             :       default: break;
     915          77 :       case 'b':  // 1 string to match.
     916          77 :         if (memcmp(Name.data()+2, "jc_runtime_name", 15) != 0)
     917             :           break;
     918             :         return AttributeList::AT_ObjCRuntimeName;        // "objc_runtime_name"
     919          30 :       case 'w':  // 1 string to match.
     920          30 :         if (memcmp(Name.data()+2, "nership_returns", 15) != 0)
     921             :           break;
     922             :         return AttributeList::AT_Ownership;      // "ownership_returns"
     923             :       }
     924             :       break;
     925           9 :     case 's':    // 1 string to match.
     926           9 :       if (memcmp(Name.data()+1, "hared_capability", 16) != 0)
     927             :         break;
     928             :       return AttributeList::AT_Capability;       // "shared_capability"
     929          49 :     case 't':    // 1 string to match.
     930          49 :       if (memcmp(Name.data()+1, "ransparent_union", 16) != 0)
     931             :         break;
     932             :       return AttributeList::AT_TransparentUnion;         // "transparent_union"
     933             :     }
     934             :     break;
     935        4246 :   case 18:       // 13 strings to match.
     936        8492 :     switch (Name[0]) {
     937             :     default: break;
     938          26 :     case 'a':    // 2 strings to match.
     939          52 :       switch (Name[1]) {
     940             :       default: break;
     941           5 :       case 'c':  // 1 string to match.
     942           5 :         if (memcmp(Name.data()+2, "quire_capability", 16) != 0)
     943             :           break;
     944             :         return AttributeList::AT_AcquireCapability;      // "acquire_capability"
     945          21 :       case 's':  // 1 string to match.
     946          21 :         if (memcmp(Name.data()+2, "sert_shared_lock", 16) != 0)
     947             :           break;
     948             :         return AttributeList::AT_AssertSharedLock;       // "assert_shared_lock"
     949             :       }
     950             :       break;
     951           0 :     case 'c':    // 1 string to match.
     952           0 :       if (memcmp(Name.data()+1, "arries_dependency", 17) != 0)
     953             :         break;
     954             :       return AttributeList::AT_CarriesDependency;        // "carries_dependency"
     955           7 :     case 'd':    // 1 string to match.
     956           7 :       if (memcmp(Name.data()+1, "isable_tail_calls", 17) != 0)
     957             :         break;
     958             :       return AttributeList::AT_DisableTailCalls;         // "disable_tail_calls"
     959         649 :     case 'e':    // 1 string to match.
     960         649 :       if (memcmp(Name.data()+1, "num_extensibility", 17) != 0)
     961             :         break;
     962             :       return AttributeList::AT_EnumExtensibility;        // "enum_extensibility"
     963          74 :     case 'i':    // 1 string to match.
     964          74 :       if (memcmp(Name.data()+1, "boutletcollection", 17) != 0)
     965             :         break;
     966             :       return AttributeList::AT_IBOutletCollection;       // "iboutletcollection"
     967          32 :     case 'n':    // 2 strings to match.
     968          32 :       if (memcmp(Name.data()+1, "o_sanitize_", 11) != 0)
     969             :         break;
     970          64 :       switch (Name[12]) {
     971             :       default: break;
     972          12 :       case 'm':  // 1 string to match.
     973          12 :         if (memcmp(Name.data()+13, "emory", 5) != 0)
     974             :           break;
     975             :         return AttributeList::AT_NoSanitizeSpecific;     // "no_sanitize_memory"
     976          20 :       case 't':  // 1 string to match.
     977          20 :         if (memcmp(Name.data()+13, "hread", 5) != 0)
     978             :           break;
     979             :         return AttributeList::AT_NoSanitizeSpecific;     // "no_sanitize_thread"
     980             :       }
     981             :       break;
     982          76 :     case 'o':    // 2 strings to match.
     983         152 :       switch (Name[1]) {
     984             :       default: break;
     985          37 :       case 'b':  // 1 string to match.
     986          37 :         if (memcmp(Name.data()+2, "jc_method_family", 16) != 0)
     987             :           break;
     988             :         return AttributeList::AT_ObjCMethodFamily;       // "objc_method_family"
     989          39 :       case 'p':  // 1 string to match.
     990          39 :         if (memcmp(Name.data()+2, "encl_unroll_hint", 16) != 0)
     991             :           break;
     992             :         return AttributeList::AT_OpenCLUnrollHint;       // "opencl_unroll_hint"
     993             :       }
     994             :       break;
     995          14 :     case 'r':    // 1 string to match.
     996          14 :       if (memcmp(Name.data()+1, "elease_capability", 17) != 0)
     997             :         break;
     998             :       return AttributeList::AT_ReleaseCapability;        // "release_capability"
     999          34 :     case 's':    // 1 string to match.
    1000          34 :       if (memcmp(Name.data()+1, "wift_error_result", 17) != 0)
    1001             :         break;
    1002             :       return AttributeList::AT_SwiftErrorResult;         // "swift_error_result"
    1003        3334 :     case 'w':    // 1 string to match.
    1004        3334 :       if (memcmp(Name.data()+1, "arn_unused_result", 17) != 0)
    1005             :         break;
    1006             :       return AttributeList::AT_WarnUnusedResult;         // "warn_unused_result"
    1007             :     }
    1008             :     break;
    1009         859 :   case 19:       // 10 strings to match.
    1010        1718 :     switch (Name[0]) {
    1011             :     default: break;
    1012         174 :     case 'a':    // 1 string to match.
    1013         174 :       if (memcmp(Name.data()+1, "mdgpu_waves_per_eu", 18) != 0)
    1014             :         break;
    1015             :       return AttributeList::AT_AMDGPUWavesPerEU;         // "amdgpu_waves_per_eu"
    1016         184 :     case 'c':    // 3 strings to match.
    1017         184 :       if (memcmp(Name.data()+1, "f_", 2) != 0)
    1018             :         break;
    1019         368 :       switch (Name[3]) {
    1020             :       default: break;
    1021           0 :       case 'a':  // 1 string to match.
    1022           0 :         if (memcmp(Name.data()+4, "udited_transfer", 15) != 0)
    1023             :           break;
    1024             :         return AttributeList::AT_CFAuditedTransfer;      // "cf_audited_transfer"
    1025         183 :       case 'r':  // 1 string to match.
    1026         183 :         if (memcmp(Name.data()+4, "eturns_retained", 15) != 0)
    1027             :           break;
    1028             :         return AttributeList::AT_CFReturnsRetained;      // "cf_returns_retained"
    1029           1 :       case 'u':  // 1 string to match.
    1030           1 :         if (memcmp(Name.data()+4, "nknown_transfer", 15) != 0)
    1031             :           break;
    1032             :         return AttributeList::AT_CFUnknownTransfer;      // "cf_unknown_transfer"
    1033             :       }
    1034             :       break;
    1035         329 :     case 'n':    // 2 strings to match.
    1036         658 :       switch (Name[1]) {
    1037             :       default: break;
    1038          31 :       case 'o':  // 1 string to match.
    1039          31 :         if (memcmp(Name.data()+2, "_sanitize_address", 17) != 0)
    1040             :           break;
    1041             :         return AttributeList::AT_NoSanitizeSpecific;     // "no_sanitize_address"
    1042         298 :       case 's':  // 1 string to match.
    1043         298 :         if (memcmp(Name.data()+2, "_returns_retained", 17) != 0)
    1044             :           break;
    1045             :         return AttributeList::AT_NSReturnsRetained;      // "ns_returns_retained"
    1046             :       }
    1047             :       break;
    1048         125 :     case 'o':    // 3 strings to match.
    1049         125 :       if (memcmp(Name.data()+1, "bjc_", 4) != 0)
    1050             :         break;
    1051         250 :       switch (Name[5]) {
    1052             :       default: break;
    1053          73 :       case 'b':  // 2 strings to match.
    1054          73 :         if (memcmp(Name.data()+6, "ridge_", 6) != 0)
    1055             :           break;
    1056         146 :         switch (Name[12]) {
    1057             :         default: break;
    1058          17 :         case 'm':        // 1 string to match.
    1059          17 :           if (memcmp(Name.data()+13, "utable", 6) != 0)
    1060             :             break;
    1061             :           return AttributeList::AT_ObjCBridgeMutable;    // "objc_bridge_mutable"
    1062          56 :         case 'r':        // 1 string to match.
    1063          56 :           if (memcmp(Name.data()+13, "elated", 6) != 0)
    1064             :             break;
    1065             :           return AttributeList::AT_ObjCBridgeRelated;    // "objc_bridge_related"
    1066             :         }
    1067             :         break;
    1068          52 :       case 'r':  // 1 string to match.
    1069          52 :         if (memcmp(Name.data()+6, "equires_super", 13) != 0)
    1070             :           break;
    1071             :         return AttributeList::AT_ObjCRequiresSuper;      // "objc_requires_super"
    1072             :       }
    1073             :       break;
    1074          47 :     case 'r':    // 1 string to match.
    1075          47 :       if (memcmp(Name.data()+1, "equires_capability", 18) != 0)
    1076             :         break;
    1077             :       return AttributeList::AT_RequiresCapability;       // "requires_capability"
    1078             :     }
    1079             :     break;
    1080        1195 :   case 20:       // 5 strings to match.
    1081        2390 :     switch (Name[0]) {
    1082             :     default: break;
    1083         902 :     case 'n':    // 1 string to match.
    1084         902 :       if (memcmp(Name.data()+1, "eon_polyvector_type", 19) != 0)
    1085             :         break;
    1086             :       return AttributeList::AT_NeonPolyVectorType;       // "neon_polyvector_type"
    1087           3 :     case 'o':    // 1 string to match.
    1088           3 :       if (memcmp(Name.data()+1, "bjc_runtime_visible", 19) != 0)
    1089             :         break;
    1090             :       return AttributeList::AT_ObjCRuntimeVisible;       // "objc_runtime_visible"
    1091          20 :     case 'r':    // 1 string to match.
    1092          20 :       if (memcmp(Name.data()+1, "eqd_work_group_size", 19) != 0)
    1093             :         break;
    1094             :       return AttributeList::AT_ReqdWorkGroupSize;        // "reqd_work_group_size"
    1095         258 :     case 's':    // 1 string to match.
    1096         258 :       if (memcmp(Name.data()+1, "hared_lock_function", 19) != 0)
    1097             :         break;
    1098             :       return AttributeList::AT_AcquireCapability;        // "shared_lock_function"
    1099          12 :     case 'w':    // 1 string to match.
    1100          12 :       if (memcmp(Name.data()+1, "ork_group_size_hint", 19) != 0)
    1101             :         break;
    1102             :       return AttributeList::AT_WorkGroupSizeHint;        // "work_group_size_hint"
    1103             :     }
    1104             :     break;
    1105         963 :   case 21:       // 7 strings to match.
    1106        1926 :     switch (Name[0]) {
    1107             :     default: break;
    1108          24 :     case 'a':    // 1 string to match.
    1109          24 :       if (memcmp(Name.data()+1, "ssert_exclusive_lock", 20) != 0)
    1110             :         break;
    1111             :       return AttributeList::AT_AssertExclusiveLock;      // "assert_exclusive_lock"
    1112           9 :     case 'o':    // 1 string to match.
    1113           9 :       if (memcmp(Name.data()+1, "bjc_precise_lifetime", 20) != 0)
    1114             :         break;
    1115             :       return AttributeList::AT_ObjCPreciseLifetime;      // "objc_precise_lifetime"
    1116         222 :     case 'p':    // 1 string to match.
    1117         222 :       if (memcmp(Name.data()+1, "ointer_with_type_tag", 20) != 0)
    1118             :         break;
    1119             :       return AttributeList::AT_ArgumentWithTypeTag;      // "pointer_with_type_tag"
    1120         366 :     case 's':    // 2 strings to match.
    1121         732 :       switch (Name[1]) {
    1122             :       default: break;
    1123         298 :       case 'h':  // 1 string to match.
    1124         298 :         if (memcmp(Name.data()+2, "ared_locks_required", 19) != 0)
    1125             :           break;
    1126             :         return AttributeList::AT_RequiresCapability;     // "shared_locks_required"
    1127          68 :       case 'w':  // 1 string to match.
    1128          68 :         if (memcmp(Name.data()+2, "ift_indirect_result", 19) != 0)
    1129             :           break;
    1130             :         return AttributeList::AT_SwiftIndirectResult;    // "swift_indirect_result"
    1131             :       }
    1132             :       break;
    1133         342 :     case 't':    // 1 string to match.
    1134         342 :       if (memcmp(Name.data()+1, "ype_tag_for_datatype", 20) != 0)
    1135             :         break;
    1136             :       return AttributeList::AT_TypeTagForDatatype;       // "type_tag_for_datatype"
    1137           0 :     case 'x':    // 1 string to match.
    1138           0 :       if (memcmp(Name.data()+1, "ray_never_instrument", 20) != 0)
    1139             :         break;
    1140             :       return AttributeList::AT_XRayInstrument;   // "xray_never_instrument"
    1141             :     }
    1142             :     break;
    1143         173 :   case 22:       // 6 strings to match.
    1144         346 :     switch (Name[0]) {
    1145             :     default: break;
    1146           9 :     case 'a':    // 1 string to match.
    1147           9 :       if (memcmp(Name.data()+1, "rgument_with_type_tag", 21) != 0)
    1148             :         break;
    1149             :       return AttributeList::AT_ArgumentWithTypeTag;      // "argument_with_type_tag"
    1150         122 :     case 'e':    // 1 string to match.
    1151         122 :       if (memcmp(Name.data()+1, "xternal_source_symbol", 21) != 0)
    1152             :         break;
    1153             :       return AttributeList::AT_ExternalSourceSymbol;     // "external_source_symbol"
    1154          22 :     case 'n':    // 1 string to match.
    1155          22 :       if (memcmp(Name.data()+1, "o_instrument_function", 21) != 0)
    1156             :         break;
    1157             :       return AttributeList::AT_NoInstrumentFunction;     // "no_instrument_function"
    1158           8 :     case 'o':    // 1 string to match.
    1159           8 :       if (memcmp(Name.data()+1, "bjc_independent_class", 21) != 0)
    1160             :         break;
    1161             :       return AttributeList::AT_ObjCIndependentClass;     // "objc_independent_class"
    1162           8 :     case 't':    // 1 string to match.
    1163           8 :       if (memcmp(Name.data()+1, "ry_acquire_capability", 21) != 0)
    1164             :         break;
    1165             :       return AttributeList::AT_TryAcquireCapability;     // "try_acquire_capability"
    1166           4 :     case 'x':    // 1 string to match.
    1167           4 :       if (memcmp(Name.data()+1, "ray_always_instrument", 21) != 0)
    1168             :         break;
    1169             :       return AttributeList::AT_XRayInstrument;   // "xray_always_instrument"
    1170             :     }
    1171             :     break;
    1172         837 :   case 23:       // 6 strings to match.
    1173        1674 :     switch (Name[0]) {
    1174             :     default: break;
    1175          43 :     case 'c':    // 1 string to match.
    1176          43 :       if (memcmp(Name.data()+1, "f_returns_not_retained", 22) != 0)
    1177             :         break;
    1178             :       return AttributeList::AT_CFReturnsNotRetained;     // "cf_returns_not_retained"
    1179         493 :     case 'e':    // 1 string to match.
    1180         493 :       if (memcmp(Name.data()+1, "xclusive_lock_function", 22) != 0)
    1181             :         break;
    1182             :       return AttributeList::AT_AcquireCapability;        // "exclusive_lock_function"
    1183          10 :     case 'f':    // 1 string to match.
    1184          10 :       if (memcmp(Name.data()+1, "orce_align_arg_pointer", 22) != 0)
    1185             :         break;
    1186             :       return AttributeList::AT_X86ForceAlignArgPointer;  // "force_align_arg_pointer"
    1187         112 :     case 'n':    // 2 strings to match.
    1188         112 :       if (memcmp(Name.data()+1, "s_returns_", 10) != 0)
    1189             :         break;
    1190         224 :       switch (Name[11]) {
    1191             :       default: break;
    1192           4 :       case 'a':  // 1 string to match.
    1193           4 :         if (memcmp(Name.data()+12, "utoreleased", 11) != 0)
    1194             :           break;
    1195             :         return AttributeList::AT_NSReturnsAutoreleased;  // "ns_returns_autoreleased"
    1196         108 :       case 'n':  // 1 string to match.
    1197         108 :         if (memcmp(Name.data()+12, "ot_retained", 11) != 0)
    1198             :           break;
    1199             :         return AttributeList::AT_NSReturnsNotRetained;   // "ns_returns_not_retained"
    1200             :       }
    1201             :       break;
    1202         179 :     case 's':    // 1 string to match.
    1203         179 :       if (memcmp(Name.data()+1, "hared_trylock_function", 22) != 0)
    1204             :         break;
    1205             :       return AttributeList::AT_SharedTrylockFunction;    // "shared_trylock_function"
    1206             :     }
    1207             :     break;
    1208         980 :   case 24:       // 2 strings to match.
    1209        1960 :     switch (Name[0]) {
    1210             :     default: break;
    1211          14 :     case 'a':    // 1 string to match.
    1212          14 :       if (memcmp(Name.data()+1, "ssert_shared_capability", 23) != 0)
    1213             :         break;
    1214             :       return AttributeList::AT_AssertCapability;         // "assert_shared_capability"
    1215         966 :     case 'e':    // 1 string to match.
    1216         966 :       if (memcmp(Name.data()+1, "xclusive_locks_required", 23) != 0)
    1217             :         break;
    1218             :       return AttributeList::AT_RequiresCapability;       // "exclusive_locks_required"
    1219             :     }
    1220             :     break;
    1221         102 :   case 25:       // 5 strings to match.
    1222         204 :     switch (Name[0]) {
    1223             :     default: break;
    1224           3 :     case 'a':    // 1 string to match.
    1225           3 :       if (memcmp(Name.data()+1, "cquire_shared_capability", 24) != 0)
    1226             :         break;
    1227             :       return AttributeList::AT_AcquireCapability;        // "acquire_shared_capability"
    1228          10 :     case 'i':    // 1 string to match.
    1229          10 :       if (memcmp(Name.data()+1, "ntel_reqd_sub_group_size", 24) != 0)
    1230             :         break;
    1231             :       return AttributeList::AT_OpenCLIntelReqdSubGroupSize;      // "intel_reqd_sub_group_size"
    1232          77 :     case 'n':    // 2 strings to match.
    1233          77 :       if (memcmp(Name.data()+1, "o_", 2) != 0)
    1234             :         break;
    1235         154 :       switch (Name[3]) {
    1236             :       default: break;
    1237          27 :       case 'c':  // 1 string to match.
    1238          27 :         if (memcmp(Name.data()+4, "aller_saved_registers", 21) != 0)
    1239             :           break;
    1240             :         return AttributeList::AT_AnyX86NoCallerSavedRegisters;   // "no_caller_saved_registers"
    1241          50 :       case 't':  // 1 string to match.
    1242          50 :         if (memcmp(Name.data()+4, "hread_safety_analysis", 21) != 0)
    1243             :           break;
    1244             :         return AttributeList::AT_NoThreadSafetyAnalysis;         // "no_thread_safety_analysis"
    1245             :       }
    1246             :       break;
    1247          12 :     case 'r':    // 1 string to match.
    1248          12 :       if (memcmp(Name.data()+1, "elease_shared_capability", 24) != 0)
    1249             :         break;
    1250             :       return AttributeList::AT_ReleaseCapability;        // "release_shared_capability"
    1251             :     }
    1252             :     break;
    1253         231 :   case 26:       // 6 strings to match.
    1254         462 :     switch (Name[0]) {
    1255             :     default: break;
    1256           2 :     case 'c':    // 1 string to match.
    1257           2 :       if (memcmp(Name.data()+1, "onsumable_auto_cast_state", 25) != 0)
    1258             :         break;
    1259             :       return AttributeList::AT_ConsumableAutoCast;       // "consumable_auto_cast_state"
    1260         195 :     case 'e':    // 1 string to match.
    1261         195 :       if (memcmp(Name.data()+1, "xclusive_trylock_function", 25) != 0)
    1262             :         break;
    1263             :       return AttributeList::AT_ExclusiveTrylockFunction;         // "exclusive_trylock_function"
    1264           1 :     case 'n':    // 1 string to match.
    1265           1 :       if (memcmp(Name.data()+1, "o_address_safety_analysis", 25) != 0)
    1266             :         break;
    1267             :       return AttributeList::AT_NoSanitizeSpecific;       // "no_address_safety_analysis"
    1268          23 :     case 'o':    // 1 string to match.
    1269          23 :       if (memcmp(Name.data()+1, "bjc_returns_inner_pointer", 25) != 0)
    1270             :         break;
    1271             :       return AttributeList::AT_ObjCReturnsInnerPointer;  // "objc_returns_inner_pointer"
    1272          10 :     case 'r':    // 2 strings to match.
    1273          20 :       if (Name[1] != 'e')
    1274             :         break;
    1275          20 :       switch (Name[2]) {
    1276             :       default: break;
    1277           3 :       case 'l':  // 1 string to match.
    1278           3 :         if (memcmp(Name.data()+3, "ease_generic_capability", 23) != 0)
    1279             :           break;
    1280             :         return AttributeList::AT_ReleaseCapability;      // "release_generic_capability"
    1281           7 :       case 'q':  // 1 string to match.
    1282           7 :         if (memcmp(Name.data()+3, "uires_shared_capability", 23) != 0)
    1283             :           break;
    1284             :         return AttributeList::AT_RequiresCapability;     // "requires_shared_capability"
    1285             :       }
    1286             :       break;
    1287             :     }
    1288             :     break;
    1289         203 :   case 27:       // 5 strings to match.
    1290         406 :     switch (Name[0]) {
    1291             :     default: break;
    1292         138 :     case 'a':    // 1 string to match.
    1293         138 :       if (memcmp(Name.data()+1, "mdgpu_flat_work_group_size", 26) != 0)
    1294             :         break;
    1295             :       return AttributeList::AT_AMDGPUFlatWorkGroupSize;  // "amdgpu_flat_work_group_size"
    1296          12 :     case 'd':    // 2 strings to match.
    1297          12 :       if (memcmp(Name.data()+1, "evice_builtin_", 14) != 0)
    1298             :         break;
    1299          24 :       switch (Name[15]) {
    1300             :       default: break;
    1301           6 :       case 's':  // 1 string to match.
    1302           6 :         if (memcmp(Name.data()+16, "urface_type", 11) != 0)
    1303             :           break;
    1304             :         return AttributeList::IgnoredAttribute;  // "device_builtin_surface_type"
    1305           6 :       case 't':  // 1 string to match.
    1306           6 :         if (memcmp(Name.data()+16, "exture_type", 11) != 0)
    1307             :           break;
    1308             :         return AttributeList::IgnoredAttribute;  // "device_builtin_texture_type"
    1309             :       }
    1310             :       break;
    1311          53 :     case 'o':    // 2 strings to match.
    1312          53 :       if (memcmp(Name.data()+1, "bjc_", 4) != 0)
    1313             :         break;
    1314         106 :       switch (Name[5]) {
    1315             :       default: break;
    1316          35 :       case 'd':  // 1 string to match.
    1317          35 :         if (memcmp(Name.data()+6, "esignated_initializer", 21) != 0)
    1318             :           break;
    1319             :         return AttributeList::AT_ObjCDesignatedInitializer;      // "objc_designated_initializer"
    1320          18 :       case 's':  // 1 string to match.
    1321          18 :         if (memcmp(Name.data()+6, "ubclassing_restricted", 21) != 0)
    1322             :           break;
    1323             :         return AttributeList::AT_ObjCSubclassingRestricted;      // "objc_subclassing_restricted"
    1324             :       }
    1325             :       break;
    1326             :     }
    1327             :     break;
    1328           2 :   case 28:       // 1 string to match.
    1329           2 :     if (memcmp(Name.data()+0, "consumable_set_state_on_read", 28) != 0)
    1330             :       break;
    1331             :     return AttributeList::AT_ConsumableSetOnRead;        // "consumable_set_state_on_read"
    1332           6 :   case 29:       // 1 string to match.
    1333           6 :     if (memcmp(Name.data()+0, "try_acquire_shared_capability", 29) != 0)
    1334             :       break;
    1335             :     return AttributeList::AT_TryAcquireCapability;       // "try_acquire_shared_capability"
    1336         168 :   case 31:       // 1 string to match.
    1337         168 :     if (memcmp(Name.data()+0, "require_constant_initialization", 31) != 0)
    1338             :       break;
    1339             :     return AttributeList::AT_RequireConstantInit;        // "require_constant_initialization"
    1340          12 :   case 34:       // 1 string to match.
    1341          12 :     if (memcmp(Name.data()+0, "objc_requires_property_definitions", 34) != 0)
    1342             :       break;
    1343             :     return AttributeList::AT_ObjCRequiresPropertyDefs;   // "objc_requires_property_definitions"
    1344          39 :   case 35:       // 1 string to match.
    1345          39 :     if (memcmp(Name.data()+0, "objc_arc_weak_reference_unavailable", 35) != 0)
    1346             :       break;
    1347             :     return AttributeList::AT_ArcWeakrefUnavailable;      // "objc_arc_weak_reference_unavailable"
    1348          12 :   case 46:       // 1 string to match.
    1349          12 :     if (memcmp(Name.data()+0, "objc_protocol_requires_explicit_implementation", 46) != 0)
    1350             :       break;
    1351             :     return AttributeList::AT_ObjCExplicitProtocolImpl;   // "objc_protocol_requires_explicit_implementation"
    1352             :   }
    1353       41369 :   } else if (AttributeList::AS_Declspec == Syntax) {
    1354        7233 :   switch (Name.size()) {
    1355             :   default: break;
    1356          62 :   case 4:        // 1 string to match.
    1357          62 :     if (memcmp(Name.data()+0, "uuid", 4) != 0)
    1358             :       break;
    1359             :     return AttributeList::AT_Uuid;       // "uuid"
    1360         224 :   case 5:        // 2 strings to match.
    1361         448 :     switch (Name[0]) {
    1362             :     default: break;
    1363         215 :     case 'a':    // 1 string to match.
    1364         215 :       if (memcmp(Name.data()+1, "lign", 4) != 0)
    1365             :         break;
    1366             :       return AttributeList::AT_Aligned;  // "align"
    1367           9 :     case 'n':    // 1 string to match.
    1368           9 :       if (memcmp(Name.data()+1, "aked", 4) != 0)
    1369             :         break;
    1370             :       return AttributeList::AT_Naked;    // "naked"
    1371             :     }
    1372             :     break;
    1373          55 :   case 6:        // 1 string to match.
    1374          55 :     if (memcmp(Name.data()+0, "thread", 6) != 0)
    1375             :       break;
    1376             :     return AttributeList::AT_Thread;     // "thread"
    1377           7 :   case 7:        // 2 strings to match.
    1378           7 :     if (memcmp(Name.data()+0, "no", 2) != 0)
    1379             :       break;
    1380           6 :     switch (Name[2]) {
    1381             :     default: break;
    1382           2 :     case 'a':    // 1 string to match.
    1383           2 :       if (memcmp(Name.data()+3, "lias", 4) != 0)
    1384             :         break;
    1385             :       return AttributeList::AT_NoAlias;  // "noalias"
    1386           1 :     case 't':    // 1 string to match.
    1387           1 :       if (memcmp(Name.data()+3, "hrow", 4) != 0)
    1388             :         break;
    1389             :       return AttributeList::AT_NoThrow;  // "nothrow"
    1390             :     }
    1391             :     break;
    1392         170 :   case 8:        // 7 strings to match.
    1393         340 :     switch (Name[0]) {
    1394             :     default: break;
    1395           3 :     case '_':    // 1 string to match.
    1396           3 :       if (memcmp(Name.data()+1, "_host__", 7) != 0)
    1397             :         break;
    1398             :       return AttributeList::AT_CUDAHost;         // "__host__"
    1399           8 :     case 'a':    // 1 string to match.
    1400           8 :       if (memcmp(Name.data()+1, "llocate", 7) != 0)
    1401             :         break;
    1402             :       return AttributeList::AT_Section;  // "allocate"
    1403          59 :     case 'n':    // 3 strings to match.
    1404         118 :       if (Name[1] != 'o')
    1405             :         break;
    1406         118 :       switch (Name[2]) {
    1407             :       default: break;
    1408          31 :       case 'i':  // 1 string to match.
    1409          31 :         if (memcmp(Name.data()+3, "nline", 5) != 0)
    1410             :           break;
    1411             :         return AttributeList::AT_NoInline;       // "noinline"
    1412          16 :       case 'r':  // 1 string to match.
    1413          16 :         if (memcmp(Name.data()+3, "eturn", 5) != 0)
    1414             :           break;
    1415             :         return AttributeList::AT_NoReturn;       // "noreturn"
    1416          12 :       case 'v':  // 1 string to match.
    1417          12 :         if (memcmp(Name.data()+3, "table", 5) != 0)
    1418             :           break;
    1419             :         return AttributeList::AT_MSNoVTable;     // "novtable"
    1420             :       }
    1421             :       break;
    1422          99 :     case 'p':    // 1 string to match.
    1423          99 :       if (memcmp(Name.data()+1, "roperty", 7) != 0)
    1424             :         break;
    1425             :       return AttributeList::IgnoredAttribute;    // "property"
    1426           1 :     case 'r':    // 1 string to match.
    1427           1 :       if (memcmp(Name.data()+1, "estrict", 7) != 0)
    1428             :         break;
    1429             :       return AttributeList::AT_Restrict;         // "restrict"
    1430             :     }
    1431             :     break;
    1432        6635 :   case 9:        // 3 strings to match.
    1433       13270 :     switch (Name[0]) {
    1434             :     default: break;
    1435        6605 :     case 'd':    // 2 strings to match.
    1436        6605 :       if (memcmp(Name.data()+1, "ll", 2) != 0)
    1437             :         break;
    1438       13210 :       switch (Name[3]) {
    1439             :       default: break;
    1440        3059 :       case 'e':  // 1 string to match.
    1441        3059 :         if (memcmp(Name.data()+4, "xport", 5) != 0)
    1442             :           break;
    1443             :         return AttributeList::AT_DLLExport;      // "dllexport"
    1444        3546 :       case 'i':  // 1 string to match.
    1445        3546 :         if (memcmp(Name.data()+4, "mport", 5) != 0)
    1446             :           break;
    1447             :         return AttributeList::AT_DLLImport;      // "dllimport"
    1448             :       }
    1449             :       break;
    1450          26 :     case 's':    // 1 string to match.
    1451          26 :       if (memcmp(Name.data()+1, "electany", 8) != 0)
    1452             :         break;
    1453             :       return AttributeList::AT_SelectAny;        // "selectany"
    1454             :     }
    1455             :     break;
    1456          32 :   case 10:       // 4 strings to match.
    1457          64 :     switch (Name[0]) {
    1458             :     default: break;
    1459           9 :     case '_':    // 3 strings to match.
    1460          18 :       if (Name[1] != '_')
    1461             :         break;
    1462          18 :       switch (Name[2]) {
    1463             :       default: break;
    1464           3 :       case 'd':  // 1 string to match.
    1465           3 :         if (memcmp(Name.data()+3, "evice__", 7) != 0)
    1466             :           break;
    1467             :         return AttributeList::AT_CUDADevice;     // "__device__"
    1468           3 :       case 'g':  // 1 string to match.
    1469           3 :         if (memcmp(Name.data()+3, "lobal__", 7) != 0)
    1470             :           break;
    1471             :         return AttributeList::AT_CUDAGlobal;     // "__global__"
    1472           3 :       case 's':  // 1 string to match.
    1473           3 :         if (memcmp(Name.data()+3, "hared__", 7) != 0)
    1474             :           break;
    1475             :         return AttributeList::AT_CUDAShared;     // "__shared__"
    1476             :       }
    1477             :       break;
    1478          23 :     case 'd':    // 1 string to match.
    1479          23 :       if (memcmp(Name.data()+1, "eprecated", 9) != 0)
    1480             :         break;
    1481             :       return AttributeList::AT_Deprecated;       // "deprecated"
    1482             :     }
    1483             :     break;
    1484          15 :   case 11:       // 1 string to match.
    1485          15 :     if (memcmp(Name.data()+0, "empty_bases", 11) != 0)
    1486             :       break;
    1487             :     return AttributeList::AT_EmptyBases;         // "empty_bases"
    1488           4 :   case 12:       // 1 string to match.
    1489           4 :     if (memcmp(Name.data()+0, "__constant__", 12) != 0)
    1490             :       break;
    1491             :     return AttributeList::AT_CUDAConstant;       // "__constant__"
    1492           8 :   case 14:       // 1 string to match.
    1493           8 :     if (memcmp(Name.data()+0, "layout_version", 14) != 0)
    1494             :       break;
    1495             :     return AttributeList::AT_LayoutVersion;      // "layout_version"
    1496           0 :   case 17:       // 1 string to match.
    1497           0 :     if (memcmp(Name.data()+0, "__launch_bounds__", 17) != 0)
    1498             :       break;
    1499             :     return AttributeList::AT_CUDALaunchBounds;   // "__launch_bounds__"
    1500          15 :   case 18:       // 2 strings to match.
    1501          15 :     if (memcmp(Name.data()+0, "__", 2) != 0)
    1502             :       break;
    1503          30 :     switch (Name[2]) {
    1504             :     default: break;
    1505           3 :     case 'c':    // 1 string to match.
    1506           3 :       if (memcmp(Name.data()+3, "udart_builtin__", 15) != 0)
    1507             :         break;
    1508             :       return AttributeList::IgnoredAttribute;    // "__cudart_builtin__"
    1509          12 :     case 'd':    // 1 string to match.
    1510          12 :       if (memcmp(Name.data()+3, "evice_builtin__", 15) != 0)
    1511             :         break;
    1512             :       return AttributeList::IgnoredAttribute;    // "__device_builtin__"
    1513             :     }
    1514             :     break;
    1515           6 :   case 31:       // 2 strings to match.
    1516           6 :     if (memcmp(Name.data()+0, "__device_builtin_", 17) != 0)
    1517             :       break;
    1518          12 :     switch (Name[17]) {
    1519             :     default: break;
    1520           3 :     case 's':    // 1 string to match.
    1521           3 :       if (memcmp(Name.data()+18, "urface_type__", 13) != 0)
    1522             :         break;
    1523             :       return AttributeList::IgnoredAttribute;    // "__device_builtin_surface_type__"
    1524           3 :     case 't':    // 1 string to match.
    1525           3 :       if (memcmp(Name.data()+18, "exture_type__", 13) != 0)
    1526             :         break;
    1527             :       return AttributeList::IgnoredAttribute;    // "__device_builtin_texture_type__"
    1528             :     }
    1529             :     break;
    1530             :   }
    1531       34136 :   } else if (AttributeList::AS_Microsoft == Syntax) {
    1532          40 :   switch (Name.size()) {
    1533             :   default: break;
    1534          40 :   case 4:        // 1 string to match.
    1535          40 :     if (memcmp(Name.data()+0, "uuid", 4) != 0)
    1536             :       break;
    1537             :     return AttributeList::AT_Uuid;       // "uuid"
    1538             :   }
    1539       34096 :   } else if (AttributeList::AS_CXX11 == Syntax) {
    1540        1463 :   switch (Name.size()) {
    1541             :   default: break;
    1542          12 :   case 8:        // 3 strings to match.
    1543          12 :     if (memcmp(Name.data()+0, "gnu::", 5) != 0)
    1544             :       break;
    1545           0 :     switch (Name[5]) {
    1546             :     default: break;
    1547           0 :     case 'f':    // 1 string to match.
    1548           0 :       if (memcmp(Name.data()+6, "ar", 2) != 0)
    1549             :         break;
    1550             :       return AttributeList::AT_MipsLongCall;     // "gnu::far"
    1551           0 :     case 'h':    // 1 string to match.
    1552           0 :       if (memcmp(Name.data()+6, "ot", 2) != 0)
    1553             :         break;
    1554             :       return AttributeList::AT_Hot;      // "gnu::hot"
    1555           0 :     case 'p':    // 1 string to match.
    1556           0 :       if (memcmp(Name.data()+6, "cs", 2) != 0)
    1557             :         break;
    1558             :       return AttributeList::AT_Pcs;      // "gnu::pcs"
    1559             :     }
    1560             :     break;
    1561          32 :   case 9:        // 6 strings to match.
    1562          32 :     if (memcmp(Name.data()+0, "gnu::", 5) != 0)
    1563             :       break;
    1564          20 :     switch (Name[5]) {
    1565             :     default: break;
    1566           0 :     case 'c':    // 1 string to match.
    1567           0 :       if (memcmp(Name.data()+6, "old", 3) != 0)
    1568             :         break;
    1569             :       return AttributeList::AT_Cold;     // "gnu::cold"
    1570           4 :     case 'm':    // 1 string to match.
    1571           4 :       if (memcmp(Name.data()+6, "ode", 3) != 0)
    1572             :         break;
    1573             :       return AttributeList::AT_Mode;     // "gnu::mode"
    1574           0 :     case 'n':    // 1 string to match.
    1575           0 :       if (memcmp(Name.data()+6, "ear", 3) != 0)
    1576             :         break;
    1577             :       return AttributeList::AT_MipsShortCall;    // "gnu::near"
    1578           2 :     case 'p':    // 1 string to match.
    1579           2 :       if (memcmp(Name.data()+6, "ure", 3) != 0)
    1580             :         break;
    1581             :       return AttributeList::AT_Pure;     // "gnu::pure"
    1582           4 :     case 'u':    // 1 string to match.
    1583           4 :       if (memcmp(Name.data()+6, "sed", 3) != 0)
    1584             :         break;
    1585             :       return AttributeList::AT_Used;     // "gnu::used"
    1586           0 :     case 'w':    // 1 string to match.
    1587           0 :       if (memcmp(Name.data()+6, "eak", 3) != 0)
    1588             :         break;
    1589             :       return AttributeList::AT_Weak;     // "gnu::weak"
    1590             :     }
    1591             :     break;
    1592         441 :   case 10:       // 6 strings to match.
    1593         882 :     switch (Name[0]) {
    1594             :     default: break;
    1595         425 :     case ':':    // 1 string to match.
    1596         425 :       if (memcmp(Name.data()+1, ":noreturn", 9) != 0)
    1597             :         break;
    1598             :       return AttributeList::AT_CXX11NoReturn;    // "::noreturn"
    1599          16 :     case 'g':    // 5 strings to match.
    1600          16 :       if (memcmp(Name.data()+1, "nu::", 4) != 0)
    1601             :         break;
    1602          32 :       switch (Name[5]) {
    1603             :       default: break;
    1604           9 :       case 'a':  // 1 string to match.
    1605           9 :         if (memcmp(Name.data()+6, "lias", 4) != 0)
    1606             :           break;
    1607             :         return AttributeList::AT_Alias;  // "gnu::alias"
    1608           4 :       case 'c':  // 2 strings to match.
    1609           8 :         switch (Name[6]) {
    1610             :         default: break;
    1611           0 :         case 'd':        // 1 string to match.
    1612           0 :           if (memcmp(Name.data()+7, "ecl", 3) != 0)
    1613             :             break;
    1614             :           return AttributeList::AT_CDecl;        // "gnu::cdecl"
    1615           4 :         case 'o':        // 1 string to match.
    1616           4 :           if (memcmp(Name.data()+7, "nst", 3) != 0)
    1617             :             break;
    1618             :           return AttributeList::AT_Const;        // "gnu::const"
    1619             :         }
    1620             :         break;
    1621           0 :       case 'i':  // 1 string to match.
    1622           0 :         if (memcmp(Name.data()+6, "func", 4) != 0)
    1623             :           break;
    1624             :         return AttributeList::AT_IFunc;  // "gnu::ifunc"
    1625           3 :       case 'n':  // 1 string to match.
    1626           3 :         if (memcmp(Name.data()+6, "aked", 4) != 0)
    1627             :           break;
    1628             :         return AttributeList::AT_Naked;  // "gnu::naked"
    1629             :       }
    1630             :       break;
    1631             :     }
    1632             :     break;
    1633          59 :   case 11:       // 9 strings to match.
    1634         118 :     switch (Name[0]) {
    1635             :     default: break;
    1636          33 :     case ':':    // 1 string to match.
    1637          33 :       if (memcmp(Name.data()+1, ":nodiscard", 10) != 0)
    1638             :         break;
    1639             :       return AttributeList::AT_WarnUnusedResult;         // "::nodiscard"
    1640          24 :     case 'g':    // 8 strings to match.
    1641          24 :       if (memcmp(Name.data()+1, "nu::", 4) != 0)
    1642             :         break;
    1643          48 :       switch (Name[5]) {
    1644             :       default: break;
    1645           0 :       case 'c':  // 1 string to match.
    1646           0 :         if (memcmp(Name.data()+6, "ommon", 5) != 0)
    1647             :           break;
    1648             :         return AttributeList::AT_Common;         // "gnu::common"
    1649           4 :       case 'f':  // 1 string to match.
    1650           4 :         if (memcmp(Name.data()+6, "ormat", 5) != 0)
    1651             :           break;
    1652             :         return AttributeList::AT_Format;         // "gnu::format"
    1653           0 :       case 'm':  // 3 strings to match.
    1654           0 :         switch (Name[6]) {
    1655             :         default: break;
    1656           0 :         case 'a':        // 1 string to match.
    1657           0 :           if (memcmp(Name.data()+7, "lloc", 4) != 0)
    1658             :             break;
    1659             :           return AttributeList::AT_Restrict;     // "gnu::malloc"
    1660           0 :         case 'i':        // 1 string to match.
    1661           0 :           if (memcmp(Name.data()+7, "ps16", 4) != 0)
    1662             :             break;
    1663             :           return AttributeList::AT_Mips16;       // "gnu::mips16"
    1664           0 :         case 's':        // 1 string to match.
    1665           0 :           if (memcmp(Name.data()+7, "_abi", 4) != 0)
    1666             :             break;
    1667             :           return AttributeList::AT_MSABI;        // "gnu::ms_abi"
    1668             :         }
    1669             :         break;
    1670           2 :       case 'p':  // 1 string to match.
    1671           2 :         if (memcmp(Name.data()+6, "acked", 5) != 0)
    1672             :           break;
    1673             :         return AttributeList::AT_Packed;         // "gnu::packed"
    1674           0 :       case 't':  // 1 string to match.
    1675           0 :         if (memcmp(Name.data()+6, "arget", 5) != 0)
    1676             :           break;
    1677             :         return AttributeList::AT_Target;         // "gnu::target"
    1678          18 :       case 'u':  // 1 string to match.
    1679          18 :         if (memcmp(Name.data()+6, "nused", 5) != 0)
    1680             :           break;
    1681             :         return AttributeList::AT_Unused;         // "gnu::unused"
    1682             :       }
    1683             :       break;
    1684             :     }
    1685             :     break;
    1686         133 :   case 12:       // 14 strings to match.
    1687         266 :     switch (Name[0]) {
    1688             :     default: break;
    1689          65 :     case ':':    // 1 string to match.
    1690          65 :       if (memcmp(Name.data()+1, ":deprecated", 11) != 0)
    1691             :         break;
    1692             :       return AttributeList::AT_Deprecated;       // "::deprecated"
    1693          64 :     case 'g':    // 13 strings to match.
    1694          64 :       if (memcmp(Name.data()+1, "nu::", 4) != 0)
    1695             :         break;
    1696         128 :       switch (Name[5]) {
    1697             :       default: break;
    1698           2 :       case '_':  // 1 string to match.
    1699           2 :         if (memcmp(Name.data()+6, "_const", 6) != 0)
    1700             :           break;
    1701             :         return AttributeList::AT_Const;  // "gnu::__const"
    1702          31 :       case 'a':  // 2 strings to match.
    1703          62 :         switch (Name[6]) {
    1704             :         default: break;
    1705           4 :         case 'b':        // 1 string to match.
    1706           4 :           if (memcmp(Name.data()+7, "i_tag", 5) != 0)
    1707             :             break;
    1708             :           return AttributeList::AT_AbiTag;       // "gnu::abi_tag"
    1709          27 :         case 'l':        // 1 string to match.
    1710          27 :           if (memcmp(Name.data()+7, "igned", 5) != 0)
    1711             :             break;
    1712             :           return AttributeList::AT_Aligned;      // "gnu::aligned"
    1713             :         }
    1714             :         break;
    1715           4 :       case 'c':  // 1 string to match.
    1716           4 :         if (memcmp(Name.data()+6, "leanup", 6) != 0)
    1717             :           break;
    1718             :         return AttributeList::AT_Cleanup;        // "gnu::cleanup"
    1719          19 :       case 'f':  // 1 string to match.
    1720          19 :         if (memcmp(Name.data()+6, "latten", 6) != 0)
    1721             :           break;
    1722             :         return AttributeList::AT_Flatten;        // "gnu::flatten"
    1723           4 :       case 'n':  // 3 strings to match.
    1724           8 :         if (Name[6] != 'o')
    1725             :           break;
    1726           8 :         switch (Name[7]) {
    1727             :         default: break;
    1728           2 :         case 'd':        // 1 string to match.
    1729           2 :           if (memcmp(Name.data()+8, "ebug", 4) != 0)
    1730             :             break;
    1731             :           return AttributeList::AT_NoDebug;      // "gnu::nodebug"
    1732           2 :         case 'n':        // 1 string to match.
    1733           2 :           if (memcmp(Name.data()+8, "null", 4) != 0)
    1734             :             break;
    1735             :           return AttributeList::AT_NonNull;      // "gnu::nonnull"
    1736           0 :         case 't':        // 1 string to match.
    1737           0 :           if (memcmp(Name.data()+8, "hrow", 4) != 0)
    1738             :             break;
    1739             :           return AttributeList::AT_NoThrow;      // "gnu::nothrow"
    1740             :         }
    1741             :         break;
    1742           0 :       case 'r':  // 2 strings to match.
    1743           0 :         if (memcmp(Name.data()+6, "eg", 2) != 0)
    1744             :           break;
    1745           0 :         switch (Name[8]) {
    1746             :         default: break;
    1747           0 :         case 'c':        // 1 string to match.
    1748           0 :           if (memcmp(Name.data()+9, "all", 3) != 0)
    1749             :             break;
    1750             :           return AttributeList::AT_RegCall;      // "gnu::regcall"
    1751           0 :         case 'p':        // 1 string to match.
    1752           0 :           if (memcmp(Name.data()+9, "arm", 3) != 0)
    1753             :             break;
    1754             :           return AttributeList::AT_Regparm;      // "gnu::regparm"
    1755             :         }
    1756             :         break;
    1757           4 :       case 's':  // 2 strings to match.
    1758           8 :         switch (Name[6]) {
    1759             :         default: break;
    1760           0 :         case 'e':        // 1 string to match.
    1761           0 :           if (memcmp(Name.data()+7, "ction", 5) != 0)
    1762             :             break;
    1763             :           return AttributeList::AT_Section;      // "gnu::section"
    1764           4 :         case 't':        // 1 string to match.
    1765           4 :           if (memcmp(Name.data()+7, "dcall", 5) != 0)
    1766             :             break;
    1767             :           return AttributeList::AT_StdCall;      // "gnu::stdcall"
    1768             :         }
    1769             :         break;
    1770           0 :       case 'w':  // 1 string to match.
    1771           0 :         if (memcmp(Name.data()+6, "eakref", 6) != 0)
    1772             :           break;
    1773             :         return AttributeList::AT_WeakRef;        // "gnu::weakref"
    1774             :       }
    1775             :       break;
    1776             :     }
    1777             :     break;
    1778         133 :   case 13:       // 10 strings to match.
    1779         266 :     switch (Name[0]) {
    1780             :     default: break;
    1781          57 :     case ':':    // 1 string to match.
    1782          57 :       if (memcmp(Name.data()+1, ":fallthrough", 12) != 0)
    1783             :         break;
    1784             :       return AttributeList::AT_FallThrough;      // "::fallthrough"
    1785          76 :     case 'g':    // 9 strings to match.
    1786         152 :       switch (Name[1]) {
    1787             :       default: break;
    1788          40 :       case 'n':  // 8 strings to match.
    1789          40 :         if (memcmp(Name.data()+2, "u::", 3) != 0)
    1790             :           break;
    1791          80 :         switch (Name[5]) {
    1792             :         default: break;
    1793          10 :         case 'f':        // 1 string to match.
    1794          10 :           if (memcmp(Name.data()+6, "astcall", 7) != 0)
    1795             :             break;
    1796             :           return AttributeList::AT_FastCall;     // "gnu::fastcall"
    1797          30 :         case 'n':        // 4 strings to match.
    1798          60 :           if (Name[6] != 'o')
    1799             :             break;
    1800          60 :           switch (Name[7]) {
    1801             :           default: break;
    1802           0 :           case 'c':      // 1 string to match.
    1803           0 :             if (memcmp(Name.data()+8, "ommon", 5) != 0)
    1804             :               break;
    1805             :             return AttributeList::AT_NoCommon;   // "gnu::nocommon"
    1806           0 :           case 'i':      // 1 string to match.
    1807           0 :             if (memcmp(Name.data()+8, "nline", 5) != 0)
    1808             :               break;
    1809             :             return AttributeList::AT_NoInline;   // "gnu::noinline"
    1810           0 :           case 'm':      // 1 string to match.
    1811           0 :             if (memcmp(Name.data()+8, "ips16", 5) != 0)
    1812             :               break;
    1813             :             return AttributeList::AT_NoMips16;   // "gnu::nomips16"
    1814          30 :           case 'r':      // 1 string to match.
    1815          30 :             if (memcmp(Name.data()+8, "eturn", 5) != 0)
    1816             :               break;
    1817             :             return AttributeList::AT_NoReturn;   // "gnu::noreturn"
    1818             :           }
    1819             :           break;
    1820           0 :         case 's':        // 2 strings to match.
    1821           0 :           switch (Name[6]) {
    1822             :           default: break;
    1823           0 :           case 'e':      // 1 string to match.
    1824           0 :             if (memcmp(Name.data()+7, "ntinel", 6) != 0)
    1825             :               break;
    1826             :             return AttributeList::AT_Sentinel;   // "gnu::sentinel"
    1827           0 :           case 'y':      // 1 string to match.
    1828           0 :             if (memcmp(Name.data()+7, "sv_abi", 6) != 0)
    1829             :               break;
    1830             :             return AttributeList::AT_SysVABI;    // "gnu::sysv_abi"
    1831             :           }
    1832             :           break;
    1833           0 :         case 't':        // 1 string to match.
    1834           0 :           if (memcmp(Name.data()+6, "hiscall", 7) != 0)
    1835             :             break;
    1836             :           return AttributeList::AT_ThisCall;     // "gnu::thiscall"
    1837             :         }
    1838             :         break;
    1839          36 :       case 's':  // 1 string to match.
    1840          36 :         if (memcmp(Name.data()+2, "l::suppress", 11) != 0)
    1841             :           break;
    1842             :         return AttributeList::AT_Suppress;       // "gsl::suppress"
    1843             :       }
    1844             :       break;
    1845             :     }
    1846             :     break;
    1847          64 :   case 14:       // 11 strings to match.
    1848         128 :     switch (Name[0]) {
    1849             :     default: break;
    1850          45 :     case ':':    // 1 string to match.
    1851          45 :       if (memcmp(Name.data()+1, ":maybe_unused", 13) != 0)
    1852             :         break;
    1853             :       return AttributeList::AT_Unused;   // "::maybe_unused"
    1854          16 :     case 'c':    // 1 string to match.
    1855          16 :       if (memcmp(Name.data()+1, "lang::optnone", 13) != 0)
    1856             :         break;
    1857             :       return AttributeList::AT_OptimizeNone;     // "clang::optnone"
    1858           3 :     case 'g':    // 9 strings to match.
    1859           3 :       if (memcmp(Name.data()+1, "nu::", 4) != 0)
    1860             :         break;
    1861           6 :       switch (Name[5]) {
    1862             :       default: break;
    1863           0 :       case 'd':  // 2 strings to match.
    1864           0 :         if (memcmp(Name.data()+6, "ll", 2) != 0)
    1865             :           break;
    1866           0 :         switch (Name[8]) {
    1867             :         default: break;
    1868           0 :         case 'e':        // 1 string to match.
    1869           0 :           if (memcmp(Name.data()+9, "xport", 5) != 0)
    1870             :             break;
    1871             :           return AttributeList::AT_DLLExport;    // "gnu::dllexport"
    1872           0 :         case 'i':        // 1 string to match.
    1873           0 :           if (memcmp(Name.data()+9, "mport", 5) != 0)
    1874             :             break;
    1875             :           return AttributeList::AT_DLLImport;    // "gnu::dllimport"
    1876             :         }
    1877             :         break;
    1878           0 :       case 'l':  // 1 string to match.
    1879           0 :         if (memcmp(Name.data()+6, "ong_call", 8) != 0)
    1880             :           break;
    1881             :         return AttributeList::AT_MipsLongCall;   // "gnu::long_call"
    1882           0 :       case 'm':  // 3 strings to match.
    1883           0 :         switch (Name[6]) {
    1884             :         default: break;
    1885           0 :         case 'a':        // 1 string to match.
    1886           0 :           if (memcmp(Name.data()+7, "y_alias", 7) != 0)
    1887             :             break;
    1888             :           return AttributeList::AT_MayAlias;     // "gnu::may_alias"
    1889           0 :         case 'i':        // 1 string to match.
    1890           0 :           if (memcmp(Name.data()+7, "cromips", 7) != 0)
    1891             :             break;
    1892             :           return AttributeList::AT_MicroMips;    // "gnu::micromips"
    1893           0 :         case 's':        // 1 string to match.
    1894           0 :           if (memcmp(Name.data()+7, "_struct", 7) != 0)
    1895             :             break;
    1896             :           return AttributeList::AT_MSStruct;     // "gnu::ms_struct"
    1897             :         }
    1898             :         break;
    1899           0 :       case 's':  // 2 strings to match.
    1900           0 :         switch (Name[6]) {
    1901             :         default: break;
    1902           0 :         case 'e':        // 1 string to match.
    1903           0 :           if (memcmp(Name.data()+7, "lectany", 7) != 0)
    1904             :             break;
    1905             :           return AttributeList::AT_SelectAny;    // "gnu::selectany"
    1906           0 :         case 'w':        // 1 string to match.
    1907           0 :           if (memcmp(Name.data()+7, "iftcall", 7) != 0)
    1908             :             break;
    1909             :           return AttributeList::AT_SwiftCall;    // "gnu::swiftcall"
    1910             :         }
    1911             :         break;
    1912           3 :       case 't':  // 1 string to match.
    1913           3 :         if (memcmp(Name.data()+6, "ls_model", 8) != 0)
    1914             :           break;
    1915             :         return AttributeList::AT_TLSModel;       // "gnu::tls_model"
    1916             :       }
    1917             :       break;
    1918             :     }
    1919             :     break;
    1920          35 :   case 15:       // 7 strings to match.
    1921          35 :     if (memcmp(Name.data()+0, "gnu::", 5) != 0)
    1922             :       break;
    1923          50 :     switch (Name[5]) {
    1924             :     default: break;
    1925           0 :     case 'a':    // 1 string to match.
    1926           0 :       if (memcmp(Name.data()+6, "lloc_size", 9) != 0)
    1927             :         break;
    1928             :       return AttributeList::AT_AllocSize;        // "gnu::alloc_size"
    1929          20 :     case 'd':    // 2 strings to match.
    1930          40 :       if (Name[6] != 'e')
    1931             :         break;
    1932          40 :       switch (Name[7]) {
    1933             :       default: break;
    1934          20 :       case 'p':  // 1 string to match.
    1935          20 :         if (memcmp(Name.data()+8, "recated", 7) != 0)
    1936             :           break;
    1937             :         return AttributeList::AT_Deprecated;     // "gnu::deprecated"
    1938           0 :       case 's':  // 1 string to match.
    1939           0 :         if (memcmp(Name.data()+8, "tructor", 7) != 0)
    1940             :           break;
    1941             :         return AttributeList::AT_Destructor;     // "gnu::destructor"
    1942             :       }
    1943             :       break;
    1944           0 :     case 'f':    // 1 string to match.
    1945           0 :       if (memcmp(Name.data()+6, "ormat_arg", 9) != 0)
    1946             :         break;
    1947             :       return AttributeList::AT_FormatArg;        // "gnu::format_arg"
    1948           2 :     case 'g':    // 1 string to match.
    1949           2 :       if (memcmp(Name.data()+6, "nu_inline", 9) != 0)
    1950             :         break;
    1951             :       return AttributeList::AT_GNUInline;        // "gnu::gnu_inline"
    1952           0 :     case 's':    // 1 string to match.
    1953           0 :       if (memcmp(Name.data()+6, "hort_call", 9) != 0)
    1954             :         break;
    1955             :       return AttributeList::AT_MipsShortCall;    // "gnu::short_call"
    1956           3 :     case 'v':    // 1 string to match.
    1957           3 :       if (memcmp(Name.data()+6, "isibility", 9) != 0)
    1958             :         break;
    1959             :       return AttributeList::AT_Visibility;       // "gnu::visibility"
    1960             :     }
    1961             :     break;
    1962          27 :   case 16:       // 4 strings to match.
    1963          27 :     if (memcmp(Name.data()+0, "gnu::", 5) != 0)
    1964             :       break;
    1965           6 :     switch (Name[5]) {
    1966             :     default: break;
    1967           0 :     case 'a':    // 1 string to match.
    1968           0 :       if (memcmp(Name.data()+6, "lloc_align", 10) != 0)
    1969             :         break;
    1970             :       return AttributeList::AT_AllocAlign;       // "gnu::alloc_align"
    1971           0 :     case 'c':    // 1 string to match.
    1972           0 :       if (memcmp(Name.data()+6, "onstructor", 10) != 0)
    1973             :         break;
    1974             :       return AttributeList::AT_Constructor;      // "gnu::constructor"
    1975           0 :     case 'n':    // 1 string to match.
    1976           0 :       if (memcmp(Name.data()+6, "omicromips", 10) != 0)
    1977             :         break;
    1978             :       return AttributeList::AT_NoMicroMips;      // "gnu::nomicromips"
    1979           3 :     case 'v':    // 1 string to match.
    1980           3 :       if (memcmp(Name.data()+6, "ector_size", 10) != 0)
    1981             :         break;
    1982             :       return AttributeList::AT_VectorSize;       // "gnu::vector_size"
    1983             :     }
    1984             :     break;
    1985           0 :   case 17:       // 2 strings to match.
    1986           0 :     if (memcmp(Name.data()+0, "clang::c", 8) != 0)
    1987             :       break;
    1988           0 :     switch (Name[8]) {
    1989             :     default: break;
    1990           0 :     case 'a':    // 1 string to match.
    1991           0 :       if (memcmp(Name.data()+9, "pability", 8) != 0)
    1992             :         break;
    1993             :       return AttributeList::AT_Capability;       // "clang::capability"
    1994           0 :     case 'o':    // 1 string to match.
    1995           0 :       if (memcmp(Name.data()+9, "nvergent", 8) != 0)
    1996             :         break;
    1997             :       return AttributeList::AT_Convergent;       // "clang::convergent"
    1998             :     }
    1999             :     break;
    2000          94 :   case 18:       // 6 strings to match.
    2001         188 :     switch (Name[0]) {
    2002             :     default: break;
    2003          92 :     case 'c':    // 3 strings to match.
    2004          92 :       if (memcmp(Name.data()+1, "lang::", 6) != 0)
    2005             :         break;
    2006         184 :       switch (Name[7]) {
    2007             :       default: break;
    2008          76 :       case 'f':  // 1 string to match.
    2009          76 :         if (memcmp(Name.data()+8, "allthrough", 10) != 0)
    2010             :           break;
    2011             :         return AttributeList::AT_FallThrough;    // "clang::fallthrough"
    2012          16 :       case 'n':  // 2 strings to match.
    2013          32 :         if (Name[8] != 'o')
    2014             :           break;
    2015          32 :         switch (Name[9]) {
    2016             :         default: break;
    2017          12 :         case '_':        // 1 string to match.
    2018          12 :           if (memcmp(Name.data()+10, "sanitize", 8) != 0)
    2019             :             break;
    2020             :           return AttributeList::AT_NoSanitize;   // "clang::no_sanitize"
    2021           4 :         case 'd':        // 1 string to match.
    2022           4 :           if (memcmp(Name.data()+10, "uplicate", 8) != 0)
    2023             :             break;
    2024             :           return AttributeList::AT_NoDuplicate;  // "clang::noduplicate"
    2025             :         }
    2026             :         break;
    2027             :       }
    2028             :       break;
    2029           2 :     case 'g':    // 3 strings to match.
    2030           2 :       if (memcmp(Name.data()+1, "nu::", 4) != 0)
    2031             :         break;
    2032           4 :       switch (Name[5]) {
    2033             :       default: break;
    2034           2 :       case 'a':  // 1 string to match.
    2035           2 :         if (memcmp(Name.data()+6, "lways_inline", 12) != 0)
    2036             :           break;
    2037             :         return AttributeList::AT_AlwaysInline;   // "gnu::always_inline"
    2038           0 :       case 'r':  // 1 string to match.
    2039           0 :         if (memcmp(Name.data()+6, "eturns_twice", 12) != 0)
    2040             :           break;
    2041             :         return AttributeList::AT_ReturnsTwice;   // "gnu::returns_twice"
    2042           0 :       case 's':  // 1 string to match.
    2043           0 :         if (memcmp(Name.data()+6, "wift_context", 12) != 0)
    2044             :           break;
    2045             :         return AttributeList::AT_SwiftContext;   // "gnu::swift_context"
    2046             :       }
    2047             :       break;
    2048             :     }
    2049             :     break;
    2050          59 :   case 19:       // 2 strings to match.
    2051          59 :     if (memcmp(Name.data()+0, "gnu::", 5) != 0)
    2052             :       break;
    2053          50 :     switch (Name[5]) {
    2054             :     default: break;
    2055           0 :     case 'a':    // 1 string to match.
    2056           0 :       if (memcmp(Name.data()+6, "ssume_aligned", 13) != 0)
    2057             :         break;
    2058             :       return AttributeList::AT_AssumeAligned;    // "gnu::assume_aligned"
    2059          25 :     case 'n':    // 1 string to match.
    2060          25 :       if (memcmp(Name.data()+6, "o_split_stack", 13) != 0)
    2061             :         break;
    2062             :       return AttributeList::AT_NoSplitStack;     // "gnu::no_split_stack"
    2063             :     }
    2064             :     break;
    2065         143 :   case 20:       // 3 strings to match.
    2066         286 :     switch (Name[0]) {
    2067             :     default: break;
    2068         103 :     case ':':    // 1 string to match.
    2069         103 :       if (memcmp(Name.data()+1, ":carries_dependency", 19) != 0)
    2070             :         break;
    2071             :       return AttributeList::AT_CarriesDependency;        // "::carries_dependency"
    2072          40 :     case 'c':    // 1 string to match.
    2073          40 :       if (memcmp(Name.data()+1, "lang::xray_log_args", 19) != 0)
    2074             :         break;
    2075             :       return AttributeList::AT_XRayLogArgs;      // "clang::xray_log_args"
    2076           0 :     case 'g':    // 1 string to match.
    2077           0 :       if (memcmp(Name.data()+1, "nu::returns_nonnull", 19) != 0)
    2078             :         break;
    2079             :       return AttributeList::AT_ReturnsNonNull;   // "gnu::returns_nonnull"
    2080             :     }
    2081             :     break;
    2082          10 :   case 22:       // 3 strings to match.
    2083          20 :     switch (Name[0]) {
    2084             :     default: break;
    2085          10 :     case 'c':    // 2 strings to match.
    2086          10 :       if (memcmp(Name.data()+1, "lang::", 6) != 0)
    2087             :         break;
    2088          20 :       switch (Name[7]) {
    2089             :       default: break;
    2090          10 :       case 'n':  // 1 string to match.
    2091          10 :         if (memcmp(Name.data()+8, "ot_tail_called", 14) != 0)
    2092             :           break;
    2093             :         return AttributeList::AT_NotTailCalled;  // "clang::not_tail_called"
    2094           0 :       case 't':  // 1 string to match.
    2095           0 :         if (memcmp(Name.data()+8, "ype_visibility", 14) != 0)
    2096             :           break;
    2097             :         return AttributeList::AT_TypeVisibility;         // "clang::type_visibility"
    2098             :       }
    2099             :       break;
    2100           0 :     case 'g':    // 1 string to match.
    2101           0 :       if (memcmp(Name.data()+1, "nu::transparent_union", 21) != 0)
    2102             :         break;
    2103             :       return AttributeList::AT_TransparentUnion;         // "gnu::transparent_union"
    2104             :     }
    2105             :     break;
    2106          14 :   case 23:       // 4 strings to match.
    2107          28 :     switch (Name[0]) {
    2108             :     default: break;
    2109          10 :     case 'c':    // 1 string to match.
    2110          10 :       if (memcmp(Name.data()+1, "lang::internal_linkage", 22) != 0)
    2111             :         break;
    2112             :       return AttributeList::AT_InternalLinkage;  // "clang::internal_linkage"
    2113           2 :     case 'g':    // 3 strings to match.
    2114           2 :       if (memcmp(Name.data()+1, "nu::", 4) != 0)
    2115             :         break;
    2116           4 :       switch (Name[5]) {
    2117             :       default: break;
    2118           0 :       case 'n':  // 1 string to match.
    2119           0 :         if (memcmp(Name.data()+6, "o_sanitize_thread", 17) != 0)
    2120             :           break;
    2121             :         return AttributeList::AT_NoSanitizeSpecific;     // "gnu::no_sanitize_thread"
    2122           0 :       case 's':  // 1 string to match.
    2123           0 :         if (memcmp(Name.data()+6, "wift_error_result", 17) != 0)
    2124             :           break;
    2125             :         return AttributeList::AT_SwiftErrorResult;       // "gnu::swift_error_result"
    2126           2 :       case 'w':  // 1 string to match.
    2127           2 :         if (memcmp(Name.data()+6, "arn_unused_result", 17) != 0)
    2128             :           break;
    2129             :         return AttributeList::AT_WarnUnusedResult;       // "gnu::warn_unused_result"
    2130             :       }
    2131             :       break;
    2132             :     }
    2133             :     break;
    2134          20 :   case 24:       // 3 strings to match.
    2135          40 :     switch (Name[0]) {
    2136             :     default: break;
    2137           0 :     case 'c':    // 2 strings to match.
    2138           0 :       if (memcmp(Name.data()+1, "lang::", 6) != 0)
    2139             :         break;
    2140           0 :       switch (Name[7]) {
    2141             :       default: break;
    2142           0 :       case 'a':  // 1 string to match.
    2143           0 :         if (memcmp(Name.data()+8, "ssert_capability", 16) != 0)
    2144             :           break;
    2145             :         return AttributeList::AT_AssertCapability;       // "clang::assert_capability"
    2146           0 :       case 's':  // 1 string to match.
    2147           0 :         if (memcmp(Name.data()+8, "hared_capability", 16) != 0)
    2148             :           break;
    2149             :         return AttributeList::AT_Capability;     // "clang::shared_capability"
    2150             :       }
    2151             :       break;
    2152          18 :     case 'g':    // 1 string to match.
    2153          18 :       if (memcmp(Name.data()+1, "nu::no_sanitize_address", 23) != 0)
    2154             :         break;
    2155             :       return AttributeList::AT_NoSanitizeSpecific;       // "gnu::no_sanitize_address"
    2156             :     }
    2157             :     break;
    2158          37 :   case 25:       // 5 strings to match.
    2159          37 :     if (memcmp(Name.data()+0, "clang::", 7) != 0)
    2160             :       break;
    2161          74 :     switch (Name[7]) {
    2162             :     default: break;
    2163           0 :     case 'a':    // 1 string to match.
    2164           0 :       if (memcmp(Name.data()+8, "cquire_capability", 17) != 0)
    2165             :         break;
    2166             :       return AttributeList::AT_AcquireCapability;        // "clang::acquire_capability"
    2167          18 :     case 'd':    // 1 string to match.
    2168          18 :       if (memcmp(Name.data()+8, "isable_tail_calls", 17) != 0)
    2169             :         break;
    2170             :       return AttributeList::AT_DisableTailCalls;         // "clang::disable_tail_calls"
    2171           5 :     case 'e':    // 1 string to match.
    2172           5 :       if (memcmp(Name.data()+8, "num_extensibility", 17) != 0)
    2173             :         break;
    2174             :       return AttributeList::AT_EnumExtensibility;        // "clang::enum_extensibility"
    2175           0 :     case 'r':    // 1 string to match.
    2176           0 :       if (memcmp(Name.data()+8, "elease_capability", 17) != 0)
    2177             :         break;
    2178             :       return AttributeList::AT_ReleaseCapability;        // "clang::release_capability"
    2179          14 :     case 'w':    // 1 string to match.
    2180          14 :       if (memcmp(Name.data()+8, "arn_unused_result", 17) != 0)
    2181             :         break;
    2182             :       return AttributeList::AT_WarnUnusedResult;         // "clang::warn_unused_result"
    2183             :     }
    2184             :     break;
    2185           0 :   case 26:       // 2 strings to match.
    2186           0 :     switch (Name[0]) {
    2187             :     default: break;
    2188           0 :     case 'c':    // 1 string to match.
    2189           0 :       if (memcmp(Name.data()+1, "lang::requires_capability", 25) != 0)
    2190             :         break;
    2191             :       return AttributeList::AT_RequiresCapability;       // "clang::requires_capability"
    2192           0 :     case 'g':    // 1 string to match.
    2193           0 :       if (memcmp(Name.data()+1, "nu::swift_indirect_result", 25) != 0)
    2194             :         break;
    2195             :       return AttributeList::AT_SwiftIndirectResult;      // "gnu::swift_indirect_result"
    2196             :     }
    2197             :     break;
    2198           0 :   case 27:       // 1 string to match.
    2199           0 :     if (memcmp(Name.data()+0, "gnu::no_instrument_function", 27) != 0)
    2200             :       break;
    2201             :     return AttributeList::AT_NoInstrumentFunction;       // "gnu::no_instrument_function"
    2202          44 :   case 28:       // 3 strings to match.
    2203          88 :     switch (Name[0]) {
    2204             :     default: break;
    2205          44 :     case 'c':    // 2 strings to match.
    2206          44 :       if (memcmp(Name.data()+1, "lang::", 6) != 0)
    2207             :         break;
    2208          88 :       switch (Name[7]) {
    2209             :       default: break;
    2210          24 :       case 'l':  // 1 string to match.
    2211          24 :         if (memcmp(Name.data()+8, "to_visibility_public", 20) != 0)
    2212             :           break;
    2213             :         return AttributeList::AT_LTOVisibilityPublic;    // "clang::lto_visibility_public"
    2214          20 :       case 'x':  // 1 string to match.
    2215          20 :         if (memcmp(Name.data()+8, "ray_never_instrument", 20) != 0)
    2216             :           break;
    2217             :         return AttributeList::AT_XRayInstrument;         // "clang::xray_never_instrument"
    2218             :       }
    2219             :       break;
    2220           0 :     case 'g':    // 1 string to match.
    2221           0 :       if (memcmp(Name.data()+1, "nu::force_align_arg_pointer", 27) != 0)
    2222             :         break;
    2223             :       return AttributeList::AT_X86ForceAlignArgPointer;  // "gnu::force_align_arg_pointer"
    2224             :     }
    2225             :     break;
    2226          36 :   case 29:       // 3 strings to match.
    2227          36 :     if (memcmp(Name.data()+0, "clang::", 7) != 0)
    2228             :       break;
    2229          72 :     switch (Name[7]) {
    2230             :     default: break;
    2231           4 :     case 'e':    // 1 string to match.
    2232           4 :       if (memcmp(Name.data()+8, "xternal_source_symbol", 21) != 0)
    2233             :         break;
    2234             :       return AttributeList::AT_ExternalSourceSymbol;     // "clang::external_source_symbol"
    2235           0 :     case 't':    // 1 string to match.
    2236           0 :       if (memcmp(Name.data()+8, "ry_acquire_capability", 21) != 0)
    2237             :         break;
    2238             :       return AttributeList::AT_TryAcquireCapability;     // "clang::try_acquire_capability"
    2239          32 :     case 'x':    // 1 string to match.
    2240          32 :       if (memcmp(Name.data()+8, "ray_always_instrument", 21) != 0)
    2241             :         break;
    2242             :       return AttributeList::AT_XRayInstrument;   // "clang::xray_always_instrument"
    2243             :     }
    2244             :     break;
    2245           4 :   case 30:       // 1 string to match.
    2246           4 :     if (memcmp(Name.data()+0, "gnu::no_caller_saved_registers", 30) != 0)
    2247             :       break;
    2248             :     return AttributeList::AT_AnyX86NoCallerSavedRegisters;       // "gnu::no_caller_saved_registers"
    2249           2 :   case 31:       // 2 strings to match.
    2250           4 :     switch (Name[0]) {
    2251             :     default: break;
    2252           0 :     case 'c':    // 1 string to match.
    2253           0 :       if (memcmp(Name.data()+1, "lang::assert_shared_capability", 30) != 0)
    2254             :         break;
    2255             :       return AttributeList::AT_AssertCapability;         // "clang::assert_shared_capability"
    2256           2 :     case 'g':    // 1 string to match.
    2257           2 :       if (memcmp(Name.data()+1, "nu::no_address_safety_analysis", 30) != 0)
    2258             :         break;
    2259             :       return AttributeList::AT_NoSanitizeSpecific;       // "gnu::no_address_safety_analysis"
    2260             :     }
    2261             :     break;
    2262           0 :   case 32:       // 2 strings to match.
    2263           0 :     if (memcmp(Name.data()+0, "clang::", 7) != 0)
    2264             :       break;
    2265           0 :     switch (Name[7]) {
    2266             :     default: break;
    2267           0 :     case 'a':    // 1 string to match.
    2268           0 :       if (memcmp(Name.data()+8, "cquire_shared_capability", 24) != 0)
    2269             :         break;
    2270             :       return AttributeList::AT_AcquireCapability;        // "clang::acquire_shared_capability"
    2271           0 :     case 'r':    // 1 string to match.
    2272           0 :       if (memcmp(Name.data()+8, "elease_shared_capability", 24) != 0)
    2273             :         break;
    2274             :       return AttributeList::AT_ReleaseCapability;        // "clang::release_shared_capability"
    2275             :     }
    2276             :     break;
    2277           0 :   case 33:       // 2 strings to match.
    2278           0 :     if (memcmp(Name.data()+0, "clang::re", 9) != 0)
    2279             :       break;
    2280           0 :     switch (Name[9]) {
    2281             :     default: break;
    2282           0 :     case 'l':    // 1 string to match.
    2283           0 :       if (memcmp(Name.data()+10, "ease_generic_capability", 23) != 0)
    2284             :         break;
    2285             :       return AttributeList::AT_ReleaseCapability;        // "clang::release_generic_capability"
    2286           0 :     case 'q':    // 1 string to match.
    2287           0 :       if (memcmp(Name.data()+10, "uires_shared_capability", 23) != 0)
    2288             :         break;
    2289             :       return AttributeList::AT_RequiresCapability;       // "clang::requires_shared_capability"
    2290             :     }
    2291             :     break;
    2292           0 :   case 36:       // 1 string to match.
    2293           0 :     if (memcmp(Name.data()+0, "clang::try_acquire_shared_capability", 36) != 0)
    2294             :       break;
    2295             :     return AttributeList::AT_TryAcquireCapability;       // "clang::try_acquire_shared_capability"
    2296           0 :   case 38:       // 1 string to match.
    2297           0 :     if (memcmp(Name.data()+0, "clang::require_constant_initialization", 38) != 0)
    2298             :       break;
    2299             :     return AttributeList::AT_RequireConstantInit;        // "clang::require_constant_initialization"
    2300             :   }
    2301       32633 :   } else if (AttributeList::AS_Keyword == Syntax || AttributeList::AS_ContextSensitiveKeyword == Syntax) {
    2302       32439 :   switch (Name.size()) {
    2303             :   default: break;
    2304         658 :   case 5:        // 2 strings to match.
    2305        1316 :     switch (Name[0]) {
    2306             :     default: break;
    2307           1 :     case '_':    // 1 string to match.
    2308           1 :       if (memcmp(Name.data()+1, "_w64", 4) != 0)
    2309             :         break;
    2310             :       return AttributeList::IgnoredAttribute;    // "__w64"
    2311         657 :     case 'l':    // 1 string to match.
    2312         657 :       if (memcmp(Name.data()+1, "ocal", 4) != 0)
    2313             :         break;
    2314             :       return AttributeList::AT_OpenCLLocalAddressSpace;  // "local"
    2315             :     }
    2316             :     break;
    2317        1009 :   case 6:        // 5 strings to match.
    2318        2018 :     switch (Name[0]) {
    2319             :     default: break;
    2320          26 :     case '_':    // 3 strings to match.
    2321          52 :       switch (Name[1]) {
    2322             :       default: break;
    2323          24 :       case '_':  // 2 strings to match.
    2324          48 :         switch (Name[2]) {
    2325             :         default: break;
    2326          16 :         case 's':        // 1 string to match.
    2327          16 :           if (memcmp(Name.data()+3, "ptr", 3) != 0)
    2328             :             break;
    2329             :           return AttributeList::AT_SPtr;         // "__sptr"
    2330           8 :         case 'u':        // 1 string to match.
    2331           8 :           if (memcmp(Name.data()+3, "ptr", 3) != 0)
    2332             :             break;
    2333             :           return AttributeList::AT_UPtr;         // "__uptr"
    2334             :         }
    2335             :         break;
    2336           2 :       case 'c':  // 1 string to match.
    2337           2 :         if (memcmp(Name.data()+2, "decl", 4) != 0)
    2338             :           break;
    2339             :         return AttributeList::AT_CDecl;  // "_cdecl"
    2340             :       }
    2341             :       break;
    2342         575 :     case 'g':    // 1 string to match.
    2343         575 :       if (memcmp(Name.data()+1, "lobal", 5) != 0)
    2344             :         break;
    2345             :       return AttributeList::AT_OpenCLGlobalAddressSpace;         // "global"
    2346         408 :     case 'k':    // 1 string to match.
    2347         408 :       if (memcmp(Name.data()+1, "ernel", 5) != 0)
    2348             :         break;
    2349             :       return AttributeList::AT_OpenCLKernel;     // "kernel"
    2350             :     }
    2351             :     break;
    2352        9342 :   case 7:        // 8 strings to match.
    2353       18684 :     switch (Name[0]) {
    2354             :     default: break;
    2355        8375 :     case '_':    // 5 strings to match.
    2356       16750 :       switch (Name[1]) {
    2357             :       default: break;
    2358        8373 :       case '_':  // 4 strings to match.
    2359       16746 :         switch (Name[2]) {
    2360             :         default: break;
    2361         229 :         case 'c':        // 1 string to match.
    2362         229 :           if (memcmp(Name.data()+3, "decl", 4) != 0)
    2363             :             break;
    2364             :           return AttributeList::AT_CDecl;        // "__cdecl"
    2365        8115 :         case 'l':        // 1 string to match.
    2366        8115 :           if (memcmp(Name.data()+3, "ocal", 4) != 0)
    2367             :             break;
    2368             :           return AttributeList::AT_OpenCLLocalAddressSpace;      // "__local"
    2369          29 :         case 'p':        // 2 strings to match.
    2370          29 :           if (memcmp(Name.data()+3, "tr", 2) != 0)
    2371             :             break;
    2372          58 :           switch (Name[5]) {
    2373             :           default: break;
    2374          21 :           case '3':      // 1 string to match.
    2375          42 :             if (Name[6] != '2')
    2376             :               break;
    2377             :             return AttributeList::AT_Ptr32;      // "__ptr32"
    2378           8 :           case '6':      // 1 string to match.
    2379          16 :             if (Name[6] != '4')
    2380             :               break;
    2381             :             return AttributeList::AT_Ptr64;      // "__ptr64"
    2382             :           }
    2383             :           break;
    2384             :         }
    2385             :         break;
    2386           2 :       case 'p':  // 1 string to match.
    2387           2 :         if (memcmp(Name.data()+2, "ascal", 5) != 0)
    2388             :           break;
    2389             :         return AttributeList::AT_Pascal;         // "_pascal"
    2390             :       }
    2391             :       break;
    2392         303 :     case 'a':    // 1 string to match.
    2393         303 :       if (memcmp(Name.data()+1, "lignas", 6) != 0)
    2394             :         break;
    2395             :       return AttributeList::AT_Aligned;  // "alignas"
    2396         277 :     case 'g':    // 1 string to match.
    2397         277 :       if (memcmp(Name.data()+1, "eneric", 6) != 0)
    2398             :         break;
    2399             :       return AttributeList::AT_OpenCLGenericAddressSpace;        // "generic"
    2400         387 :     case 'p':    // 1 string to match.
    2401         387 :       if (memcmp(Name.data()+1, "rivate", 6) != 0)
    2402             :         break;
    2403             :       return AttributeList::AT_OpenCLPrivateAddressSpace;        // "private"
    2404             :     }
    2405             :     break;
    2406       10772 :   case 8:        // 8 strings to match.
    2407       21544 :     switch (Name[0]) {
    2408             :     default: break;
    2409       10461 :     case '_':    // 7 strings to match.
    2410       20922 :       switch (Name[1]) {
    2411             :       default: break;
    2412          40 :       case 'A':  // 1 string to match.
    2413          40 :         if (memcmp(Name.data()+2, "lignas", 6) != 0)
    2414             :           break;
    2415             :         return AttributeList::AT_Aligned;        // "_Alignas"
    2416        1007 :       case 'N':  // 1 string to match.
    2417        1007 :         if (memcmp(Name.data()+2, "onnull", 6) != 0)
    2418             :           break;
    2419             :         return AttributeList::AT_TypeNonNull;    // "_Nonnull"
    2420        9412 :       case '_':  // 4 strings to match.
    2421       18824 :         switch (Name[2]) {
    2422             :         default: break;
    2423        9264 :         case 'g':        // 1 string to match.
    2424        9264 :           if (memcmp(Name.data()+3, "lobal", 5) != 0)
    2425             :             break;
    2426             :           return AttributeList::AT_OpenCLGlobalAddressSpace;     // "__global"
    2427         133 :         case 'k':        // 2 strings to match.
    2428         266 :           switch (Name[3]) {
    2429             :           default: break;
    2430          70 :           case 'e':      // 1 string to match.
    2431          70 :             if (memcmp(Name.data()+4, "rnel", 4) != 0)
    2432             :               break;
    2433             :             return AttributeList::AT_OpenCLKernel;       // "__kernel"
    2434          63 :           case 'i':      // 1 string to match.
    2435          63 :             if (memcmp(Name.data()+4, "ndof", 4) != 0)
    2436             :               break;
    2437             :             return AttributeList::AT_ObjCKindOf;         // "__kindof"
    2438             :           }
    2439             :           break;
    2440          15 :         case 'p':        // 1 string to match.
    2441          15 :           if (memcmp(Name.data()+3, "ascal", 5) != 0)
    2442             :             break;
    2443             :           return AttributeList::AT_Pascal;       // "__pascal"
    2444             :         }
    2445             :         break;
    2446           2 :       case 's':  // 1 string to match.
    2447           2 :         if (memcmp(Name.data()+2, "tdcall", 6) != 0)
    2448             :           break;
    2449             :         return AttributeList::AT_StdCall;        // "_stdcall"
    2450             :       }
    2451             :       break;
    2452         311 :     case 'c':    // 1 string to match.
    2453         311 :       if (memcmp(Name.data()+1, "onstant", 7) != 0)
    2454             :         break;
    2455             :       return AttributeList::AT_OpenCLConstantAddressSpace;       // "constant"
    2456             :     }
    2457             :     break;
    2458        5921 :   case 9:        // 8 strings to match.
    2459       11842 :     switch (Name[0]) {
    2460             :     default: break;
    2461        3404 :     case '_':    // 7 strings to match.
    2462        6808 :       switch (Name[1]) {
    2463             :       default: break;
    2464         663 :       case 'N':  // 1 string to match.
    2465         663 :         if (memcmp(Name.data()+2, "ullable", 7) != 0)
    2466             :           break;
    2467             :         return AttributeList::AT_TypeNullable;   // "_Nullable"
    2468        2739 :       case '_':  // 4 strings to match.
    2469        5478 :         switch (Name[2]) {
    2470             :         default: break;
    2471           3 :         case 'g':        // 1 string to match.
    2472           3 :           if (memcmp(Name.data()+3, "eneric", 6) != 0)
    2473             :             break;
    2474             :           return AttributeList::AT_OpenCLGenericAddressSpace;    // "__generic"
    2475        2497 :         case 'p':        // 1 string to match.
    2476        2497 :           if (memcmp(Name.data()+3, "rivate", 6) != 0)
    2477             :             break;
    2478             :           return AttributeList::AT_OpenCLPrivateAddressSpace;    // "__private"
    2479          96 :         case 'r':        // 1 string to match.
    2480          96 :           if (memcmp(Name.data()+3, "egcall", 6) != 0)
    2481             :             break;
    2482             :           return AttributeList::AT_RegCall;      // "__regcall"
    2483         143 :         case 's':        // 1 string to match.
    2484         143 :           if (memcmp(Name.data()+3, "tdcall", 6) != 0)
    2485             :             break;
    2486             :           return AttributeList::AT_StdCall;      // "__stdcall"
    2487             :         }
    2488             :         break;
    2489           2 :       case 'f':  // 1 string to match.
    2490           2 :         if (memcmp(Name.data()+2, "astcall", 7) != 0)
    2491             :           break;
    2492             :         return AttributeList::AT_FastCall;       // "_fastcall"
    2493           0 :       case 't':  // 1 string to match.
    2494           0 :         if (memcmp(Name.data()+2, "hiscall", 7) != 0)
    2495             :           break;
    2496             :         return AttributeList::AT_ThisCall;       // "_thiscall"
    2497             :       }
    2498             :       break;
    2499        2517 :     case 'r':    // 1 string to match.
    2500        2517 :       if (memcmp(Name.data()+1, "ead_only", 8) != 0)
    2501             :         break;
    2502             :       return AttributeList::AT_OpenCLAccess;     // "read_only"
    2503             :     }
    2504             :     break;
    2505        4528 :   case 10:       // 5 strings to match.
    2506        9056 :     switch (Name[0]) {
    2507             :     default: break;
    2508        1344 :     case '_':    // 3 strings to match.
    2509        2688 :       if (Name[1] != '_')
    2510             :         break;
    2511        2688 :       switch (Name[2]) {
    2512             :       default: break;
    2513        1213 :       case 'c':  // 1 string to match.
    2514        1213 :         if (memcmp(Name.data()+3, "onstant", 7) != 0)
    2515             :           break;
    2516             :         return AttributeList::AT_OpenCLConstantAddressSpace;     // "__constant"
    2517          89 :       case 'f':  // 1 string to match.
    2518          89 :         if (memcmp(Name.data()+3, "astcall", 7) != 0)
    2519             :           break;
    2520             :         return AttributeList::AT_FastCall;       // "__fastcall"
    2521          42 :       case 't':  // 1 string to match.
    2522          42 :         if (memcmp(Name.data()+3, "hiscall", 7) != 0)
    2523             :           break;
    2524             :         return AttributeList::AT_ThisCall;       // "__thiscall"
    2525             :       }
    2526             :       break;
    2527        1778 :     case 'r':    // 1 string to match.
    2528        1778 :       if (memcmp(Name.data()+1, "ead_write", 9) != 0)
    2529             :         break;
    2530             :       return AttributeList::AT_OpenCLAccess;     // "read_write"
    2531        1406 :     case 'w':    // 1 string to match.
    2532        1406 :       if (memcmp(Name.data()+1, "rite_only", 9) != 0)
    2533             :         break;
    2534             :       return AttributeList::AT_OpenCLAccess;     // "write_only"
    2535             :     }
    2536             :     break;
    2537           2 :   case 11:       // 2 strings to match.
    2538           4 :     if (Name[0] != '_')
    2539             :       break;
    2540           4 :     switch (Name[1]) {
    2541             :     default: break;
    2542           2 :     case '_':    // 1 string to match.
    2543           2 :       if (memcmp(Name.data()+2, "read_only", 9) != 0)
    2544             :         break;
    2545             :       return AttributeList::AT_OpenCLAccess;     // "__read_only"
    2546           0 :     case 'v':    // 1 string to match.
    2547           0 :       if (memcmp(Name.data()+2, "ectorcall", 9) != 0)
    2548             :         break;
    2549             :       return AttributeList::AT_VectorCall;       // "_vectorcall"
    2550             :     }
    2551             :     break;
    2552         107 :   case 12:       // 3 strings to match.
    2553         107 :     if (memcmp(Name.data()+0, "__", 2) != 0)
    2554             :       break;
    2555         214 :     switch (Name[2]) {
    2556             :     default: break;
    2557           2 :     case 'r':    // 1 string to match.
    2558           2 :       if (memcmp(Name.data()+3, "ead_write", 9) != 0)
    2559             :         break;
    2560             :       return AttributeList::AT_OpenCLAccess;     // "__read_write"
    2561         103 :     case 'v':    // 1 string to match.
    2562         103 :       if (memcmp(Name.data()+3, "ectorcall", 9) != 0)
    2563             :         break;
    2564             :       return AttributeList::AT_VectorCall;       // "__vectorcall"
    2565           2 :     case 'w':    // 1 string to match.
    2566           2 :       if (memcmp(Name.data()+3, "rite_only", 9) != 0)
    2567             :         break;
    2568             :       return AttributeList::AT_OpenCLAccess;     // "__write_only"
    2569             :     }
    2570             :     break;
    2571          14 :   case 13:       // 1 string to match.
    2572          14 :     if (memcmp(Name.data()+0, "__forceinline", 13) != 0)
    2573             :       break;
    2574             :     return AttributeList::AT_AlwaysInline;       // "__forceinline"
    2575          31 :   case 17:       // 1 string to match.
    2576          31 :     if (memcmp(Name.data()+0, "_Null_unspecified", 17) != 0)
    2577             :       break;
    2578             :     return AttributeList::AT_TypeNullUnspecified;        // "_Null_unspecified"
    2579          24 :   case 20:       // 1 string to match.
    2580          24 :     if (memcmp(Name.data()+0, "__single_inheritance", 20) != 0)
    2581             :       break;
    2582             :     return AttributeList::AT_MSInheritance;      // "__single_inheritance"
    2583          12 :   case 21:       // 1 string to match.
    2584          12 :     if (memcmp(Name.data()+0, "__virtual_inheritance", 21) != 0)
    2585             :       break;
    2586             :     return AttributeList::AT_MSInheritance;      // "__virtual_inheritance"
    2587          19 :   case 22:       // 1 string to match.
    2588          19 :     if (memcmp(Name.data()+0, "__multiple_inheritance", 22) != 0)
    2589             :       break;
    2590             :     return AttributeList::AT_MSInheritance;      // "__multiple_inheritance"
    2591           0 :   case 25:       // 1 string to match.
    2592           0 :     if (memcmp(Name.data()+0, "__unspecified_inheritance", 25) != 0)
    2593             :       break;
    2594             :     return AttributeList::AT_MSInheritance;      // "__unspecified_inheritance"
    2595             :   }
    2596         194 :   } else if (AttributeList::AS_Pragma == Syntax) {
    2597         194 :   switch (Name.size()) {
    2598             :   default: break;
    2599         158 :   case 4:        // 1 string to match.
    2600         158 :     if (memcmp(Name.data()+0, "loop", 4) != 0)
    2601             :       break;
    2602             :     return AttributeList::AT_LoopHint;   // "loop"
    2603          28 :   case 6:        // 1 string to match.
    2604          28 :     if (memcmp(Name.data()+0, "unroll", 6) != 0)
    2605             :       break;
    2606             :     return AttributeList::AT_LoopHint;   // "unroll"
    2607           8 :   case 8:        // 1 string to match.
    2608           8 :     if (memcmp(Name.data()+0, "nounroll", 8) != 0)
    2609             :       break;
    2610             :     return AttributeList::AT_LoopHint;   // "nounroll"
    2611             :   }
    2612             :   }
    2613             :   return AttributeList::UnknownAttribute;
    2614             : }

Generated by: LCOV version 1.13