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

Generated by: LCOV version 1.13