LCOV - code coverage report
Current view: top level - build-llvm/tools/clang/include/clang/Sema - AttrSpellingListIndex.inc (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 335 586 57.2 %
Date: 2018-05-20 00:06:23 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
       2             : |*                                                                            *|
       3             : |* Code to translate different attribute spellings into internal identifiers  *|
       4             : |*                                                                            *|
       5             : |* Automatically generated file, do not edit!                                 *|
       6             : |*                                                                            *|
       7             : \*===----------------------------------------------------------------------===*/
       8             : 
       9     2695875 :   switch (AttrKind) {
      10             :   case AT_AMDGPUFlatWorkGroupSize: {
      11          83 :     if (Name == "amdgpu_flat_work_group_size" && SyntaxUsed == 0 && Scope == "")
      12             :         return 0;
      13           0 :     if (Name == "amdgpu_flat_work_group_size" && SyntaxUsed == 1 && Scope == "clang")
      14             :         return 1;
      15             :     break;
      16             :   }
      17             :   case AT_AMDGPUNumSGPR: {
      18          66 :     if (Name == "amdgpu_num_sgpr" && SyntaxUsed == 0 && Scope == "")
      19             :         return 0;
      20           0 :     if (Name == "amdgpu_num_sgpr" && SyntaxUsed == 1 && Scope == "clang")
      21             :         return 1;
      22             :     break;
      23             :   }
      24             :   case AT_AMDGPUNumVGPR: {
      25          66 :     if (Name == "amdgpu_num_vgpr" && SyntaxUsed == 0 && Scope == "")
      26             :         return 0;
      27           0 :     if (Name == "amdgpu_num_vgpr" && SyntaxUsed == 1 && Scope == "clang")
      28             :         return 1;
      29             :     break;
      30             :   }
      31             :   case AT_AMDGPUWavesPerEU: {
      32         104 :     if (Name == "amdgpu_waves_per_eu" && SyntaxUsed == 0 && Scope == "")
      33             :         return 0;
      34           0 :     if (Name == "amdgpu_waves_per_eu" && SyntaxUsed == 1 && Scope == "clang")
      35             :         return 1;
      36             :     break;
      37             :   }
      38             :   case AT_Interrupt: {
      39         151 :     if (Name == "interrupt" && SyntaxUsed == 0 && Scope == "")
      40             :         return 0;
      41           0 :     if (Name == "interrupt" && SyntaxUsed == 1 && Scope == "gnu")
      42             :         return 1;
      43             :     break;
      44             :   }
      45             :   case AT_AVRSignal: {
      46           2 :     if (Name == "signal" && SyntaxUsed == 0 && Scope == "")
      47             :         return 0;
      48           0 :     if (Name == "signal" && SyntaxUsed == 1 && Scope == "gnu")
      49             :         return 1;
      50             :     break;
      51             :   }
      52             :   case AT_AbiTag: {
      53        3682 :     if (Name == "abi_tag" && SyntaxUsed == 0 && Scope == "")
      54             :         return 0;
      55           0 :     if (Name == "abi_tag" && SyntaxUsed == 1 && Scope == "gnu")
      56             :         return 1;
      57             :     break;
      58             :   }
      59             :   case AT_AcquireCapability: {
      60           1 :     if (Name == "acquire_capability" && SyntaxUsed == 0 && Scope == "")
      61             :         return 0;
      62           0 :     if (Name == "acquire_capability" && SyntaxUsed == 1 && Scope == "clang")
      63             :         return 1;
      64           1 :     if (Name == "acquire_shared_capability" && SyntaxUsed == 0 && Scope == "")
      65             :         return 2;
      66           0 :     if (Name == "acquire_shared_capability" && SyntaxUsed == 1 && Scope == "clang")
      67             :         return 3;
      68         276 :     if (Name == "exclusive_lock_function" && SyntaxUsed == 0 && Scope == "")
      69             :         return 4;
      70         125 :     if (Name == "shared_lock_function" && SyntaxUsed == 0 && Scope == "")
      71             :         return 5;
      72             :     break;
      73             :   }
      74             :   case AT_AcquiredAfter: {
      75         133 :     if (Name == "acquired_after" && SyntaxUsed == 0 && Scope == "")
      76             :         return 0;
      77             :     break;
      78             :   }
      79             :   case AT_AcquiredBefore: {
      80          94 :     if (Name == "acquired_before" && SyntaxUsed == 0 && Scope == "")
      81             :         return 0;
      82             :     break;
      83             :   }
      84             :   case AT_AddressSpace: {
      85           0 :     if (Name == "address_space" && SyntaxUsed == 0 && Scope == "")
      86             :         return 0;
      87           0 :     if (Name == "address_space" && SyntaxUsed == 1 && Scope == "clang")
      88             :         return 1;
      89           0 :     if (Name == "address_space" && SyntaxUsed == 2 && Scope == "clang")
      90             :         return 2;
      91             :     break;
      92             :   }
      93             :   case AT_Alias: {
      94          95 :     if (Name == "alias" && SyntaxUsed == 0 && Scope == "")
      95             :         return 0;
      96           3 :     if (Name == "alias" && SyntaxUsed == 1 && Scope == "gnu")
      97             :         return 1;
      98             :     break;
      99             :   }
     100             :   case AT_AlignValue: {
     101          98 :     if (Name == "align_value" && SyntaxUsed == 0 && Scope == "")
     102             :         return 0;
     103             :     break;
     104             :   }
     105             :   case AT_Aligned: {
     106        5335 :     if (Name == "aligned" && SyntaxUsed == 0 && Scope == "")
     107             :         return 0;
     108           6 :     if (Name == "aligned" && SyntaxUsed == 1 && Scope == "gnu")
     109             :         return 1;
     110         214 :     if (Name == "align" && SyntaxUsed == 3 && Scope == "")
     111             :         return 2;
     112        1320 :     if (Name == "alignas" && SyntaxUsed == 5 && Scope == "")
     113             :         return 3;
     114          37 :     if (Name == "_Alignas" && SyntaxUsed == 5 && Scope == "")
     115             :         return 4;
     116             :     break;
     117             :   }
     118             :   case AT_AllocAlign: {
     119          20 :     if (Name == "alloc_align" && SyntaxUsed == 0 && Scope == "")
     120             :         return 0;
     121           0 :     if (Name == "alloc_align" && SyntaxUsed == 1 && Scope == "gnu")
     122             :         return 1;
     123             :     break;
     124             :   }
     125             :   case AT_AllocSize: {
     126          24 :     if (Name == "alloc_size" && SyntaxUsed == 0 && Scope == "")
     127             :         return 0;
     128           0 :     if (Name == "alloc_size" && SyntaxUsed == 1 && Scope == "gnu")
     129             :         return 1;
     130             :     break;
     131             :   }
     132             :   case AT_AlwaysInline: {
     133      734542 :     if (Name == "always_inline" && SyntaxUsed == 0 && Scope == "")
     134             :         return 0;
     135           1 :     if (Name == "always_inline" && SyntaxUsed == 1 && Scope == "gnu")
     136             :         return 1;
     137          14 :     if (Name == "__forceinline" && SyntaxUsed == 5 && Scope == "")
     138             :         return 2;
     139             :     break;
     140             :   }
     141             :   case AT_AnalyzerNoReturn: {
     142           6 :     if (Name == "analyzer_noreturn" && SyntaxUsed == 0 && Scope == "")
     143             :         return 0;
     144             :     break;
     145             :   }
     146             :   case AT_Annotate: {
     147         276 :     if (Name == "annotate" && SyntaxUsed == 0 && Scope == "")
     148             :         return 0;
     149           5 :     if (Name == "annotate" && SyntaxUsed == 1 && Scope == "clang")
     150             :         return 1;
     151           1 :     if (Name == "annotate" && SyntaxUsed == 2 && Scope == "clang")
     152             :         return 2;
     153             :     break;
     154             :   }
     155             :   case AT_AnyX86NoCallerSavedRegisters: {
     156          25 :     if (Name == "no_caller_saved_registers" && SyntaxUsed == 0 && Scope == "")
     157             :         return 0;
     158           2 :     if (Name == "no_caller_saved_registers" && SyntaxUsed == 1 && Scope == "gnu")
     159             :         return 1;
     160             :     break;
     161             :   }
     162             :   case AT_AnyX86NoCfCheck: {
     163          10 :     if (Name == "nocf_check" && SyntaxUsed == 0 && Scope == "")
     164             :         return 0;
     165           4 :     if (Name == "nocf_check" && SyntaxUsed == 1 && Scope == "gnu")
     166             :         return 1;
     167             :     break;
     168             :   }
     169             :   case AT_ArcWeakrefUnavailable: {
     170          33 :     if (Name == "objc_arc_weak_reference_unavailable" && SyntaxUsed == 0 && Scope == "")
     171             :         return 0;
     172           0 :     if (Name == "objc_arc_weak_reference_unavailable" && SyntaxUsed == 1 && Scope == "clang")
     173             :         return 1;
     174           0 :     if (Name == "objc_arc_weak_reference_unavailable" && SyntaxUsed == 2 && Scope == "clang")
     175             :         return 2;
     176             :     break;
     177             :   }
     178             :   case AT_ArgumentWithTypeTag: {
     179          11 :     if (Name == "argument_with_type_tag" && SyntaxUsed == 0 && Scope == "")
     180             :         return 0;
     181           0 :     if (Name == "argument_with_type_tag" && SyntaxUsed == 1 && Scope == "clang")
     182             :         return 1;
     183           0 :     if (Name == "argument_with_type_tag" && SyntaxUsed == 2 && Scope == "clang")
     184             :         return 2;
     185          58 :     if (Name == "pointer_with_type_tag" && SyntaxUsed == 0 && Scope == "")
     186             :         return 3;
     187           2 :     if (Name == "pointer_with_type_tag" && SyntaxUsed == 1 && Scope == "clang")
     188             :         return 4;
     189           2 :     if (Name == "pointer_with_type_tag" && SyntaxUsed == 2 && Scope == "clang")
     190             :         return 5;
     191             :     break;
     192             :   }
     193             :   case AT_Artificial: {
     194          36 :     if (Name == "artificial" && SyntaxUsed == 0 && Scope == "")
     195             :         return 0;
     196           0 :     if (Name == "artificial" && SyntaxUsed == 1 && Scope == "gnu")
     197             :         return 1;
     198             :     break;
     199             :   }
     200             :   case AT_AssertCapability: {
     201          15 :     if (Name == "assert_capability" && SyntaxUsed == 0 && Scope == "")
     202             :         return 0;
     203           0 :     if (Name == "assert_capability" && SyntaxUsed == 1 && Scope == "clang")
     204             :         return 1;
     205           9 :     if (Name == "assert_shared_capability" && SyntaxUsed == 0 && Scope == "")
     206             :         return 2;
     207           0 :     if (Name == "assert_shared_capability" && SyntaxUsed == 1 && Scope == "clang")
     208             :         return 3;
     209             :     break;
     210             :   }
     211             :   case AT_AssertExclusiveLock: {
     212          15 :     if (Name == "assert_exclusive_lock" && SyntaxUsed == 0 && Scope == "")
     213             :         return 0;
     214             :     break;
     215             :   }
     216             :   case AT_AssertSharedLock: {
     217          13 :     if (Name == "assert_shared_lock" && SyntaxUsed == 0 && Scope == "")
     218             :         return 0;
     219             :     break;
     220             :   }
     221             :   case AT_AssumeAligned: {
     222          17 :     if (Name == "assume_aligned" && SyntaxUsed == 0 && Scope == "")
     223             :         return 0;
     224           0 :     if (Name == "assume_aligned" && SyntaxUsed == 1 && Scope == "gnu")
     225             :         return 1;
     226             :     break;
     227             :   }
     228             :   case AT_Availability: {
     229         831 :     if (Name == "availability" && SyntaxUsed == 0 && Scope == "")
     230             :         return 0;
     231           7 :     if (Name == "availability" && SyntaxUsed == 1 && Scope == "clang")
     232             :         return 1;
     233           7 :     if (Name == "availability" && SyntaxUsed == 2 && Scope == "clang")
     234             :         return 2;
     235             :     break;
     236             :   }
     237             :   case AT_Blocks: {
     238         376 :     if (Name == "blocks" && SyntaxUsed == 0 && Scope == "")
     239             :         return 0;
     240           0 :     if (Name == "blocks" && SyntaxUsed == 1 && Scope == "clang")
     241             :         return 1;
     242           0 :     if (Name == "blocks" && SyntaxUsed == 2 && Scope == "clang")
     243             :         return 2;
     244             :     break;
     245             :   }
     246             :   case AT_CDecl: {
     247           0 :     if (Name == "cdecl" && SyntaxUsed == 0 && Scope == "")
     248             :         return 0;
     249           0 :     if (Name == "cdecl" && SyntaxUsed == 1 && Scope == "gnu")
     250             :         return 1;
     251           0 :     if (Name == "__cdecl" && SyntaxUsed == 5 && Scope == "")
     252             :         return 2;
     253           0 :     if (Name == "_cdecl" && SyntaxUsed == 5 && Scope == "")
     254             :         return 3;
     255             :     break;
     256             :   }
     257             :   case AT_CFAuditedTransfer: {
     258           0 :     if (Name == "cf_audited_transfer" && SyntaxUsed == 0 && Scope == "")
     259             :         return 0;
     260           0 :     if (Name == "cf_audited_transfer" && SyntaxUsed == 1 && Scope == "clang")
     261             :         return 1;
     262           0 :     if (Name == "cf_audited_transfer" && SyntaxUsed == 2 && Scope == "clang")
     263             :         return 2;
     264             :     break;
     265             :   }
     266             :   case AT_CFConsumed: {
     267         299 :     if (Name == "cf_consumed" && SyntaxUsed == 0 && Scope == "")
     268             :         return 0;
     269           0 :     if (Name == "cf_consumed" && SyntaxUsed == 1 && Scope == "clang")
     270             :         return 1;
     271           0 :     if (Name == "cf_consumed" && SyntaxUsed == 2 && Scope == "clang")
     272             :         return 2;
     273             :     break;
     274             :   }
     275             :   case AT_CFReturnsNotRetained: {
     276          42 :     if (Name == "cf_returns_not_retained" && SyntaxUsed == 0 && Scope == "")
     277             :         return 0;
     278           0 :     if (Name == "cf_returns_not_retained" && SyntaxUsed == 1 && Scope == "clang")
     279             :         return 1;
     280           0 :     if (Name == "cf_returns_not_retained" && SyntaxUsed == 2 && Scope == "clang")
     281             :         return 2;
     282             :     break;
     283             :   }
     284             :   case AT_CFReturnsRetained: {
     285         180 :     if (Name == "cf_returns_retained" && SyntaxUsed == 0 && Scope == "")
     286             :         return 0;
     287           0 :     if (Name == "cf_returns_retained" && SyntaxUsed == 1 && Scope == "clang")
     288             :         return 1;
     289           0 :     if (Name == "cf_returns_retained" && SyntaxUsed == 2 && Scope == "clang")
     290             :         return 2;
     291             :     break;
     292             :   }
     293             :   case AT_CFUnknownTransfer: {
     294           1 :     if (Name == "cf_unknown_transfer" && SyntaxUsed == 0 && Scope == "")
     295             :         return 0;
     296           0 :     if (Name == "cf_unknown_transfer" && SyntaxUsed == 1 && Scope == "clang")
     297             :         return 1;
     298           0 :     if (Name == "cf_unknown_transfer" && SyntaxUsed == 2 && Scope == "clang")
     299             :         return 2;
     300             :     break;
     301             :   }
     302             :   case AT_CUDAConstant: {
     303         107 :     if (Name == "constant" && SyntaxUsed == 0 && Scope == "")
     304             :         return 0;
     305           2 :     if (Name == "__constant__" && SyntaxUsed == 3 && Scope == "")
     306             :         return 1;
     307             :     break;
     308             :   }
     309             :   case AT_CUDADevice: {
     310        1127 :     if (Name == "device" && SyntaxUsed == 0 && Scope == "")
     311             :         return 0;
     312           2 :     if (Name == "__device__" && SyntaxUsed == 3 && Scope == "")
     313             :         return 1;
     314             :     break;
     315             :   }
     316             :   case AT_CUDAGlobal: {
     317         115 :     if (Name == "global" && SyntaxUsed == 0 && Scope == "")
     318             :         return 0;
     319           2 :     if (Name == "__global__" && SyntaxUsed == 3 && Scope == "")
     320             :         return 1;
     321             :     break;
     322             :   }
     323             :   case AT_CUDAHost: {
     324         443 :     if (Name == "host" && SyntaxUsed == 0 && Scope == "")
     325             :         return 0;
     326           2 :     if (Name == "__host__" && SyntaxUsed == 3 && Scope == "")
     327             :         return 1;
     328             :     break;
     329             :   }
     330             :   case AT_CUDAInvalidTarget: {
     331             :     break;
     332             :   }
     333             :   case AT_CUDALaunchBounds: {
     334          27 :     if (Name == "launch_bounds" && SyntaxUsed == 0 && Scope == "")
     335             :         return 0;
     336           0 :     if (Name == "__launch_bounds__" && SyntaxUsed == 3 && Scope == "")
     337             :         return 1;
     338             :     break;
     339             :   }
     340             :   case AT_CUDAShared: {
     341         179 :     if (Name == "shared" && SyntaxUsed == 0 && Scope == "")
     342             :         return 0;
     343           2 :     if (Name == "__shared__" && SyntaxUsed == 3 && Scope == "")
     344             :         return 1;
     345             :     break;
     346             :   }
     347             :   case AT_CXX11NoReturn: {
     348        1011 :     if (Name == "noreturn" && SyntaxUsed == 1 && Scope == "")
     349             :         return 0;
     350             :     break;
     351             :   }
     352             :   case AT_CallableWhen: {
     353          12 :     if (Name == "callable_when" && SyntaxUsed == 0 && Scope == "")
     354             :         return 0;
     355           0 :     if (Name == "callable_when" && SyntaxUsed == 1 && Scope == "clang")
     356             :         return 1;
     357             :     break;
     358             :   }
     359             :   case AT_Capability: {
     360           8 :     if (Name == "capability" && SyntaxUsed == 0 && Scope == "")
     361             :         return 0;
     362           0 :     if (Name == "capability" && SyntaxUsed == 1 && Scope == "clang")
     363             :         return 1;
     364           2 :     if (Name == "shared_capability" && SyntaxUsed == 0 && Scope == "")
     365             :         return 2;
     366           0 :     if (Name == "shared_capability" && SyntaxUsed == 1 && Scope == "clang")
     367             :         return 3;
     368             :     break;
     369             :   }
     370             :   case AT_CarriesDependency: {
     371          20 :     if (Name == "carries_dependency" && SyntaxUsed == 0 && Scope == "")
     372             :         return 0;
     373          20 :     if (Name == "carries_dependency" && SyntaxUsed == 1 && Scope == "")
     374             :         return 1;
     375             :     break;
     376             :   }
     377             :   case AT_Cleanup: {
     378          27 :     if (Name == "cleanup" && SyntaxUsed == 0 && Scope == "")
     379             :         return 0;
     380           1 :     if (Name == "cleanup" && SyntaxUsed == 1 && Scope == "gnu")
     381             :         return 1;
     382             :     break;
     383             :   }
     384             :   case AT_CodeSeg: {
     385          75 :     if (Name == "code_seg" && SyntaxUsed == 3 && Scope == "")
     386             :         return 0;
     387             :     break;
     388             :   }
     389             :   case AT_Cold: {
     390          25 :     if (Name == "cold" && SyntaxUsed == 0 && Scope == "")
     391             :         return 0;
     392           0 :     if (Name == "cold" && SyntaxUsed == 1 && Scope == "gnu")
     393             :         return 1;
     394             :     break;
     395             :   }
     396             :   case AT_Common: {
     397           8 :     if (Name == "common" && SyntaxUsed == 0 && Scope == "")
     398             :         return 0;
     399           0 :     if (Name == "common" && SyntaxUsed == 1 && Scope == "gnu")
     400             :         return 1;
     401             :     break;
     402             :   }
     403             :   case AT_Const: {
     404      199137 :     if (Name == "const" && SyntaxUsed == 0 && Scope == "")
     405             :         return 0;
     406           2 :     if (Name == "const" && SyntaxUsed == 1 && Scope == "gnu")
     407             :         return 1;
     408           6 :     if (Name == "__const" && SyntaxUsed == 0 && Scope == "")
     409             :         return 2;
     410           1 :     if (Name == "__const" && SyntaxUsed == 1 && Scope == "gnu")
     411             :         return 3;
     412             :     break;
     413             :   }
     414             :   case AT_Constructor: {
     415          19 :     if (Name == "constructor" && SyntaxUsed == 0 && Scope == "")
     416             :         return 0;
     417           0 :     if (Name == "constructor" && SyntaxUsed == 1 && Scope == "gnu")
     418             :         return 1;
     419             :     break;
     420             :   }
     421             :   case AT_Consumable: {
     422           6 :     if (Name == "consumable" && SyntaxUsed == 0 && Scope == "")
     423             :         return 0;
     424           0 :     if (Name == "consumable" && SyntaxUsed == 1 && Scope == "clang")
     425             :         return 1;
     426             :     break;
     427             :   }
     428             :   case AT_ConsumableAutoCast: {
     429           2 :     if (Name == "consumable_auto_cast_state" && SyntaxUsed == 0 && Scope == "")
     430             :         return 0;
     431           0 :     if (Name == "consumable_auto_cast_state" && SyntaxUsed == 1 && Scope == "clang")
     432             :         return 1;
     433             :     break;
     434             :   }
     435             :   case AT_ConsumableSetOnRead: {
     436           2 :     if (Name == "consumable_set_state_on_read" && SyntaxUsed == 0 && Scope == "")
     437             :         return 0;
     438           0 :     if (Name == "consumable_set_state_on_read" && SyntaxUsed == 1 && Scope == "clang")
     439             :         return 1;
     440             :     break;
     441             :   }
     442             :   case AT_Convergent: {
     443        2795 :     if (Name == "convergent" && SyntaxUsed == 0 && Scope == "")
     444             :         return 0;
     445           0 :     if (Name == "convergent" && SyntaxUsed == 1 && Scope == "clang")
     446             :         return 1;
     447           0 :     if (Name == "convergent" && SyntaxUsed == 2 && Scope == "clang")
     448             :         return 2;
     449             :     break;
     450             :   }
     451             :   case AT_DLLExport: {
     452        3342 :     if (Name == "dllexport" && SyntaxUsed == 3 && Scope == "")
     453             :         return 0;
     454         335 :     if (Name == "dllexport" && SyntaxUsed == 0 && Scope == "")
     455             :         return 1;
     456           0 :     if (Name == "dllexport" && SyntaxUsed == 1 && Scope == "gnu")
     457             :         return 2;
     458             :     break;
     459             :   }
     460             :   case AT_DLLImport: {
     461        3678 :     if (Name == "dllimport" && SyntaxUsed == 3 && Scope == "")
     462             :         return 0;
     463         450 :     if (Name == "dllimport" && SyntaxUsed == 0 && Scope == "")
     464             :         return 1;
     465           0 :     if (Name == "dllimport" && SyntaxUsed == 1 && Scope == "gnu")
     466             :         return 2;
     467             :     break;
     468             :   }
     469             :   case AT_Deprecated: {
     470        5701 :     if (Name == "deprecated" && SyntaxUsed == 0 && Scope == "")
     471             :         return 0;
     472          74 :     if (Name == "deprecated" && SyntaxUsed == 1 && Scope == "gnu")
     473             :         return 1;
     474          67 :     if (Name == "deprecated" && SyntaxUsed == 3 && Scope == "")
     475             :         return 2;
     476          46 :     if (Name == "deprecated" && SyntaxUsed == 1 && Scope == "")
     477             :         return 3;
     478          21 :     if (Name == "deprecated" && SyntaxUsed == 2 && Scope == "")
     479             :         return 4;
     480             :     break;
     481             :   }
     482             :   case AT_Destructor: {
     483          22 :     if (Name == "destructor" && SyntaxUsed == 0 && Scope == "")
     484             :         return 0;
     485           0 :     if (Name == "destructor" && SyntaxUsed == 1 && Scope == "gnu")
     486             :         return 1;
     487             :     break;
     488             :   }
     489             :   case AT_DiagnoseIf: {
     490         120 :     if (Name == "diagnose_if" && SyntaxUsed == 0 && Scope == "")
     491             :         return 0;
     492             :     break;
     493             :   }
     494             :   case AT_DisableTailCalls: {
     495           9 :     if (Name == "disable_tail_calls" && SyntaxUsed == 0 && Scope == "")
     496             :         return 0;
     497           6 :     if (Name == "disable_tail_calls" && SyntaxUsed == 1 && Scope == "clang")
     498             :         return 1;
     499           0 :     if (Name == "disable_tail_calls" && SyntaxUsed == 2 && Scope == "clang")
     500             :         return 2;
     501             :     break;
     502             :   }
     503             :   case AT_EmptyBases: {
     504           9 :     if (Name == "empty_bases" && SyntaxUsed == 3 && Scope == "")
     505             :         return 0;
     506             :     break;
     507             :   }
     508             :   case AT_EnableIf: {
     509         568 :     if (Name == "enable_if" && SyntaxUsed == 0 && Scope == "")
     510             :         return 0;
     511             :     break;
     512             :   }
     513             :   case AT_EnumExtensibility: {
     514          11 :     if (Name == "enum_extensibility" && SyntaxUsed == 0 && Scope == "")
     515             :         return 0;
     516           2 :     if (Name == "enum_extensibility" && SyntaxUsed == 1 && Scope == "clang")
     517             :         return 1;
     518           1 :     if (Name == "enum_extensibility" && SyntaxUsed == 2 && Scope == "clang")
     519             :         return 2;
     520             :     break;
     521             :   }
     522             :   case AT_ExclusiveTrylockFunction: {
     523          76 :     if (Name == "exclusive_trylock_function" && SyntaxUsed == 0 && Scope == "")
     524             :         return 0;
     525             :     break;
     526             :   }
     527             :   case AT_ExtVectorType: {
     528           0 :     if (Name == "ext_vector_type" && SyntaxUsed == 0 && Scope == "")
     529             :         return 0;
     530             :     break;
     531             :   }
     532             :   case AT_ExternalSourceSymbol: {
     533          60 :     if (Name == "external_source_symbol" && SyntaxUsed == 0 && Scope == "")
     534             :         return 0;
     535           4 :     if (Name == "external_source_symbol" && SyntaxUsed == 1 && Scope == "clang")
     536             :         return 1;
     537           3 :     if (Name == "external_source_symbol" && SyntaxUsed == 2 && Scope == "clang")
     538             :         return 2;
     539             :     break;
     540             :   }
     541             :   case AT_FallThrough: {
     542          68 :     if (Name == "fallthrough" && SyntaxUsed == 1 && Scope == "")
     543             :         return 0;
     544          50 :     if (Name == "fallthrough" && SyntaxUsed == 2 && Scope == "")
     545             :         return 1;
     546          36 :     if (Name == "fallthrough" && SyntaxUsed == 1 && Scope == "clang")
     547             :         return 2;
     548             :     break;
     549             :   }
     550             :   case AT_FastCall: {
     551           0 :     if (Name == "fastcall" && SyntaxUsed == 0 && Scope == "")
     552             :         return 0;
     553           0 :     if (Name == "fastcall" && SyntaxUsed == 1 && Scope == "gnu")
     554             :         return 1;
     555           0 :     if (Name == "__fastcall" && SyntaxUsed == 5 && Scope == "")
     556             :         return 2;
     557           0 :     if (Name == "_fastcall" && SyntaxUsed == 5 && Scope == "")
     558             :         return 3;
     559             :     break;
     560             :   }
     561             :   case AT_FlagEnum: {
     562          13 :     if (Name == "flag_enum" && SyntaxUsed == 0 && Scope == "")
     563             :         return 0;
     564           1 :     if (Name == "flag_enum" && SyntaxUsed == 1 && Scope == "clang")
     565             :         return 1;
     566           1 :     if (Name == "flag_enum" && SyntaxUsed == 2 && Scope == "clang")
     567             :         return 2;
     568             :     break;
     569             :   }
     570             :   case AT_Flatten: {
     571          10 :     if (Name == "flatten" && SyntaxUsed == 0 && Scope == "")
     572             :         return 0;
     573           5 :     if (Name == "flatten" && SyntaxUsed == 1 && Scope == "gnu")
     574             :         return 1;
     575             :     break;
     576             :   }
     577             :   case AT_Format: {
     578       17062 :     if (Name == "format" && SyntaxUsed == 0 && Scope == "")
     579             :         return 0;
     580           1 :     if (Name == "format" && SyntaxUsed == 1 && Scope == "gnu")
     581             :         return 1;
     582             :     break;
     583             :   }
     584             :   case AT_FormatArg: {
     585         651 :     if (Name == "format_arg" && SyntaxUsed == 0 && Scope == "")
     586             :         return 0;
     587           0 :     if (Name == "format_arg" && SyntaxUsed == 1 && Scope == "gnu")
     588             :         return 1;
     589             :     break;
     590             :   }
     591             :   case AT_GNUInline: {
     592        3975 :     if (Name == "gnu_inline" && SyntaxUsed == 0 && Scope == "")
     593             :         return 0;
     594           1 :     if (Name == "gnu_inline" && SyntaxUsed == 1 && Scope == "gnu")
     595             :         return 1;
     596             :     break;
     597             :   }
     598             :   case AT_GuardedBy: {
     599         522 :     if (Name == "guarded_by" && SyntaxUsed == 0 && Scope == "")
     600             :         return 0;
     601             :     break;
     602             :   }
     603             :   case AT_GuardedVar: {
     604          13 :     if (Name == "guarded_var" && SyntaxUsed == 0 && Scope == "")
     605             :         return 0;
     606           0 :     if (Name == "guarded_var" && SyntaxUsed == 1 && Scope == "clang")
     607             :         return 1;
     608             :     break;
     609             :   }
     610             :   case AT_Hot: {
     611           2 :     if (Name == "hot" && SyntaxUsed == 0 && Scope == "")
     612             :         return 0;
     613           0 :     if (Name == "hot" && SyntaxUsed == 1 && Scope == "gnu")
     614             :         return 1;
     615             :     break;
     616             :   }
     617             :   case AT_IBAction: {
     618          55 :     if (Name == "ibaction" && SyntaxUsed == 0 && Scope == "")
     619             :         return 0;
     620           0 :     if (Name == "ibaction" && SyntaxUsed == 1 && Scope == "clang")
     621             :         return 1;
     622           0 :     if (Name == "ibaction" && SyntaxUsed == 2 && Scope == "clang")
     623             :         return 2;
     624             :     break;
     625             :   }
     626             :   case AT_IBOutlet: {
     627          35 :     if (Name == "iboutlet" && SyntaxUsed == 0 && Scope == "")
     628             :         return 0;
     629           4 :     if (Name == "iboutlet" && SyntaxUsed == 1 && Scope == "clang")
     630             :         return 1;
     631           4 :     if (Name == "iboutlet" && SyntaxUsed == 2 && Scope == "clang")
     632             :         return 2;
     633             :     break;
     634             :   }
     635             :   case AT_IBOutletCollection: {
     636          27 :     if (Name == "iboutletcollection" && SyntaxUsed == 0 && Scope == "")
     637             :         return 0;
     638           0 :     if (Name == "iboutletcollection" && SyntaxUsed == 1 && Scope == "clang")
     639             :         return 1;
     640           0 :     if (Name == "iboutletcollection" && SyntaxUsed == 2 && Scope == "clang")
     641             :         return 2;
     642             :     break;
     643             :   }
     644             :   case AT_IFunc: {
     645          12 :     if (Name == "ifunc" && SyntaxUsed == 0 && Scope == "")
     646             :         return 0;
     647           0 :     if (Name == "ifunc" && SyntaxUsed == 1 && Scope == "gnu")
     648             :         return 1;
     649             :     break;
     650             :   }
     651             :   case AT_InitPriority: {
     652         598 :     if (Name == "init_priority" && SyntaxUsed == 0 && Scope == "")
     653             :         return 0;
     654           0 :     if (Name == "init_priority" && SyntaxUsed == 1 && Scope == "gnu")
     655             :         return 1;
     656             :     break;
     657             :   }
     658             :   case AT_IntelOclBicc: {
     659           0 :     if (Name == "intel_ocl_bicc" && SyntaxUsed == 0 && Scope == "")
     660             :         return 0;
     661           0 :     if (Name == "intel_ocl_bicc" && SyntaxUsed == 1 && Scope == "clang")
     662             :         return 1;
     663             :     break;
     664             :   }
     665             :   case AT_InternalLinkage: {
     666          35 :     if (Name == "internal_linkage" && SyntaxUsed == 0 && Scope == "")
     667             :         return 0;
     668           8 :     if (Name == "internal_linkage" && SyntaxUsed == 1 && Scope == "clang")
     669             :         return 1;
     670           3 :     if (Name == "internal_linkage" && SyntaxUsed == 2 && Scope == "clang")
     671             :         return 2;
     672             :     break;
     673             :   }
     674             :   case AT_LTOVisibilityPublic: {
     675           4 :     if (Name == "lto_visibility_public" && SyntaxUsed == 0 && Scope == "")
     676             :         return 0;
     677           4 :     if (Name == "lto_visibility_public" && SyntaxUsed == 1 && Scope == "clang")
     678             :         return 1;
     679           0 :     if (Name == "lto_visibility_public" && SyntaxUsed == 2 && Scope == "clang")
     680             :         return 2;
     681             :     break;
     682             :   }
     683             :   case AT_LayoutVersion: {
     684           1 :     if (Name == "layout_version" && SyntaxUsed == 3 && Scope == "")
     685             :         return 0;
     686             :     break;
     687             :   }
     688             :   case AT_LockReturned: {
     689          80 :     if (Name == "lock_returned" && SyntaxUsed == 0 && Scope == "")
     690             :         return 0;
     691             :     break;
     692             :   }
     693             :   case AT_Lockable: {
     694          57 :     if (Name == "lockable" && SyntaxUsed == 0 && Scope == "")
     695             :         return 0;
     696             :     break;
     697             :   }
     698             :   case AT_LocksExcluded: {
     699         130 :     if (Name == "locks_excluded" && SyntaxUsed == 0 && Scope == "")
     700             :         return 0;
     701             :     break;
     702             :   }
     703             :   case AT_LoopHint: {
     704         156 :     if (Name == "loop" && SyntaxUsed == 6 && Scope == "clang")
     705             :         return 0;
     706          26 :     if (Name == "unroll" && SyntaxUsed == 6 && Scope == "")
     707             :         return 1;
     708           7 :     if (Name == "nounroll" && SyntaxUsed == 6 && Scope == "")
     709             :         return 2;
     710             :     break;
     711             :   }
     712             :   case AT_MSABI: {
     713           1 :     if (Name == "ms_abi" && SyntaxUsed == 0 && Scope == "")
     714             :         return 0;
     715           0 :     if (Name == "ms_abi" && SyntaxUsed == 1 && Scope == "gnu")
     716             :         return 1;
     717             :     break;
     718             :   }
     719             :   case AT_MSInheritance: {
     720          50 :     if (Name == "__single_inheritance" && SyntaxUsed == 5 && Scope == "")
     721             :         return 0;
     722          40 :     if (Name == "__multiple_inheritance" && SyntaxUsed == 5 && Scope == "")
     723             :         return 1;
     724          26 :     if (Name == "__virtual_inheritance" && SyntaxUsed == 5 && Scope == "")
     725             :         return 2;
     726           0 :     if (Name == "__unspecified_inheritance" && SyntaxUsed == 5 && Scope == "")
     727             :         return 3;
     728             :     break;
     729             :   }
     730             :   case AT_MSNoVTable: {
     731           6 :     if (Name == "novtable" && SyntaxUsed == 3 && Scope == "")
     732             :         return 0;
     733             :     break;
     734             :   }
     735             :   case AT_MSStruct: {
     736          73 :     if (Name == "ms_struct" && SyntaxUsed == 0 && Scope == "")
     737             :         return 0;
     738           0 :     if (Name == "ms_struct" && SyntaxUsed == 1 && Scope == "gnu")
     739             :         return 1;
     740             :     break;
     741             :   }
     742             :   case AT_MayAlias: {
     743        4261 :     if (Name == "may_alias" && SyntaxUsed == 0 && Scope == "")
     744             :         return 0;
     745          19 :     if (Name == "may_alias" && SyntaxUsed == 1 && Scope == "gnu")
     746             :         return 1;
     747             :     break;
     748             :   }
     749             :   case AT_MicroMips: {
     750           3 :     if (Name == "micromips" && SyntaxUsed == 0 && Scope == "")
     751             :         return 0;
     752           0 :     if (Name == "micromips" && SyntaxUsed == 1 && Scope == "gnu")
     753             :         return 1;
     754             :     break;
     755             :   }
     756             :   case AT_MinSize: {
     757          24 :     if (Name == "minsize" && SyntaxUsed == 0 && Scope == "")
     758             :         return 0;
     759           0 :     if (Name == "minsize" && SyntaxUsed == 1 && Scope == "clang")
     760             :         return 1;
     761           0 :     if (Name == "minsize" && SyntaxUsed == 2 && Scope == "clang")
     762             :         return 2;
     763             :     break;
     764             :   }
     765             :   case AT_Mips16: {
     766           8 :     if (Name == "mips16" && SyntaxUsed == 0 && Scope == "")
     767             :         return 0;
     768           0 :     if (Name == "mips16" && SyntaxUsed == 1 && Scope == "gnu")
     769             :         return 1;
     770             :     break;
     771             :   }
     772             :   case AT_MipsLongCall: {
     773           8 :     if (Name == "long_call" && SyntaxUsed == 0 && Scope == "")
     774             :         return 0;
     775           0 :     if (Name == "long_call" && SyntaxUsed == 1 && Scope == "gnu")
     776             :         return 1;
     777           6 :     if (Name == "far" && SyntaxUsed == 0 && Scope == "")
     778             :         return 2;
     779           0 :     if (Name == "far" && SyntaxUsed == 1 && Scope == "gnu")
     780             :         return 3;
     781             :     break;
     782             :   }
     783             :   case AT_MipsShortCall: {
     784           6 :     if (Name == "short_call" && SyntaxUsed == 0 && Scope == "")
     785             :         return 0;
     786           0 :     if (Name == "short_call" && SyntaxUsed == 1 && Scope == "gnu")
     787             :         return 1;
     788           8 :     if (Name == "near" && SyntaxUsed == 0 && Scope == "")
     789             :         return 2;
     790           0 :     if (Name == "near" && SyntaxUsed == 1 && Scope == "gnu")
     791             :         return 3;
     792             :     break;
     793             :   }
     794             :   case AT_Mode: {
     795        3008 :     if (Name == "mode" && SyntaxUsed == 0 && Scope == "")
     796             :         return 0;
     797           1 :     if (Name == "mode" && SyntaxUsed == 1 && Scope == "gnu")
     798             :         return 1;
     799             :     break;
     800             :   }
     801             :   case AT_NSConsumed: {
     802         113 :     if (Name == "ns_consumed" && SyntaxUsed == 0 && Scope == "")
     803             :         return 0;
     804           0 :     if (Name == "ns_consumed" && SyntaxUsed == 1 && Scope == "clang")
     805             :         return 1;
     806           0 :     if (Name == "ns_consumed" && SyntaxUsed == 2 && Scope == "clang")
     807             :         return 2;
     808             :     break;
     809             :   }
     810             :   case AT_NSConsumesSelf: {
     811          19 :     if (Name == "ns_consumes_self" && SyntaxUsed == 0 && Scope == "")
     812             :         return 0;
     813           6 :     if (Name == "ns_consumes_self" && SyntaxUsed == 1 && Scope == "clang")
     814             :         return 1;
     815           6 :     if (Name == "ns_consumes_self" && SyntaxUsed == 2 && Scope == "clang")
     816             :         return 2;
     817             :     break;
     818             :   }
     819             :   case AT_NSReturnsAutoreleased: {
     820           4 :     if (Name == "ns_returns_autoreleased" && SyntaxUsed == 0 && Scope == "")
     821             :         return 0;
     822           0 :     if (Name == "ns_returns_autoreleased" && SyntaxUsed == 1 && Scope == "clang")
     823             :         return 1;
     824           0 :     if (Name == "ns_returns_autoreleased" && SyntaxUsed == 2 && Scope == "clang")
     825             :         return 2;
     826             :     break;
     827             :   }
     828             :   case AT_NSReturnsNotRetained: {
     829         108 :     if (Name == "ns_returns_not_retained" && SyntaxUsed == 0 && Scope == "")
     830             :         return 0;
     831           0 :     if (Name == "ns_returns_not_retained" && SyntaxUsed == 1 && Scope == "clang")
     832             :         return 1;
     833           0 :     if (Name == "ns_returns_not_retained" && SyntaxUsed == 2 && Scope == "clang")
     834             :         return 2;
     835             :     break;
     836             :   }
     837             :   case AT_NSReturnsRetained: {
     838          77 :     if (Name == "ns_returns_retained" && SyntaxUsed == 0 && Scope == "")
     839             :         return 0;
     840           0 :     if (Name == "ns_returns_retained" && SyntaxUsed == 1 && Scope == "clang")
     841             :         return 1;
     842           0 :     if (Name == "ns_returns_retained" && SyntaxUsed == 2 && Scope == "clang")
     843             :         return 2;
     844             :     break;
     845             :   }
     846             :   case AT_Naked: {
     847          29 :     if (Name == "naked" && SyntaxUsed == 0 && Scope == "")
     848             :         return 0;
     849           8 :     if (Name == "naked" && SyntaxUsed == 1 && Scope == "gnu")
     850             :         return 1;
     851           8 :     if (Name == "naked" && SyntaxUsed == 3 && Scope == "")
     852             :         return 2;
     853             :     break;
     854             :   }
     855             :   case AT_NeonPolyVectorType: {
     856           0 :     if (Name == "neon_polyvector_type" && SyntaxUsed == 0 && Scope == "")
     857             :         return 0;
     858           0 :     if (Name == "neon_polyvector_type" && SyntaxUsed == 1 && Scope == "clang")
     859             :         return 1;
     860           0 :     if (Name == "neon_polyvector_type" && SyntaxUsed == 2 && Scope == "clang")
     861             :         return 2;
     862             :     break;
     863             :   }
     864             :   case AT_NeonVectorType: {
     865           0 :     if (Name == "neon_vector_type" && SyntaxUsed == 0 && Scope == "")
     866             :         return 0;
     867           0 :     if (Name == "neon_vector_type" && SyntaxUsed == 1 && Scope == "clang")
     868             :         return 1;
     869           0 :     if (Name == "neon_vector_type" && SyntaxUsed == 2 && Scope == "clang")
     870             :         return 2;
     871             :     break;
     872             :   }
     873             :   case AT_NoAlias: {
     874           2 :     if (Name == "noalias" && SyntaxUsed == 3 && Scope == "")
     875             :         return 0;
     876             :     break;
     877             :   }
     878             :   case AT_NoCommon: {
     879           3 :     if (Name == "nocommon" && SyntaxUsed == 0 && Scope == "")
     880             :         return 0;
     881           0 :     if (Name == "nocommon" && SyntaxUsed == 1 && Scope == "gnu")
     882             :         return 1;
     883             :     break;
     884             :   }
     885             :   case AT_NoDebug: {
     886      650839 :     if (Name == "nodebug" && SyntaxUsed == 0 && Scope == "")
     887             :         return 0;
     888           1 :     if (Name == "nodebug" && SyntaxUsed == 1 && Scope == "gnu")
     889             :         return 1;
     890             :     break;
     891             :   }
     892             :   case AT_NoDuplicate: {
     893           5 :     if (Name == "noduplicate" && SyntaxUsed == 0 && Scope == "")
     894             :         return 0;
     895           2 :     if (Name == "noduplicate" && SyntaxUsed == 1 && Scope == "clang")
     896             :         return 1;
     897           0 :     if (Name == "noduplicate" && SyntaxUsed == 2 && Scope == "clang")
     898             :         return 2;
     899             :     break;
     900             :   }
     901             :   case AT_NoEscape: {
     902          64 :     if (Name == "noescape" && SyntaxUsed == 0 && Scope == "")
     903             :         return 0;
     904           3 :     if (Name == "noescape" && SyntaxUsed == 1 && Scope == "clang")
     905             :         return 1;
     906           1 :     if (Name == "noescape" && SyntaxUsed == 2 && Scope == "clang")
     907             :         return 2;
     908             :     break;
     909             :   }
     910             :   case AT_NoInline: {
     911         388 :     if (Name == "noinline" && SyntaxUsed == 0 && Scope == "")
     912             :         return 0;
     913          31 :     if (Name == "noinline" && SyntaxUsed == 1 && Scope == "gnu")
     914             :         return 1;
     915          31 :     if (Name == "noinline" && SyntaxUsed == 3 && Scope == "")
     916             :         return 2;
     917             :     break;
     918             :   }
     919             :   case AT_NoInstrumentFunction: {
     920          27 :     if (Name == "no_instrument_function" && SyntaxUsed == 0 && Scope == "")
     921             :         return 0;
     922           0 :     if (Name == "no_instrument_function" && SyntaxUsed == 1 && Scope == "gnu")
     923             :         return 1;
     924             :     break;
     925             :   }
     926             :   case AT_NoMicroMips: {
     927           2 :     if (Name == "nomicromips" && SyntaxUsed == 0 && Scope == "")
     928             :         return 0;
     929           0 :     if (Name == "nomicromips" && SyntaxUsed == 1 && Scope == "gnu")
     930             :         return 1;
     931             :     break;
     932             :   }
     933             :   case AT_NoMips16: {
     934           4 :     if (Name == "nomips16" && SyntaxUsed == 0 && Scope == "")
     935             :         return 0;
     936           0 :     if (Name == "nomips16" && SyntaxUsed == 1 && Scope == "gnu")
     937             :         return 1;
     938             :     break;
     939             :   }
     940             :   case AT_NoReturn: {
     941          14 :     if (Name == "noreturn" && SyntaxUsed == 0 && Scope == "")
     942             :         return 0;
     943           0 :     if (Name == "noreturn" && SyntaxUsed == 1 && Scope == "gnu")
     944             :         return 1;
     945           0 :     if (Name == "noreturn" && SyntaxUsed == 3 && Scope == "")
     946             :         return 2;
     947             :     break;
     948             :   }
     949             :   case AT_NoSanitize: {
     950          93 :     if (Name == "no_sanitize" && SyntaxUsed == 0 && Scope == "")
     951             :         return 0;
     952           6 :     if (Name == "no_sanitize" && SyntaxUsed == 1 && Scope == "clang")
     953             :         return 1;
     954           0 :     if (Name == "no_sanitize" && SyntaxUsed == 2 && Scope == "clang")
     955             :         return 2;
     956             :     break;
     957             :   }
     958             :   case AT_NoSanitizeSpecific: {
     959           2 :     if (Name == "no_address_safety_analysis" && SyntaxUsed == 0 && Scope == "")
     960             :         return 0;
     961           1 :     if (Name == "no_address_safety_analysis" && SyntaxUsed == 1 && Scope == "gnu")
     962             :         return 1;
     963          36 :     if (Name == "no_sanitize_address" && SyntaxUsed == 0 && Scope == "")
     964             :         return 2;
     965           9 :     if (Name == "no_sanitize_address" && SyntaxUsed == 1 && Scope == "gnu")
     966             :         return 3;
     967          14 :     if (Name == "no_sanitize_thread" && SyntaxUsed == 0 && Scope == "")
     968             :         return 4;
     969           0 :     if (Name == "no_sanitize_thread" && SyntaxUsed == 1 && Scope == "gnu")
     970             :         return 5;
     971           6 :     if (Name == "no_sanitize_memory" && SyntaxUsed == 0 && Scope == "")
     972             :         return 6;
     973           0 :     if (Name == "no_sanitize_memory" && SyntaxUsed == 1 && Scope == "clang")
     974             :         return 7;
     975           0 :     if (Name == "no_sanitize_memory" && SyntaxUsed == 2 && Scope == "clang")
     976             :         return 8;
     977             :     break;
     978             :   }
     979             :   case AT_NoSplitStack: {
     980          14 :     if (Name == "no_split_stack" && SyntaxUsed == 0 && Scope == "")
     981             :         return 0;
     982           8 :     if (Name == "no_split_stack" && SyntaxUsed == 1 && Scope == "gnu")
     983             :         return 1;
     984             :     break;
     985             :   }
     986             :   case AT_NoStackProtector: {
     987          10 :     if (Name == "no_stack_protector" && SyntaxUsed == 0 && Scope == "")
     988             :         return 0;
     989           0 :     if (Name == "no_stack_protector" && SyntaxUsed == 1 && Scope == "clang")
     990             :         return 1;
     991           0 :     if (Name == "no_stack_protector" && SyntaxUsed == 2 && Scope == "clang")
     992             :         return 2;
     993             :     break;
     994             :   }
     995             :   case AT_NoThreadSafetyAnalysis: {
     996          42 :     if (Name == "no_thread_safety_analysis" && SyntaxUsed == 0 && Scope == "")
     997             :         return 0;
     998           0 :     if (Name == "no_thread_safety_analysis" && SyntaxUsed == 1 && Scope == "clang")
     999             :         return 1;
    1000           0 :     if (Name == "no_thread_safety_analysis" && SyntaxUsed == 2 && Scope == "clang")
    1001             :         return 2;
    1002             :     break;
    1003             :   }
    1004             :   case AT_NoThrow: {
    1005       29767 :     if (Name == "nothrow" && SyntaxUsed == 0 && Scope == "")
    1006             :         return 0;
    1007           2 :     if (Name == "nothrow" && SyntaxUsed == 1 && Scope == "gnu")
    1008             :         return 1;
    1009           2 :     if (Name == "nothrow" && SyntaxUsed == 3 && Scope == "")
    1010             :         return 2;
    1011             :     break;
    1012             :   }
    1013             :   case AT_NonNull: {
    1014      122128 :     if (Name == "nonnull" && SyntaxUsed == 0 && Scope == "")
    1015             :         return 0;
    1016           1 :     if (Name == "nonnull" && SyntaxUsed == 1 && Scope == "gnu")
    1017             :         return 1;
    1018             :     break;
    1019             :   }
    1020             :   case AT_NotTailCalled: {
    1021           9 :     if (Name == "not_tail_called" && SyntaxUsed == 0 && Scope == "")
    1022             :         return 0;
    1023           5 :     if (Name == "not_tail_called" && SyntaxUsed == 1 && Scope == "clang")
    1024             :         return 1;
    1025           0 :     if (Name == "not_tail_called" && SyntaxUsed == 2 && Scope == "clang")
    1026             :         return 2;
    1027             :     break;
    1028             :   }
    1029             :   case AT_ObjCBoxable: {
    1030          56 :     if (Name == "objc_boxable" && SyntaxUsed == 0 && Scope == "")
    1031             :         return 0;
    1032           0 :     if (Name == "objc_boxable" && SyntaxUsed == 1 && Scope == "clang")
    1033             :         return 1;
    1034           0 :     if (Name == "objc_boxable" && SyntaxUsed == 2 && Scope == "clang")
    1035             :         return 2;
    1036             :     break;
    1037             :   }
    1038             :   case AT_ObjCBridge: {
    1039          45 :     if (Name == "objc_bridge" && SyntaxUsed == 0 && Scope == "")
    1040             :         return 0;
    1041           0 :     if (Name == "objc_bridge" && SyntaxUsed == 1 && Scope == "clang")
    1042             :         return 1;
    1043           0 :     if (Name == "objc_bridge" && SyntaxUsed == 2 && Scope == "clang")
    1044             :         return 2;
    1045             :     break;
    1046             :   }
    1047             :   case AT_ObjCBridgeMutable: {
    1048           5 :     if (Name == "objc_bridge_mutable" && SyntaxUsed == 0 && Scope == "")
    1049             :         return 0;
    1050           0 :     if (Name == "objc_bridge_mutable" && SyntaxUsed == 1 && Scope == "clang")
    1051             :         return 1;
    1052           0 :     if (Name == "objc_bridge_mutable" && SyntaxUsed == 2 && Scope == "clang")
    1053             :         return 2;
    1054             :     break;
    1055             :   }
    1056             :   case AT_ObjCBridgeRelated: {
    1057          26 :     if (Name == "objc_bridge_related" && SyntaxUsed == 0 && Scope == "")
    1058             :         return 0;
    1059           2 :     if (Name == "objc_bridge_related" && SyntaxUsed == 1 && Scope == "clang")
    1060             :         return 1;
    1061           2 :     if (Name == "objc_bridge_related" && SyntaxUsed == 2 && Scope == "clang")
    1062             :         return 2;
    1063             :     break;
    1064             :   }
    1065             :   case AT_ObjCDesignatedInitializer: {
    1066          26 :     if (Name == "objc_designated_initializer" && SyntaxUsed == 0 && Scope == "")
    1067             :         return 0;
    1068           0 :     if (Name == "objc_designated_initializer" && SyntaxUsed == 1 && Scope == "clang")
    1069             :         return 1;
    1070           0 :     if (Name == "objc_designated_initializer" && SyntaxUsed == 2 && Scope == "clang")
    1071             :         return 2;
    1072             :     break;
    1073             :   }
    1074             :   case AT_ObjCException: {
    1075          28 :     if (Name == "objc_exception" && SyntaxUsed == 0 && Scope == "")
    1076             :         return 0;
    1077           2 :     if (Name == "objc_exception" && SyntaxUsed == 1 && Scope == "clang")
    1078             :         return 1;
    1079           2 :     if (Name == "objc_exception" && SyntaxUsed == 2 && Scope == "clang")
    1080             :         return 2;
    1081             :     break;
    1082             :   }
    1083             :   case AT_ObjCExplicitProtocolImpl: {
    1084           9 :     if (Name == "objc_protocol_requires_explicit_implementation" && SyntaxUsed == 0 && Scope == "")
    1085             :         return 0;
    1086           2 :     if (Name == "objc_protocol_requires_explicit_implementation" && SyntaxUsed == 1 && Scope == "clang")
    1087             :         return 1;
    1088           2 :     if (Name == "objc_protocol_requires_explicit_implementation" && SyntaxUsed == 2 && Scope == "clang")
    1089             :         return 2;
    1090             :     break;
    1091             :   }
    1092             :   case AT_ObjCGC: {
    1093           0 :     if (Name == "objc_gc" && SyntaxUsed == 0 && Scope == "")
    1094             :         return 0;
    1095           0 :     if (Name == "objc_gc" && SyntaxUsed == 1 && Scope == "clang")
    1096             :         return 1;
    1097           0 :     if (Name == "objc_gc" && SyntaxUsed == 2 && Scope == "clang")
    1098             :         return 2;
    1099             :     break;
    1100             :   }
    1101             :   case AT_ObjCIndependentClass: {
    1102           3 :     if (Name == "objc_independent_class" && SyntaxUsed == 0 && Scope == "")
    1103             :         return 0;
    1104           0 :     if (Name == "objc_independent_class" && SyntaxUsed == 1 && Scope == "clang")
    1105             :         return 1;
    1106           0 :     if (Name == "objc_independent_class" && SyntaxUsed == 2 && Scope == "clang")
    1107             :         return 2;
    1108             :     break;
    1109             :   }
    1110             :   case AT_ObjCKindOf: {
    1111           0 :     if (Name == "__kindof" && SyntaxUsed == 5 && Scope == "")
    1112             :         return 0;
    1113             :     break;
    1114             :   }
    1115             :   case AT_ObjCMethodFamily: {
    1116          11 :     if (Name == "objc_method_family" && SyntaxUsed == 0 && Scope == "")
    1117             :         return 0;
    1118           0 :     if (Name == "objc_method_family" && SyntaxUsed == 1 && Scope == "clang")
    1119             :         return 1;
    1120           0 :     if (Name == "objc_method_family" && SyntaxUsed == 2 && Scope == "clang")
    1121             :         return 2;
    1122             :     break;
    1123             :   }
    1124             :   case AT_ObjCNSObject: {
    1125          13 :     if (Name == "NSObject" && SyntaxUsed == 0 && Scope == "")
    1126             :         return 0;
    1127           0 :     if (Name == "NSObject" && SyntaxUsed == 1 && Scope == "clang")
    1128             :         return 1;
    1129           0 :     if (Name == "NSObject" && SyntaxUsed == 2 && Scope == "clang")
    1130             :         return 2;
    1131             :     break;
    1132             :   }
    1133             :   case AT_ObjCOwnership: {
    1134           0 :     if (Name == "objc_ownership" && SyntaxUsed == 0 && Scope == "")
    1135             :         return 0;
    1136           0 :     if (Name == "objc_ownership" && SyntaxUsed == 1 && Scope == "clang")
    1137             :         return 1;
    1138           0 :     if (Name == "objc_ownership" && SyntaxUsed == 2 && Scope == "clang")
    1139             :         return 2;
    1140             :     break;
    1141             :   }
    1142             :   case AT_ObjCPreciseLifetime: {
    1143           9 :     if (Name == "objc_precise_lifetime" && SyntaxUsed == 0 && Scope == "")
    1144             :         return 0;
    1145           0 :     if (Name == "objc_precise_lifetime" && SyntaxUsed == 1 && Scope == "clang")
    1146             :         return 1;
    1147           0 :     if (Name == "objc_precise_lifetime" && SyntaxUsed == 2 && Scope == "clang")
    1148             :         return 2;
    1149             :     break;
    1150             :   }
    1151             :   case AT_ObjCRequiresPropertyDefs: {
    1152           4 :     if (Name == "objc_requires_property_definitions" && SyntaxUsed == 0 && Scope == "")
    1153             :         return 0;
    1154           0 :     if (Name == "objc_requires_property_definitions" && SyntaxUsed == 1 && Scope == "clang")
    1155             :         return 1;
    1156           0 :     if (Name == "objc_requires_property_definitions" && SyntaxUsed == 2 && Scope == "clang")
    1157             :         return 2;
    1158             :     break;
    1159             :   }
    1160             :   case AT_ObjCRequiresSuper: {
    1161          44 :     if (Name == "objc_requires_super" && SyntaxUsed == 0 && Scope == "")
    1162             :         return 0;
    1163           0 :     if (Name == "objc_requires_super" && SyntaxUsed == 1 && Scope == "clang")
    1164             :         return 1;
    1165           0 :     if (Name == "objc_requires_super" && SyntaxUsed == 2 && Scope == "clang")
    1166             :         return 2;
    1167             :     break;
    1168             :   }
    1169             :   case AT_ObjCReturnsInnerPointer: {
    1170          24 :     if (Name == "objc_returns_inner_pointer" && SyntaxUsed == 0 && Scope == "")
    1171             :         return 0;
    1172           4 :     if (Name == "objc_returns_inner_pointer" && SyntaxUsed == 1 && Scope == "clang")
    1173             :         return 1;
    1174           4 :     if (Name == "objc_returns_inner_pointer" && SyntaxUsed == 2 && Scope == "clang")
    1175             :         return 2;
    1176             :     break;
    1177             :   }
    1178             :   case AT_ObjCRootClass: {
    1179         157 :     if (Name == "objc_root_class" && SyntaxUsed == 0 && Scope == "")
    1180             :         return 0;
    1181           0 :     if (Name == "objc_root_class" && SyntaxUsed == 1 && Scope == "clang")
    1182             :         return 1;
    1183           0 :     if (Name == "objc_root_class" && SyntaxUsed == 2 && Scope == "clang")
    1184             :         return 2;
    1185             :     break;
    1186             :   }
    1187             :   case AT_ObjCRuntimeName: {
    1188          28 :     if (Name == "objc_runtime_name" && SyntaxUsed == 0 && Scope == "")
    1189             :         return 0;
    1190           2 :     if (Name == "objc_runtime_name" && SyntaxUsed == 1 && Scope == "clang")
    1191             :         return 1;
    1192           2 :     if (Name == "objc_runtime_name" && SyntaxUsed == 2 && Scope == "clang")
    1193             :         return 2;
    1194             :     break;
    1195             :   }
    1196             :   case AT_ObjCRuntimeVisible: {
    1197           3 :     if (Name == "objc_runtime_visible" && SyntaxUsed == 0 && Scope == "")
    1198             :         return 0;
    1199           0 :     if (Name == "objc_runtime_visible" && SyntaxUsed == 1 && Scope == "clang")
    1200             :         return 1;
    1201           0 :     if (Name == "objc_runtime_visible" && SyntaxUsed == 2 && Scope == "clang")
    1202             :         return 2;
    1203             :     break;
    1204             :   }
    1205             :   case AT_ObjCSubclassingRestricted: {
    1206          14 :     if (Name == "objc_subclassing_restricted" && SyntaxUsed == 0 && Scope == "")
    1207             :         return 0;
    1208           0 :     if (Name == "objc_subclassing_restricted" && SyntaxUsed == 1 && Scope == "clang")
    1209             :         return 1;
    1210           0 :     if (Name == "objc_subclassing_restricted" && SyntaxUsed == 2 && Scope == "clang")
    1211             :         return 2;
    1212             :     break;
    1213             :   }
    1214             :   case AT_OpenCLAccess: {
    1215           4 :     if (Name == "__read_only" && SyntaxUsed == 5 && Scope == "")
    1216             :         return 0;
    1217        5472 :     if (Name == "read_only" && SyntaxUsed == 5 && Scope == "")
    1218             :         return 1;
    1219           4 :     if (Name == "__write_only" && SyntaxUsed == 5 && Scope == "")
    1220             :         return 2;
    1221        3052 :     if (Name == "write_only" && SyntaxUsed == 5 && Scope == "")
    1222             :         return 3;
    1223           3 :     if (Name == "__read_write" && SyntaxUsed == 5 && Scope == "")
    1224             :         return 4;
    1225        4028 :     if (Name == "read_write" && SyntaxUsed == 5 && Scope == "")
    1226             :         return 5;
    1227             :     break;
    1228             :   }
    1229             :   case AT_OpenCLConstantAddressSpace: {
    1230           0 :     if (Name == "__constant" && SyntaxUsed == 5 && Scope == "")
    1231             :         return 0;
    1232           0 :     if (Name == "constant" && SyntaxUsed == 5 && Scope == "")
    1233             :         return 1;
    1234             :     break;
    1235             :   }
    1236             :   case AT_OpenCLGenericAddressSpace: {
    1237           0 :     if (Name == "__generic" && SyntaxUsed == 5 && Scope == "")
    1238             :         return 0;
    1239           0 :     if (Name == "generic" && SyntaxUsed == 5 && Scope == "")
    1240             :         return 1;
    1241             :     break;
    1242             :   }
    1243             :   case AT_OpenCLGlobalAddressSpace: {
    1244           0 :     if (Name == "__global" && SyntaxUsed == 5 && Scope == "")
    1245             :         return 0;
    1246           0 :     if (Name == "global" && SyntaxUsed == 5 && Scope == "")
    1247             :         return 1;
    1248             :     break;
    1249             :   }
    1250             :   case AT_OpenCLIntelReqdSubGroupSize: {
    1251           4 :     if (Name == "intel_reqd_sub_group_size" && SyntaxUsed == 0 && Scope == "")
    1252             :         return 0;
    1253             :     break;
    1254             :   }
    1255             :   case AT_OpenCLKernel: {
    1256          77 :     if (Name == "__kernel" && SyntaxUsed == 5 && Scope == "")
    1257             :         return 0;
    1258         477 :     if (Name == "kernel" && SyntaxUsed == 5 && Scope == "")
    1259             :         return 1;
    1260             :     break;
    1261             :   }
    1262             :   case AT_OpenCLLocalAddressSpace: {
    1263           0 :     if (Name == "__local" && SyntaxUsed == 5 && Scope == "")
    1264             :         return 0;
    1265           0 :     if (Name == "local" && SyntaxUsed == 5 && Scope == "")
    1266             :         return 1;
    1267             :     break;
    1268             :   }
    1269             :   case AT_OpenCLNoSVM: {
    1270           0 :     if (Name == "nosvm" && SyntaxUsed == 0 && Scope == "")
    1271             :         return 0;
    1272             :     break;
    1273             :   }
    1274             :   case AT_OpenCLPrivateAddressSpace: {
    1275           0 :     if (Name == "__private" && SyntaxUsed == 5 && Scope == "")
    1276             :         return 0;
    1277           0 :     if (Name == "private" && SyntaxUsed == 5 && Scope == "")
    1278             :         return 1;
    1279             :     break;
    1280             :   }
    1281             :   case AT_OpenCLUnrollHint: {
    1282           0 :     if (Name == "opencl_unroll_hint" && SyntaxUsed == 0 && Scope == "")
    1283             :         return 0;
    1284             :     break;
    1285             :   }
    1286             :   case AT_OptimizeNone: {
    1287          68 :     if (Name == "optnone" && SyntaxUsed == 0 && Scope == "")
    1288             :         return 0;
    1289           5 :     if (Name == "optnone" && SyntaxUsed == 1 && Scope == "clang")
    1290             :         return 1;
    1291           0 :     if (Name == "optnone" && SyntaxUsed == 2 && Scope == "clang")
    1292             :         return 2;
    1293             :     break;
    1294             :   }
    1295             :   case AT_Overloadable: {
    1296      278097 :     if (Name == "overloadable" && SyntaxUsed == 0 && Scope == "")
    1297             :         return 0;
    1298           2 :     if (Name == "overloadable" && SyntaxUsed == 1 && Scope == "clang")
    1299             :         return 1;
    1300           2 :     if (Name == "overloadable" && SyntaxUsed == 2 && Scope == "clang")
    1301             :         return 2;
    1302             :     break;
    1303             :   }
    1304             :   case AT_Ownership: {
    1305          30 :     if (Name == "ownership_holds" && SyntaxUsed == 0 && Scope == "")
    1306             :         return 0;
    1307           0 :     if (Name == "ownership_holds" && SyntaxUsed == 1 && Scope == "clang")
    1308             :         return 1;
    1309           0 :     if (Name == "ownership_holds" && SyntaxUsed == 2 && Scope == "clang")
    1310             :         return 2;
    1311          31 :     if (Name == "ownership_returns" && SyntaxUsed == 0 && Scope == "")
    1312             :         return 3;
    1313           2 :     if (Name == "ownership_returns" && SyntaxUsed == 1 && Scope == "clang")
    1314             :         return 4;
    1315           2 :     if (Name == "ownership_returns" && SyntaxUsed == 2 && Scope == "clang")
    1316             :         return 5;
    1317          23 :     if (Name == "ownership_takes" && SyntaxUsed == 0 && Scope == "")
    1318             :         return 6;
    1319           0 :     if (Name == "ownership_takes" && SyntaxUsed == 1 && Scope == "clang")
    1320             :         return 7;
    1321           0 :     if (Name == "ownership_takes" && SyntaxUsed == 2 && Scope == "clang")
    1322             :         return 8;
    1323             :     break;
    1324             :   }
    1325             :   case AT_Packed: {
    1326        4608 :     if (Name == "packed" && SyntaxUsed == 0 && Scope == "")
    1327             :         return 0;
    1328           1 :     if (Name == "packed" && SyntaxUsed == 1 && Scope == "gnu")
    1329             :         return 1;
    1330             :     break;
    1331             :   }
    1332             :   case AT_ParamTypestate: {
    1333           7 :     if (Name == "param_typestate" && SyntaxUsed == 0 && Scope == "")
    1334             :         return 0;
    1335           0 :     if (Name == "param_typestate" && SyntaxUsed == 1 && Scope == "clang")
    1336             :         return 1;
    1337             :     break;
    1338             :   }
    1339             :   case AT_Pascal: {
    1340           0 :     if (Name == "pascal" && SyntaxUsed == 0 && Scope == "")
    1341             :         return 0;
    1342           0 :     if (Name == "pascal" && SyntaxUsed == 1 && Scope == "clang")
    1343             :         return 1;
    1344           0 :     if (Name == "pascal" && SyntaxUsed == 2 && Scope == "clang")
    1345             :         return 2;
    1346           0 :     if (Name == "__pascal" && SyntaxUsed == 5 && Scope == "")
    1347             :         return 3;
    1348           0 :     if (Name == "_pascal" && SyntaxUsed == 5 && Scope == "")
    1349             :         return 4;
    1350             :     break;
    1351             :   }
    1352             :   case AT_PassObjectSize: {
    1353         106 :     if (Name == "pass_object_size" && SyntaxUsed == 0 && Scope == "")
    1354             :         return 0;
    1355           0 :     if (Name == "pass_object_size" && SyntaxUsed == 1 && Scope == "clang")
    1356             :         return 1;
    1357           0 :     if (Name == "pass_object_size" && SyntaxUsed == 2 && Scope == "clang")
    1358             :         return 2;
    1359             :     break;
    1360             :   }
    1361             :   case AT_Pcs: {
    1362           0 :     if (Name == "pcs" && SyntaxUsed == 0 && Scope == "")
    1363             :         return 0;
    1364           0 :     if (Name == "pcs" && SyntaxUsed == 1 && Scope == "gnu")
    1365             :         return 1;
    1366             :     break;
    1367             :   }
    1368             :   case AT_PragmaClangBSSSection: {
    1369             :     break;
    1370             :   }
    1371             :   case AT_PragmaClangDataSection: {
    1372             :     break;
    1373             :   }
    1374             :   case AT_PragmaClangRodataSection: {
    1375             :     break;
    1376             :   }
    1377             :   case AT_PragmaClangTextSection: {
    1378             :     break;
    1379             :   }
    1380             :   case AT_PreserveAll: {
    1381           0 :     if (Name == "preserve_all" && SyntaxUsed == 0 && Scope == "")
    1382             :         return 0;
    1383           0 :     if (Name == "preserve_all" && SyntaxUsed == 1 && Scope == "clang")
    1384             :         return 1;
    1385           0 :     if (Name == "preserve_all" && SyntaxUsed == 2 && Scope == "clang")
    1386             :         return 2;
    1387             :     break;
    1388             :   }
    1389             :   case AT_PreserveMost: {
    1390           0 :     if (Name == "preserve_most" && SyntaxUsed == 0 && Scope == "")
    1391             :         return 0;
    1392           0 :     if (Name == "preserve_most" && SyntaxUsed == 1 && Scope == "clang")
    1393             :         return 1;
    1394           0 :     if (Name == "preserve_most" && SyntaxUsed == 2 && Scope == "clang")
    1395             :         return 2;
    1396             :     break;
    1397             :   }
    1398             :   case AT_PtGuardedBy: {
    1399         121 :     if (Name == "pt_guarded_by" && SyntaxUsed == 0 && Scope == "")
    1400             :         return 0;
    1401             :     break;
    1402             :   }
    1403             :   case AT_PtGuardedVar: {
    1404          11 :     if (Name == "pt_guarded_var" && SyntaxUsed == 0 && Scope == "")
    1405             :         return 0;
    1406           0 :     if (Name == "pt_guarded_var" && SyntaxUsed == 1 && Scope == "clang")
    1407             :         return 1;
    1408             :     break;
    1409             :   }
    1410             :   case AT_Ptr32: {
    1411           0 :     if (Name == "__ptr32" && SyntaxUsed == 5 && Scope == "")
    1412             :         return 0;
    1413             :     break;
    1414             :   }
    1415             :   case AT_Ptr64: {
    1416           0 :     if (Name == "__ptr64" && SyntaxUsed == 5 && Scope == "")
    1417             :         return 0;
    1418             :     break;
    1419             :   }
    1420             :   case AT_Pure: {
    1421       21443 :     if (Name == "pure" && SyntaxUsed == 0 && Scope == "")
    1422             :         return 0;
    1423           1 :     if (Name == "pure" && SyntaxUsed == 1 && Scope == "gnu")
    1424             :         return 1;
    1425             :     break;
    1426             :   }
    1427             :   case AT_RegCall: {
    1428           0 :     if (Name == "regcall" && SyntaxUsed == 0 && Scope == "")
    1429             :         return 0;
    1430           0 :     if (Name == "regcall" && SyntaxUsed == 1 && Scope == "gnu")
    1431             :         return 1;
    1432           0 :     if (Name == "__regcall" && SyntaxUsed == 5 && Scope == "")
    1433             :         return 2;
    1434             :     break;
    1435             :   }
    1436             :   case AT_Regparm: {
    1437           0 :     if (Name == "regparm" && SyntaxUsed == 0 && Scope == "")
    1438             :         return 0;
    1439           0 :     if (Name == "regparm" && SyntaxUsed == 1 && Scope == "gnu")
    1440             :         return 1;
    1441             :     break;
    1442             :   }
    1443             :   case AT_ReleaseCapability: {
    1444           6 :     if (Name == "release_capability" && SyntaxUsed == 0 && Scope == "")
    1445             :         return 0;
    1446           0 :     if (Name == "release_capability" && SyntaxUsed == 1 && Scope == "clang")
    1447             :         return 1;
    1448           6 :     if (Name == "release_shared_capability" && SyntaxUsed == 0 && Scope == "")
    1449             :         return 2;
    1450           0 :     if (Name == "release_shared_capability" && SyntaxUsed == 1 && Scope == "clang")
    1451             :         return 3;
    1452           1 :     if (Name == "release_generic_capability" && SyntaxUsed == 0 && Scope == "")
    1453             :         return 4;
    1454           0 :     if (Name == "release_generic_capability" && SyntaxUsed == 1 && Scope == "clang")
    1455             :         return 5;
    1456         282 :     if (Name == "unlock_function" && SyntaxUsed == 0 && Scope == "")
    1457             :         return 6;
    1458           0 :     if (Name == "unlock_function" && SyntaxUsed == 1 && Scope == "clang")
    1459             :         return 7;
    1460             :     break;
    1461             :   }
    1462             :   case AT_RenderScriptKernel: {
    1463           1 :     if (Name == "kernel" && SyntaxUsed == 0 && Scope == "")
    1464             :         return 0;
    1465             :     break;
    1466             :   }
    1467             :   case AT_ReqdWorkGroupSize: {
    1468           8 :     if (Name == "reqd_work_group_size" && SyntaxUsed == 0 && Scope == "")
    1469             :         return 0;
    1470             :     break;
    1471             :   }
    1472             :   case AT_RequireConstantInit: {
    1473         155 :     if (Name == "require_constant_initialization" && SyntaxUsed == 0 && Scope == "")
    1474             :         return 0;
    1475           0 :     if (Name == "require_constant_initialization" && SyntaxUsed == 1 && Scope == "clang")
    1476             :         return 1;
    1477             :     break;
    1478             :   }
    1479             :   case AT_RequiresCapability: {
    1480          27 :     if (Name == "requires_capability" && SyntaxUsed == 0 && Scope == "")
    1481             :         return 0;
    1482           0 :     if (Name == "requires_capability" && SyntaxUsed == 1 && Scope == "clang")
    1483             :         return 1;
    1484         513 :     if (Name == "exclusive_locks_required" && SyntaxUsed == 0 && Scope == "")
    1485             :         return 2;
    1486           0 :     if (Name == "exclusive_locks_required" && SyntaxUsed == 1 && Scope == "clang")
    1487             :         return 3;
    1488           2 :     if (Name == "requires_shared_capability" && SyntaxUsed == 0 && Scope == "")
    1489             :         return 4;
    1490           0 :     if (Name == "requires_shared_capability" && SyntaxUsed == 1 && Scope == "clang")
    1491             :         return 5;
    1492         128 :     if (Name == "shared_locks_required" && SyntaxUsed == 0 && Scope == "")
    1493             :         return 6;
    1494           0 :     if (Name == "shared_locks_required" && SyntaxUsed == 1 && Scope == "clang")
    1495             :         return 7;
    1496             :     break;
    1497             :   }
    1498             :   case AT_Restrict: {
    1499           1 :     if (Name == "restrict" && SyntaxUsed == 3 && Scope == "")
    1500             :         return 0;
    1501        4393 :     if (Name == "malloc" && SyntaxUsed == 0 && Scope == "")
    1502             :         return 1;
    1503           0 :     if (Name == "malloc" && SyntaxUsed == 1 && Scope == "gnu")
    1504             :         return 2;
    1505             :     break;
    1506             :   }
    1507             :   case AT_ReturnTypestate: {
    1508          10 :     if (Name == "return_typestate" && SyntaxUsed == 0 && Scope == "")
    1509             :         return 0;
    1510           0 :     if (Name == "return_typestate" && SyntaxUsed == 1 && Scope == "clang")
    1511             :         return 1;
    1512             :     break;
    1513             :   }
    1514             :   case AT_ReturnsNonNull: {
    1515          14 :     if (Name == "returns_nonnull" && SyntaxUsed == 0 && Scope == "")
    1516             :         return 0;
    1517           0 :     if (Name == "returns_nonnull" && SyntaxUsed == 1 && Scope == "gnu")
    1518             :         return 1;
    1519             :     break;
    1520             :   }
    1521             :   case AT_ReturnsTwice: {
    1522           9 :     if (Name == "returns_twice" && SyntaxUsed == 0 && Scope == "")
    1523             :         return 0;
    1524           0 :     if (Name == "returns_twice" && SyntaxUsed == 1 && Scope == "gnu")
    1525             :         return 1;
    1526             :     break;
    1527             :   }
    1528             :   case AT_SPtr: {
    1529           0 :     if (Name == "__sptr" && SyntaxUsed == 5 && Scope == "")
    1530             :         return 0;
    1531             :     break;
    1532             :   }
    1533             :   case AT_ScopedLockable: {
    1534          33 :     if (Name == "scoped_lockable" && SyntaxUsed == 0 && Scope == "")
    1535             :         return 0;
    1536           0 :     if (Name == "scoped_lockable" && SyntaxUsed == 1 && Scope == "clang")
    1537             :         return 1;
    1538             :     break;
    1539             :   }
    1540             :   case AT_Section: {
    1541          45 :     if (Name == "section" && SyntaxUsed == 0 && Scope == "")
    1542             :         return 0;
    1543           0 :     if (Name == "section" && SyntaxUsed == 1 && Scope == "gnu")
    1544             :         return 1;
    1545           8 :     if (Name == "allocate" && SyntaxUsed == 3 && Scope == "")
    1546             :         return 2;
    1547             :     break;
    1548             :   }
    1549             :   case AT_SelectAny: {
    1550          57 :     if (Name == "selectany" && SyntaxUsed == 3 && Scope == "")
    1551             :         return 0;
    1552           3 :     if (Name == "selectany" && SyntaxUsed == 0 && Scope == "")
    1553             :         return 1;
    1554           0 :     if (Name == "selectany" && SyntaxUsed == 1 && Scope == "gnu")
    1555             :         return 2;
    1556             :     break;
    1557             :   }
    1558             :   case AT_Sentinel: {
    1559         199 :     if (Name == "sentinel" && SyntaxUsed == 0 && Scope == "")
    1560             :         return 0;
    1561           0 :     if (Name == "sentinel" && SyntaxUsed == 1 && Scope == "gnu")
    1562             :         return 1;
    1563             :     break;
    1564             :   }
    1565             :   case AT_SetTypestate: {
    1566           9 :     if (Name == "set_typestate" && SyntaxUsed == 0 && Scope == "")
    1567             :         return 0;
    1568           0 :     if (Name == "set_typestate" && SyntaxUsed == 1 && Scope == "clang")
    1569             :         return 1;
    1570             :     break;
    1571             :   }
    1572             :   case AT_SharedTrylockFunction: {
    1573          64 :     if (Name == "shared_trylock_function" && SyntaxUsed == 0 && Scope == "")
    1574             :         return 0;
    1575             :     break;
    1576             :   }
    1577             :   case AT_StdCall: {
    1578           2 :     if (Name == "stdcall" && SyntaxUsed == 0 && Scope == "")
    1579             :         return 0;
    1580           0 :     if (Name == "stdcall" && SyntaxUsed == 1 && Scope == "gnu")
    1581             :         return 1;
    1582           0 :     if (Name == "__stdcall" && SyntaxUsed == 5 && Scope == "")
    1583             :         return 2;
    1584           0 :     if (Name == "_stdcall" && SyntaxUsed == 5 && Scope == "")
    1585             :         return 3;
    1586             :     break;
    1587             :   }
    1588             :   case AT_Suppress: {
    1589           8 :     if (Name == "suppress" && SyntaxUsed == 1 && Scope == "gsl")
    1590             :         return 0;
    1591             :     break;
    1592             :   }
    1593             :   case AT_SwiftCall: {
    1594           0 :     if (Name == "swiftcall" && SyntaxUsed == 0 && Scope == "")
    1595             :         return 0;
    1596           0 :     if (Name == "swiftcall" && SyntaxUsed == 1 && Scope == "clang")
    1597             :         return 1;
    1598           0 :     if (Name == "swiftcall" && SyntaxUsed == 2 && Scope == "clang")
    1599             :         return 2;
    1600             :     break;
    1601             :   }
    1602             :   case AT_SwiftContext: {
    1603          58 :     if (Name == "swift_context" && SyntaxUsed == 0 && Scope == "")
    1604             :         return 0;
    1605           2 :     if (Name == "swift_context" && SyntaxUsed == 1 && Scope == "clang")
    1606             :         return 1;
    1607           2 :     if (Name == "swift_context" && SyntaxUsed == 2 && Scope == "clang")
    1608             :         return 2;
    1609             :     break;
    1610             :   }
    1611             :   case AT_SwiftErrorResult: {
    1612          34 :     if (Name == "swift_error_result" && SyntaxUsed == 0 && Scope == "")
    1613             :         return 0;
    1614           0 :     if (Name == "swift_error_result" && SyntaxUsed == 1 && Scope == "clang")
    1615             :         return 1;
    1616           0 :     if (Name == "swift_error_result" && SyntaxUsed == 2 && Scope == "clang")
    1617             :         return 2;
    1618             :     break;
    1619             :   }
    1620             :   case AT_SwiftIndirectResult: {
    1621          68 :     if (Name == "swift_indirect_result" && SyntaxUsed == 0 && Scope == "")
    1622             :         return 0;
    1623           0 :     if (Name == "swift_indirect_result" && SyntaxUsed == 1 && Scope == "clang")
    1624             :         return 1;
    1625           0 :     if (Name == "swift_indirect_result" && SyntaxUsed == 2 && Scope == "clang")
    1626             :         return 2;
    1627             :     break;
    1628             :   }
    1629             :   case AT_SysVABI: {
    1630           0 :     if (Name == "sysv_abi" && SyntaxUsed == 0 && Scope == "")
    1631             :         return 0;
    1632           0 :     if (Name == "sysv_abi" && SyntaxUsed == 1 && Scope == "gnu")
    1633             :         return 1;
    1634             :     break;
    1635             :   }
    1636             :   case AT_TLSModel: {
    1637          14 :     if (Name == "tls_model" && SyntaxUsed == 0 && Scope == "")
    1638             :         return 0;
    1639           1 :     if (Name == "tls_model" && SyntaxUsed == 1 && Scope == "gnu")
    1640             :         return 1;
    1641             :     break;
    1642             :   }
    1643             :   case AT_Target: {
    1644      492796 :     if (Name == "target" && SyntaxUsed == 0 && Scope == "")
    1645             :         return 0;
    1646           0 :     if (Name == "target" && SyntaxUsed == 1 && Scope == "gnu")
    1647             :         return 1;
    1648             :     break;
    1649             :   }
    1650             :   case AT_TestTypestate: {
    1651           5 :     if (Name == "test_typestate" && SyntaxUsed == 0 && Scope == "")
    1652             :         return 0;
    1653           0 :     if (Name == "test_typestate" && SyntaxUsed == 1 && Scope == "clang")
    1654             :         return 1;
    1655             :     break;
    1656             :   }
    1657             :   case AT_ThisCall: {
    1658           0 :     if (Name == "thiscall" && SyntaxUsed == 0 && Scope == "")
    1659             :         return 0;
    1660           0 :     if (Name == "thiscall" && SyntaxUsed == 1 && Scope == "gnu")
    1661             :         return 1;
    1662           0 :     if (Name == "__thiscall" && SyntaxUsed == 5 && Scope == "")
    1663             :         return 2;
    1664           0 :     if (Name == "_thiscall" && SyntaxUsed == 5 && Scope == "")
    1665             :         return 3;
    1666             :     break;
    1667             :   }
    1668             :   case AT_Thread: {
    1669          45 :     if (Name == "thread" && SyntaxUsed == 3 && Scope == "")
    1670             :         return 0;
    1671             :     break;
    1672             :   }
    1673             :   case AT_TransparentUnion: {
    1674          36 :     if (Name == "transparent_union" && SyntaxUsed == 0 && Scope == "")
    1675             :         return 0;
    1676           0 :     if (Name == "transparent_union" && SyntaxUsed == 1 && Scope == "gnu")
    1677             :         return 1;
    1678             :     break;
    1679             :   }
    1680             :   case AT_TrivialABI: {
    1681          34 :     if (Name == "trivial_abi" && SyntaxUsed == 0 && Scope == "")
    1682             :         return 0;
    1683           1 :     if (Name == "trivial_abi" && SyntaxUsed == 1 && Scope == "clang")
    1684             :         return 1;
    1685             :     break;
    1686             :   }
    1687             :   case AT_TryAcquireCapability: {
    1688           9 :     if (Name == "try_acquire_capability" && SyntaxUsed == 0 && Scope == "")
    1689             :         return 0;
    1690           0 :     if (Name == "try_acquire_capability" && SyntaxUsed == 1 && Scope == "clang")
    1691             :         return 1;
    1692           5 :     if (Name == "try_acquire_shared_capability" && SyntaxUsed == 0 && Scope == "")
    1693             :         return 2;
    1694           0 :     if (Name == "try_acquire_shared_capability" && SyntaxUsed == 1 && Scope == "clang")
    1695             :         return 3;
    1696             :     break;
    1697             :   }
    1698             :   case AT_TypeNonNull: {
    1699           0 :     if (Name == "_Nonnull" && SyntaxUsed == 5 && Scope == "")
    1700             :         return 0;
    1701             :     break;
    1702             :   }
    1703             :   case AT_TypeNullUnspecified: {
    1704           0 :     if (Name == "_Null_unspecified" && SyntaxUsed == 5 && Scope == "")
    1705             :         return 0;
    1706             :     break;
    1707             :   }
    1708             :   case AT_TypeNullable: {
    1709           0 :     if (Name == "_Nullable" && SyntaxUsed == 5 && Scope == "")
    1710             :         return 0;
    1711             :     break;
    1712             :   }
    1713             :   case AT_TypeTagForDatatype: {
    1714         164 :     if (Name == "type_tag_for_datatype" && SyntaxUsed == 0 && Scope == "")
    1715             :         return 0;
    1716           4 :     if (Name == "type_tag_for_datatype" && SyntaxUsed == 1 && Scope == "clang")
    1717             :         return 1;
    1718           4 :     if (Name == "type_tag_for_datatype" && SyntaxUsed == 2 && Scope == "clang")
    1719             :         return 2;
    1720             :     break;
    1721             :   }
    1722             :   case AT_TypeVisibility: {
    1723          30 :     if (Name == "type_visibility" && SyntaxUsed == 0 && Scope == "")
    1724             :         return 0;
    1725           0 :     if (Name == "type_visibility" && SyntaxUsed == 1 && Scope == "clang")
    1726             :         return 1;
    1727           0 :     if (Name == "type_visibility" && SyntaxUsed == 2 && Scope == "clang")
    1728             :         return 2;
    1729             :     break;
    1730             :   }
    1731             :   case AT_UPtr: {
    1732           0 :     if (Name == "__uptr" && SyntaxUsed == 5 && Scope == "")
    1733             :         return 0;
    1734             :     break;
    1735             :   }
    1736             :   case AT_Unavailable: {
    1737         897 :     if (Name == "unavailable" && SyntaxUsed == 0 && Scope == "")
    1738             :         return 0;
    1739           1 :     if (Name == "unavailable" && SyntaxUsed == 1 && Scope == "clang")
    1740             :         return 1;
    1741           1 :     if (Name == "unavailable" && SyntaxUsed == 2 && Scope == "clang")
    1742             :         return 2;
    1743             :     break;
    1744             :   }
    1745             :   case AT_Unused: {
    1746          34 :     if (Name == "maybe_unused" && SyntaxUsed == 1 && Scope == "")
    1747             :         return 0;
    1748        2479 :     if (Name == "unused" && SyntaxUsed == 0 && Scope == "")
    1749             :         return 1;
    1750           2 :     if (Name == "unused" && SyntaxUsed == 1 && Scope == "gnu")
    1751             :         return 2;
    1752          15 :     if (Name == "maybe_unused" && SyntaxUsed == 2 && Scope == "")
    1753             :         return 3;
    1754             :     break;
    1755             :   }
    1756             :   case AT_Used: {
    1757          96 :     if (Name == "used" && SyntaxUsed == 0 && Scope == "")
    1758             :         return 0;
    1759           0 :     if (Name == "used" && SyntaxUsed == 1 && Scope == "gnu")
    1760             :         return 1;
    1761             :     break;
    1762             :   }
    1763             :   case AT_Uuid: {
    1764         121 :     if (Name == "uuid" && SyntaxUsed == 3 && Scope == "")
    1765             :         return 0;
    1766          45 :     if (Name == "uuid" && SyntaxUsed == 4 && Scope == "")
    1767             :         return 1;
    1768             :     break;
    1769             :   }
    1770             :   case AT_VecReturn: {
    1771           4 :     if (Name == "vecreturn" && SyntaxUsed == 0 && Scope == "")
    1772             :         return 0;
    1773           0 :     if (Name == "vecreturn" && SyntaxUsed == 1 && Scope == "clang")
    1774             :         return 1;
    1775             :     break;
    1776             :   }
    1777             :   case AT_VecTypeHint: {
    1778           4 :     if (Name == "vec_type_hint" && SyntaxUsed == 0 && Scope == "")
    1779             :         return 0;
    1780             :     break;
    1781             :   }
    1782             :   case AT_VectorCall: {
    1783           0 :     if (Name == "vectorcall" && SyntaxUsed == 0 && Scope == "")
    1784             :         return 0;
    1785           0 :     if (Name == "vectorcall" && SyntaxUsed == 1 && Scope == "clang")
    1786             :         return 1;
    1787           0 :     if (Name == "vectorcall" && SyntaxUsed == 2 && Scope == "clang")
    1788             :         return 2;
    1789           0 :     if (Name == "__vectorcall" && SyntaxUsed == 5 && Scope == "")
    1790             :         return 3;
    1791           0 :     if (Name == "_vectorcall" && SyntaxUsed == 5 && Scope == "")
    1792             :         return 4;
    1793             :     break;
    1794             :   }
    1795             :   case AT_VectorSize: {
    1796           0 :     if (Name == "vector_size" && SyntaxUsed == 0 && Scope == "")
    1797             :         return 0;
    1798           0 :     if (Name == "vector_size" && SyntaxUsed == 1 && Scope == "gnu")
    1799             :         return 1;
    1800             :     break;
    1801             :   }
    1802             :   case AT_Visibility: {
    1803       43307 :     if (Name == "visibility" && SyntaxUsed == 0 && Scope == "")
    1804             :         return 0;
    1805           1 :     if (Name == "visibility" && SyntaxUsed == 1 && Scope == "gnu")
    1806             :         return 1;
    1807             :     break;
    1808             :   }
    1809             :   case AT_WarnUnused: {
    1810           6 :     if (Name == "warn_unused" && SyntaxUsed == 0 && Scope == "")
    1811             :         return 0;
    1812           0 :     if (Name == "warn_unused" && SyntaxUsed == 1 && Scope == "gnu")
    1813             :         return 1;
    1814             :     break;
    1815             :   }
    1816             :   case AT_WarnUnusedResult: {
    1817          26 :     if (Name == "nodiscard" && SyntaxUsed == 1 && Scope == "")
    1818             :         return 0;
    1819           9 :     if (Name == "nodiscard" && SyntaxUsed == 2 && Scope == "")
    1820             :         return 1;
    1821        4461 :     if (Name == "warn_unused_result" && SyntaxUsed == 1 && Scope == "clang")
    1822             :         return 2;
    1823        4454 :     if (Name == "warn_unused_result" && SyntaxUsed == 0 && Scope == "")
    1824             :         return 3;
    1825           1 :     if (Name == "warn_unused_result" && SyntaxUsed == 1 && Scope == "gnu")
    1826             :         return 4;
    1827             :     break;
    1828             :   }
    1829             :   case AT_Weak: {
    1830        1042 :     if (Name == "weak" && SyntaxUsed == 0 && Scope == "")
    1831             :         return 0;
    1832           0 :     if (Name == "weak" && SyntaxUsed == 1 && Scope == "gnu")
    1833             :         return 1;
    1834             :     break;
    1835             :   }
    1836             :   case AT_WeakImport: {
    1837          44 :     if (Name == "weak_import" && SyntaxUsed == 0 && Scope == "")
    1838             :         return 0;
    1839           0 :     if (Name == "weak_import" && SyntaxUsed == 1 && Scope == "clang")
    1840             :         return 1;
    1841           0 :     if (Name == "weak_import" && SyntaxUsed == 2 && Scope == "clang")
    1842             :         return 2;
    1843             :     break;
    1844             :   }
    1845             :   case AT_WeakRef: {
    1846       23461 :     if (Name == "weakref" && SyntaxUsed == 0 && Scope == "")
    1847             :         return 0;
    1848           0 :     if (Name == "weakref" && SyntaxUsed == 1 && Scope == "gnu")
    1849             :         return 1;
    1850             :     break;
    1851             :   }
    1852             :   case AT_WorkGroupSizeHint: {
    1853           4 :     if (Name == "work_group_size_hint" && SyntaxUsed == 0 && Scope == "")
    1854             :         return 0;
    1855             :     break;
    1856             :   }
    1857             :   case AT_X86ForceAlignArgPointer: {
    1858           6 :     if (Name == "force_align_arg_pointer" && SyntaxUsed == 0 && Scope == "")
    1859             :         return 0;
    1860           0 :     if (Name == "force_align_arg_pointer" && SyntaxUsed == 1 && Scope == "gnu")
    1861             :         return 1;
    1862             :     break;
    1863             :   }
    1864             :   case AT_XRayInstrument: {
    1865          28 :     if (Name == "xray_always_instrument" && SyntaxUsed == 0 && Scope == "")
    1866             :         return 0;
    1867          27 :     if (Name == "xray_always_instrument" && SyntaxUsed == 1 && Scope == "clang")
    1868             :         return 1;
    1869           0 :     if (Name == "xray_always_instrument" && SyntaxUsed == 2 && Scope == "clang")
    1870             :         return 2;
    1871          15 :     if (Name == "xray_never_instrument" && SyntaxUsed == 0 && Scope == "")
    1872             :         return 3;
    1873          15 :     if (Name == "xray_never_instrument" && SyntaxUsed == 1 && Scope == "clang")
    1874             :         return 4;
    1875           0 :     if (Name == "xray_never_instrument" && SyntaxUsed == 2 && Scope == "clang")
    1876             :         return 5;
    1877             :     break;
    1878             :   }
    1879             :   case AT_XRayLogArgs: {
    1880           9 :     if (Name == "xray_log_args" && SyntaxUsed == 0 && Scope == "")
    1881             :         return 0;
    1882           4 :     if (Name == "xray_log_args" && SyntaxUsed == 1 && Scope == "clang")
    1883             :         return 1;
    1884           0 :     if (Name == "xray_log_args" && SyntaxUsed == 2 && Scope == "clang")
    1885             :         return 2;
    1886             :     break;
    1887             :   }
    1888             :   }
    1889             :   return 0;

Generated by: LCOV version 1.13