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

Generated by: LCOV version 1.13