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

Generated by: LCOV version 1.13