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

Generated by: LCOV version 1.13