Line data Source code
1 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2 : |* *|
3 : |* Attribute deserialization code *|
4 : |* *|
5 : |* Automatically generated file, do not edit! *|
6 : |* *|
7 : \*===----------------------------------------------------------------------===*/
8 :
9 39388 : switch (Kind) {
10 0 : case attr::AMDGPUFlatWorkGroupSize: {
11 0 : bool isInherited = Record.readInt();
12 0 : bool isImplicit = Record.readInt();
13 0 : unsigned Spelling = Record.readInt();
14 0 : unsigned min = Record.readInt();
15 0 : unsigned max = Record.readInt();
16 : New = new (Context) AMDGPUFlatWorkGroupSizeAttr(Range, Context, min, max, Spelling);
17 : cast<InheritableAttr>(New)->setInherited(isInherited);
18 : New->setImplicit(isImplicit);
19 : break;
20 : }
21 0 : case attr::AMDGPUNumSGPR: {
22 0 : bool isInherited = Record.readInt();
23 0 : bool isImplicit = Record.readInt();
24 0 : unsigned Spelling = Record.readInt();
25 0 : unsigned numSGPR = Record.readInt();
26 : New = new (Context) AMDGPUNumSGPRAttr(Range, Context, numSGPR, Spelling);
27 : cast<InheritableAttr>(New)->setInherited(isInherited);
28 : New->setImplicit(isImplicit);
29 : break;
30 : }
31 0 : case attr::AMDGPUNumVGPR: {
32 0 : bool isInherited = Record.readInt();
33 0 : bool isImplicit = Record.readInt();
34 0 : unsigned Spelling = Record.readInt();
35 0 : unsigned numVGPR = Record.readInt();
36 : New = new (Context) AMDGPUNumVGPRAttr(Range, Context, numVGPR, Spelling);
37 : cast<InheritableAttr>(New)->setInherited(isInherited);
38 : New->setImplicit(isImplicit);
39 : break;
40 : }
41 0 : case attr::AMDGPUWavesPerEU: {
42 0 : bool isInherited = Record.readInt();
43 0 : bool isImplicit = Record.readInt();
44 0 : unsigned Spelling = Record.readInt();
45 0 : unsigned min = Record.readInt();
46 0 : unsigned max = Record.readInt();
47 : New = new (Context) AMDGPUWavesPerEUAttr(Range, Context, min, max, Spelling);
48 : cast<InheritableAttr>(New)->setInherited(isInherited);
49 : New->setImplicit(isImplicit);
50 : break;
51 : }
52 0 : case attr::ARMInterrupt: {
53 0 : bool isInherited = Record.readInt();
54 0 : bool isImplicit = Record.readInt();
55 0 : unsigned Spelling = Record.readInt();
56 0 : ARMInterruptAttr::InterruptType interrupt(static_cast<ARMInterruptAttr::InterruptType>(Record.readInt()));
57 : New = new (Context) ARMInterruptAttr(Range, Context, interrupt, Spelling);
58 : cast<InheritableAttr>(New)->setInherited(isInherited);
59 : New->setImplicit(isImplicit);
60 : break;
61 : }
62 0 : case attr::AVRInterrupt: {
63 0 : bool isInherited = Record.readInt();
64 0 : bool isImplicit = Record.readInt();
65 0 : unsigned Spelling = Record.readInt();
66 : New = new (Context) AVRInterruptAttr(Range, Context, Spelling);
67 : cast<InheritableAttr>(New)->setInherited(isInherited);
68 : New->setImplicit(isImplicit);
69 : break;
70 : }
71 0 : case attr::AVRSignal: {
72 0 : bool isInherited = Record.readInt();
73 0 : bool isImplicit = Record.readInt();
74 0 : unsigned Spelling = Record.readInt();
75 : New = new (Context) AVRSignalAttr(Range, Context, Spelling);
76 : cast<InheritableAttr>(New)->setInherited(isInherited);
77 : New->setImplicit(isImplicit);
78 : break;
79 : }
80 1 : case attr::AbiTag: {
81 1 : bool isImplicit = Record.readInt();
82 1 : unsigned Spelling = Record.readInt();
83 1 : unsigned tagsSize = Record.readInt();
84 : SmallVector<StringRef, 4> tags;
85 : tags.reserve(tagsSize);
86 1 : SmallVector<std::string, 4> tagsStorage;
87 : tagsStorage.reserve(tagsSize);
88 4 : for (unsigned i = 0; i != tagsSize; ++i)
89 6 : tagsStorage.push_back(Record.readString());
90 4 : for (unsigned i = 0; i != tagsSize; ++i)
91 6 : tags.push_back(tagsStorage[i]);
92 1 : New = new (Context) AbiTagAttr(Range, Context, tags.data(), tagsSize, Spelling);
93 : New->setImplicit(isImplicit);
94 : break;
95 : }
96 3 : case attr::AcquireCapability: {
97 3 : bool isInherited = Record.readInt();
98 3 : bool isImplicit = Record.readInt();
99 3 : unsigned Spelling = Record.readInt();
100 3 : unsigned argsSize = Record.readInt();
101 : SmallVector<Expr *, 4> args;
102 : args.reserve(argsSize);
103 4 : for (unsigned i = 0; i != argsSize; ++i)
104 1 : args.push_back(Record.readExpr());
105 3 : New = new (Context) AcquireCapabilityAttr(Range, Context, args.data(), argsSize, Spelling);
106 : cast<InheritableAttr>(New)->setInherited(isInherited);
107 : New->setImplicit(isImplicit);
108 : break;
109 : }
110 1 : case attr::AcquiredAfter: {
111 1 : bool isInherited = Record.readInt();
112 1 : bool isImplicit = Record.readInt();
113 1 : unsigned Spelling = Record.readInt();
114 1 : unsigned argsSize = Record.readInt();
115 : SmallVector<Expr *, 4> args;
116 : args.reserve(argsSize);
117 2 : for (unsigned i = 0; i != argsSize; ++i)
118 1 : args.push_back(Record.readExpr());
119 1 : New = new (Context) AcquiredAfterAttr(Range, Context, args.data(), argsSize, Spelling);
120 : cast<InheritableAttr>(New)->setInherited(isInherited);
121 : New->setImplicit(isImplicit);
122 : break;
123 : }
124 0 : case attr::AcquiredBefore: {
125 0 : bool isInherited = Record.readInt();
126 0 : bool isImplicit = Record.readInt();
127 0 : unsigned Spelling = Record.readInt();
128 0 : unsigned argsSize = Record.readInt();
129 : SmallVector<Expr *, 4> args;
130 : args.reserve(argsSize);
131 0 : for (unsigned i = 0; i != argsSize; ++i)
132 0 : args.push_back(Record.readExpr());
133 0 : New = new (Context) AcquiredBeforeAttr(Range, Context, args.data(), argsSize, Spelling);
134 : cast<InheritableAttr>(New)->setInherited(isInherited);
135 : New->setImplicit(isImplicit);
136 : break;
137 : }
138 7 : case attr::AddressSpace: {
139 7 : bool isImplicit = Record.readInt();
140 7 : unsigned Spelling = Record.readInt();
141 7 : int addressSpace = Record.readInt();
142 : New = new (Context) AddressSpaceAttr(Range, Context, addressSpace, Spelling);
143 : New->setImplicit(isImplicit);
144 : break;
145 : }
146 2 : case attr::Alias: {
147 2 : bool isImplicit = Record.readInt();
148 2 : unsigned Spelling = Record.readInt();
149 : std::string aliasee= Record.readString();
150 2 : New = new (Context) AliasAttr(Range, Context, aliasee, Spelling);
151 : New->setImplicit(isImplicit);
152 : break;
153 : }
154 0 : case attr::AlignMac68k: {
155 0 : bool isInherited = Record.readInt();
156 0 : bool isImplicit = Record.readInt();
157 0 : unsigned Spelling = Record.readInt();
158 : New = new (Context) AlignMac68kAttr(Range, Context, Spelling);
159 : cast<InheritableAttr>(New)->setInherited(isInherited);
160 : New->setImplicit(isImplicit);
161 : break;
162 : }
163 0 : case attr::AlignValue: {
164 0 : bool isImplicit = Record.readInt();
165 0 : unsigned Spelling = Record.readInt();
166 : Expr * alignment = Record.readExpr();
167 : New = new (Context) AlignValueAttr(Range, Context, alignment, Spelling);
168 : New->setImplicit(isImplicit);
169 : break;
170 : }
171 182 : case attr::Aligned: {
172 182 : bool isInherited = Record.readInt();
173 182 : bool isImplicit = Record.readInt();
174 182 : unsigned Spelling = Record.readInt();
175 182 : bool isalignmentExpr = Record.readInt();
176 : void *alignmentPtr;
177 182 : if (isalignmentExpr)
178 : alignmentPtr = Record.readExpr();
179 : else
180 : alignmentPtr = Record.getTypeSourceInfo();
181 : New = new (Context) AlignedAttr(Range, Context, isalignmentExpr, alignmentPtr, Spelling);
182 : cast<InheritableAttr>(New)->setInherited(isInherited);
183 : New->setImplicit(isImplicit);
184 : break;
185 : }
186 2 : case attr::AllocAlign: {
187 2 : bool isInherited = Record.readInt();
188 2 : bool isImplicit = Record.readInt();
189 2 : unsigned Spelling = Record.readInt();
190 2 : ParamIdx paramIndex = ParamIdx::deserialize(Record.readInt());
191 2 : New = new (Context) AllocAlignAttr(Range, Context, paramIndex, Spelling);
192 : cast<InheritableAttr>(New)->setInherited(isInherited);
193 : New->setImplicit(isImplicit);
194 : break;
195 : }
196 4 : case attr::AllocSize: {
197 4 : bool isInherited = Record.readInt();
198 4 : bool isImplicit = Record.readInt();
199 4 : unsigned Spelling = Record.readInt();
200 8 : ParamIdx elemSizeParam = ParamIdx::deserialize(Record.readInt());
201 4 : ParamIdx numElemsParam = ParamIdx::deserialize(Record.readInt());
202 4 : New = new (Context) AllocSizeAttr(Range, Context, elemSizeParam, numElemsParam, Spelling);
203 : cast<InheritableAttr>(New)->setInherited(isInherited);
204 : New->setImplicit(isImplicit);
205 : break;
206 : }
207 0 : case attr::AlwaysDestroy: {
208 0 : bool isInherited = Record.readInt();
209 0 : bool isImplicit = Record.readInt();
210 0 : unsigned Spelling = Record.readInt();
211 : New = new (Context) AlwaysDestroyAttr(Range, Context, Spelling);
212 : cast<InheritableAttr>(New)->setInherited(isInherited);
213 : New->setImplicit(isImplicit);
214 : break;
215 : }
216 5912 : case attr::AlwaysInline: {
217 5912 : bool isInherited = Record.readInt();
218 5912 : bool isImplicit = Record.readInt();
219 5912 : unsigned Spelling = Record.readInt();
220 : New = new (Context) AlwaysInlineAttr(Range, Context, Spelling);
221 : cast<InheritableAttr>(New)->setInherited(isInherited);
222 : New->setImplicit(isImplicit);
223 : break;
224 : }
225 0 : case attr::AnalyzerNoReturn: {
226 0 : bool isInherited = Record.readInt();
227 0 : bool isImplicit = Record.readInt();
228 0 : unsigned Spelling = Record.readInt();
229 : New = new (Context) AnalyzerNoReturnAttr(Range, Context, Spelling);
230 : cast<InheritableAttr>(New)->setInherited(isInherited);
231 : New->setImplicit(isImplicit);
232 : break;
233 : }
234 0 : case attr::Annotate: {
235 0 : bool isInherited = Record.readInt();
236 0 : bool isImplicit = Record.readInt();
237 0 : unsigned Spelling = Record.readInt();
238 : std::string annotation= Record.readString();
239 0 : New = new (Context) AnnotateAttr(Range, Context, annotation, Spelling);
240 : cast<InheritableAttr>(New)->setInherited(isInherited);
241 : New->setImplicit(isImplicit);
242 : break;
243 : }
244 0 : case attr::AnyX86Interrupt: {
245 0 : bool isInherited = Record.readInt();
246 0 : bool isImplicit = Record.readInt();
247 0 : unsigned Spelling = Record.readInt();
248 : New = new (Context) AnyX86InterruptAttr(Range, Context, Spelling);
249 : cast<InheritableAttr>(New)->setInherited(isInherited);
250 : New->setImplicit(isImplicit);
251 : break;
252 : }
253 0 : case attr::AnyX86NoCallerSavedRegisters: {
254 0 : bool isInherited = Record.readInt();
255 0 : bool isImplicit = Record.readInt();
256 0 : unsigned Spelling = Record.readInt();
257 : New = new (Context) AnyX86NoCallerSavedRegistersAttr(Range, Context, Spelling);
258 : cast<InheritableAttr>(New)->setInherited(isInherited);
259 : New->setImplicit(isImplicit);
260 : break;
261 : }
262 0 : case attr::AnyX86NoCfCheck: {
263 0 : bool isInherited = Record.readInt();
264 0 : bool isImplicit = Record.readInt();
265 0 : unsigned Spelling = Record.readInt();
266 : New = new (Context) AnyX86NoCfCheckAttr(Range, Context, Spelling);
267 : cast<InheritableAttr>(New)->setInherited(isInherited);
268 : New->setImplicit(isImplicit);
269 : break;
270 : }
271 0 : case attr::ArcWeakrefUnavailable: {
272 0 : bool isInherited = Record.readInt();
273 0 : bool isImplicit = Record.readInt();
274 0 : unsigned Spelling = Record.readInt();
275 : New = new (Context) ArcWeakrefUnavailableAttr(Range, Context, Spelling);
276 : cast<InheritableAttr>(New)->setInherited(isInherited);
277 : New->setImplicit(isImplicit);
278 : break;
279 : }
280 4 : case attr::ArgumentWithTypeTag: {
281 4 : bool isInherited = Record.readInt();
282 4 : bool isImplicit = Record.readInt();
283 4 : unsigned Spelling = Record.readInt();
284 : IdentifierInfo * argumentKind = Record.getIdentifierInfo();
285 8 : ParamIdx argumentIdx = ParamIdx::deserialize(Record.readInt());
286 8 : ParamIdx typeTagIdx = ParamIdx::deserialize(Record.readInt());
287 4 : bool isPointer = Record.readInt();
288 4 : New = new (Context) ArgumentWithTypeTagAttr(Range, Context, argumentKind, argumentIdx, typeTagIdx, isPointer, Spelling);
289 : cast<InheritableAttr>(New)->setInherited(isInherited);
290 : New->setImplicit(isImplicit);
291 : break;
292 : }
293 0 : case attr::Artificial: {
294 0 : bool isInherited = Record.readInt();
295 0 : bool isImplicit = Record.readInt();
296 0 : unsigned Spelling = Record.readInt();
297 : New = new (Context) ArtificialAttr(Range, Context, Spelling);
298 : cast<InheritableAttr>(New)->setInherited(isInherited);
299 : New->setImplicit(isImplicit);
300 : break;
301 : }
302 8 : case attr::AsmLabel: {
303 8 : bool isInherited = Record.readInt();
304 8 : bool isImplicit = Record.readInt();
305 8 : unsigned Spelling = Record.readInt();
306 : std::string label= Record.readString();
307 8 : New = new (Context) AsmLabelAttr(Range, Context, label, Spelling);
308 : cast<InheritableAttr>(New)->setInherited(isInherited);
309 : New->setImplicit(isImplicit);
310 : break;
311 : }
312 0 : case attr::AssertCapability: {
313 0 : bool isInherited = Record.readInt();
314 0 : bool isImplicit = Record.readInt();
315 0 : unsigned Spelling = Record.readInt();
316 0 : unsigned argsSize = Record.readInt();
317 : SmallVector<Expr *, 4> args;
318 : args.reserve(argsSize);
319 0 : for (unsigned i = 0; i != argsSize; ++i)
320 0 : args.push_back(Record.readExpr());
321 0 : New = new (Context) AssertCapabilityAttr(Range, Context, args.data(), argsSize, Spelling);
322 : cast<InheritableAttr>(New)->setInherited(isInherited);
323 : New->setImplicit(isImplicit);
324 : break;
325 : }
326 0 : case attr::AssertExclusiveLock: {
327 0 : bool isInherited = Record.readInt();
328 0 : bool isImplicit = Record.readInt();
329 0 : unsigned Spelling = Record.readInt();
330 0 : unsigned argsSize = Record.readInt();
331 : SmallVector<Expr *, 4> args;
332 : args.reserve(argsSize);
333 0 : for (unsigned i = 0; i != argsSize; ++i)
334 0 : args.push_back(Record.readExpr());
335 0 : New = new (Context) AssertExclusiveLockAttr(Range, Context, args.data(), argsSize, Spelling);
336 : cast<InheritableAttr>(New)->setInherited(isInherited);
337 : New->setImplicit(isImplicit);
338 : break;
339 : }
340 0 : case attr::AssertSharedLock: {
341 0 : bool isInherited = Record.readInt();
342 0 : bool isImplicit = Record.readInt();
343 0 : unsigned Spelling = Record.readInt();
344 0 : unsigned argsSize = Record.readInt();
345 : SmallVector<Expr *, 4> args;
346 : args.reserve(argsSize);
347 0 : for (unsigned i = 0; i != argsSize; ++i)
348 0 : args.push_back(Record.readExpr());
349 0 : New = new (Context) AssertSharedLockAttr(Range, Context, args.data(), argsSize, Spelling);
350 : cast<InheritableAttr>(New)->setInherited(isInherited);
351 : New->setImplicit(isImplicit);
352 : break;
353 : }
354 0 : case attr::AssumeAligned: {
355 0 : bool isInherited = Record.readInt();
356 0 : bool isImplicit = Record.readInt();
357 0 : unsigned Spelling = Record.readInt();
358 : Expr * alignment = Record.readExpr();
359 : Expr * offset = Record.readExpr();
360 : New = new (Context) AssumeAlignedAttr(Range, Context, alignment, offset, Spelling);
361 : cast<InheritableAttr>(New)->setInherited(isInherited);
362 : New->setImplicit(isImplicit);
363 : break;
364 : }
365 4 : case attr::Availability: {
366 4 : bool isInherited = Record.readInt();
367 4 : bool isImplicit = Record.readInt();
368 4 : unsigned Spelling = Record.readInt();
369 : IdentifierInfo * platform = Record.getIdentifierInfo();
370 4 : VersionTuple introduced= Record.readVersionTuple();
371 4 : VersionTuple deprecated= Record.readVersionTuple();
372 4 : VersionTuple obsoleted= Record.readVersionTuple();
373 4 : bool unavailable = Record.readInt();
374 : std::string message= Record.readString();
375 4 : bool strict = Record.readInt();
376 : std::string replacement= Record.readString();
377 4 : New = new (Context) AvailabilityAttr(Range, Context, platform, introduced, deprecated, obsoleted, unavailable, message, strict, replacement, Spelling);
378 : cast<InheritableAttr>(New)->setInherited(isInherited);
379 : New->setImplicit(isImplicit);
380 : break;
381 : }
382 5 : case attr::Blocks: {
383 5 : bool isInherited = Record.readInt();
384 5 : bool isImplicit = Record.readInt();
385 5 : unsigned Spelling = Record.readInt();
386 5 : BlocksAttr::BlockType type(static_cast<BlocksAttr::BlockType>(Record.readInt()));
387 : New = new (Context) BlocksAttr(Range, Context, type, Spelling);
388 : cast<InheritableAttr>(New)->setInherited(isInherited);
389 : New->setImplicit(isImplicit);
390 : break;
391 : }
392 0 : case attr::C11NoReturn: {
393 0 : bool isInherited = Record.readInt();
394 0 : bool isImplicit = Record.readInt();
395 0 : unsigned Spelling = Record.readInt();
396 : New = new (Context) C11NoReturnAttr(Range, Context, Spelling);
397 : cast<InheritableAttr>(New)->setInherited(isInherited);
398 : New->setImplicit(isImplicit);
399 : break;
400 : }
401 0 : case attr::CDecl: {
402 0 : bool isInherited = Record.readInt();
403 0 : bool isImplicit = Record.readInt();
404 0 : unsigned Spelling = Record.readInt();
405 : New = new (Context) CDeclAttr(Range, Context, Spelling);
406 : cast<InheritableAttr>(New)->setInherited(isInherited);
407 : New->setImplicit(isImplicit);
408 : break;
409 : }
410 0 : case attr::CFAuditedTransfer: {
411 0 : bool isInherited = Record.readInt();
412 0 : bool isImplicit = Record.readInt();
413 0 : unsigned Spelling = Record.readInt();
414 : New = new (Context) CFAuditedTransferAttr(Range, Context, Spelling);
415 : cast<InheritableAttr>(New)->setInherited(isInherited);
416 : New->setImplicit(isImplicit);
417 : break;
418 : }
419 0 : case attr::CFConsumed: {
420 0 : bool isInherited = Record.readInt();
421 0 : bool isImplicit = Record.readInt();
422 0 : unsigned Spelling = Record.readInt();
423 : New = new (Context) CFConsumedAttr(Range, Context, Spelling);
424 : cast<InheritableAttr>(New)->setInherited(isInherited);
425 : New->setImplicit(isImplicit);
426 : break;
427 : }
428 0 : case attr::CFReturnsNotRetained: {
429 0 : bool isInherited = Record.readInt();
430 0 : bool isImplicit = Record.readInt();
431 0 : unsigned Spelling = Record.readInt();
432 : New = new (Context) CFReturnsNotRetainedAttr(Range, Context, Spelling);
433 : cast<InheritableAttr>(New)->setInherited(isInherited);
434 : New->setImplicit(isImplicit);
435 : break;
436 : }
437 0 : case attr::CFReturnsRetained: {
438 0 : bool isInherited = Record.readInt();
439 0 : bool isImplicit = Record.readInt();
440 0 : unsigned Spelling = Record.readInt();
441 : New = new (Context) CFReturnsRetainedAttr(Range, Context, Spelling);
442 : cast<InheritableAttr>(New)->setInherited(isInherited);
443 : New->setImplicit(isImplicit);
444 : break;
445 : }
446 0 : case attr::CFUnknownTransfer: {
447 0 : bool isInherited = Record.readInt();
448 0 : bool isImplicit = Record.readInt();
449 0 : unsigned Spelling = Record.readInt();
450 : New = new (Context) CFUnknownTransferAttr(Range, Context, Spelling);
451 : cast<InheritableAttr>(New)->setInherited(isInherited);
452 : New->setImplicit(isImplicit);
453 : break;
454 : }
455 0 : case attr::CPUDispatch: {
456 0 : bool isInherited = Record.readInt();
457 0 : bool isImplicit = Record.readInt();
458 0 : unsigned Spelling = Record.readInt();
459 0 : unsigned cpusSize = Record.readInt();
460 : SmallVector<IdentifierInfo *, 4> cpus;
461 : cpus.reserve(cpusSize);
462 0 : for (unsigned i = 0; i != cpusSize; ++i)
463 0 : cpus.push_back(Record.getIdentifierInfo());
464 0 : New = new (Context) CPUDispatchAttr(Range, Context, cpus.data(), cpusSize, Spelling);
465 : cast<InheritableAttr>(New)->setInherited(isInherited);
466 : New->setImplicit(isImplicit);
467 : break;
468 : }
469 0 : case attr::CPUSpecific: {
470 0 : bool isInherited = Record.readInt();
471 0 : bool isImplicit = Record.readInt();
472 0 : unsigned Spelling = Record.readInt();
473 0 : unsigned cpusSize = Record.readInt();
474 : SmallVector<IdentifierInfo *, 4> cpus;
475 : cpus.reserve(cpusSize);
476 0 : for (unsigned i = 0; i != cpusSize; ++i)
477 0 : cpus.push_back(Record.getIdentifierInfo());
478 0 : New = new (Context) CPUSpecificAttr(Range, Context, cpus.data(), cpusSize, Spelling);
479 : cast<InheritableAttr>(New)->setInherited(isInherited);
480 : New->setImplicit(isImplicit);
481 : break;
482 : }
483 0 : case attr::CUDAConstant: {
484 0 : bool isInherited = Record.readInt();
485 0 : bool isImplicit = Record.readInt();
486 0 : unsigned Spelling = Record.readInt();
487 : New = new (Context) CUDAConstantAttr(Range, Context, Spelling);
488 : cast<InheritableAttr>(New)->setInherited(isInherited);
489 : New->setImplicit(isImplicit);
490 : break;
491 : }
492 4 : case attr::CUDADevice: {
493 4 : bool isInherited = Record.readInt();
494 4 : bool isImplicit = Record.readInt();
495 4 : unsigned Spelling = Record.readInt();
496 : New = new (Context) CUDADeviceAttr(Range, Context, Spelling);
497 : cast<InheritableAttr>(New)->setInherited(isInherited);
498 : New->setImplicit(isImplicit);
499 : break;
500 : }
501 1 : case attr::CUDAGlobal: {
502 1 : bool isInherited = Record.readInt();
503 1 : bool isImplicit = Record.readInt();
504 1 : unsigned Spelling = Record.readInt();
505 : New = new (Context) CUDAGlobalAttr(Range, Context, Spelling);
506 : cast<InheritableAttr>(New)->setInherited(isInherited);
507 : New->setImplicit(isImplicit);
508 : break;
509 : }
510 4 : case attr::CUDAHost: {
511 4 : bool isInherited = Record.readInt();
512 4 : bool isImplicit = Record.readInt();
513 4 : unsigned Spelling = Record.readInt();
514 : New = new (Context) CUDAHostAttr(Range, Context, Spelling);
515 : cast<InheritableAttr>(New)->setInherited(isInherited);
516 : New->setImplicit(isImplicit);
517 : break;
518 : }
519 0 : case attr::CUDAInvalidTarget: {
520 0 : bool isInherited = Record.readInt();
521 0 : bool isImplicit = Record.readInt();
522 0 : unsigned Spelling = Record.readInt();
523 : New = new (Context) CUDAInvalidTargetAttr(Range, Context, Spelling);
524 : cast<InheritableAttr>(New)->setInherited(isInherited);
525 : New->setImplicit(isImplicit);
526 : break;
527 : }
528 0 : case attr::CUDALaunchBounds: {
529 0 : bool isInherited = Record.readInt();
530 0 : bool isImplicit = Record.readInt();
531 0 : unsigned Spelling = Record.readInt();
532 : Expr * maxThreads = Record.readExpr();
533 : Expr * minBlocks = Record.readExpr();
534 : New = new (Context) CUDALaunchBoundsAttr(Range, Context, maxThreads, minBlocks, Spelling);
535 : cast<InheritableAttr>(New)->setInherited(isInherited);
536 : New->setImplicit(isImplicit);
537 : break;
538 : }
539 0 : case attr::CUDAShared: {
540 0 : bool isInherited = Record.readInt();
541 0 : bool isImplicit = Record.readInt();
542 0 : unsigned Spelling = Record.readInt();
543 : New = new (Context) CUDASharedAttr(Range, Context, Spelling);
544 : cast<InheritableAttr>(New)->setInherited(isInherited);
545 : New->setImplicit(isImplicit);
546 : break;
547 : }
548 0 : case attr::CXX11NoReturn: {
549 0 : bool isInherited = Record.readInt();
550 0 : bool isImplicit = Record.readInt();
551 0 : unsigned Spelling = Record.readInt();
552 : New = new (Context) CXX11NoReturnAttr(Range, Context, Spelling);
553 : cast<InheritableAttr>(New)->setInherited(isInherited);
554 : New->setImplicit(isImplicit);
555 : break;
556 : }
557 0 : case attr::CallableWhen: {
558 0 : bool isInherited = Record.readInt();
559 0 : bool isImplicit = Record.readInt();
560 0 : unsigned Spelling = Record.readInt();
561 0 : unsigned callableStatesSize = Record.readInt();
562 : SmallVector<CallableWhenAttr::ConsumedState, 4> callableStates;
563 : callableStates.reserve(callableStatesSize);
564 0 : for (unsigned i = callableStatesSize; i; --i)
565 0 : callableStates.push_back(static_cast<CallableWhenAttr::ConsumedState>(Record.readInt()));
566 0 : New = new (Context) CallableWhenAttr(Range, Context, callableStates.data(), callableStatesSize, Spelling);
567 : cast<InheritableAttr>(New)->setInherited(isInherited);
568 : New->setImplicit(isImplicit);
569 : break;
570 : }
571 4 : case attr::Capability: {
572 4 : bool isInherited = Record.readInt();
573 4 : bool isImplicit = Record.readInt();
574 4 : unsigned Spelling = Record.readInt();
575 : std::string name= Record.readString();
576 4 : New = new (Context) CapabilityAttr(Range, Context, name, Spelling);
577 : cast<InheritableAttr>(New)->setInherited(isInherited);
578 : New->setImplicit(isImplicit);
579 : break;
580 : }
581 18856 : case attr::CapturedRecord: {
582 18856 : bool isInherited = Record.readInt();
583 18856 : bool isImplicit = Record.readInt();
584 18856 : unsigned Spelling = Record.readInt();
585 : New = new (Context) CapturedRecordAttr(Range, Context, Spelling);
586 : cast<InheritableAttr>(New)->setInherited(isInherited);
587 : New->setImplicit(isImplicit);
588 : break;
589 : }
590 0 : case attr::CarriesDependency: {
591 0 : bool isInherited = Record.readInt();
592 0 : bool isImplicit = Record.readInt();
593 0 : unsigned Spelling = Record.readInt();
594 : New = new (Context) CarriesDependencyAttr(Range, Context, Spelling);
595 : cast<InheritableAttr>(New)->setInherited(isInherited);
596 : New->setImplicit(isImplicit);
597 : break;
598 : }
599 0 : case attr::Cleanup: {
600 0 : bool isInherited = Record.readInt();
601 0 : bool isImplicit = Record.readInt();
602 0 : unsigned Spelling = Record.readInt();
603 0 : FunctionDecl * functionDecl = Record.GetLocalDeclAs<FunctionDecl >(Record.readInt());
604 : New = new (Context) CleanupAttr(Range, Context, functionDecl, Spelling);
605 : cast<InheritableAttr>(New)->setInherited(isInherited);
606 : New->setImplicit(isImplicit);
607 : break;
608 : }
609 0 : case attr::CodeSeg: {
610 0 : bool isInherited = Record.readInt();
611 0 : bool isImplicit = Record.readInt();
612 0 : unsigned Spelling = Record.readInt();
613 : std::string name= Record.readString();
614 0 : New = new (Context) CodeSegAttr(Range, Context, name, Spelling);
615 : cast<InheritableAttr>(New)->setInherited(isInherited);
616 : New->setImplicit(isImplicit);
617 : break;
618 : }
619 8 : case attr::Cold: {
620 8 : bool isInherited = Record.readInt();
621 8 : bool isImplicit = Record.readInt();
622 8 : unsigned Spelling = Record.readInt();
623 : New = new (Context) ColdAttr(Range, Context, Spelling);
624 : cast<InheritableAttr>(New)->setInherited(isInherited);
625 : New->setImplicit(isImplicit);
626 : break;
627 : }
628 0 : case attr::Common: {
629 0 : bool isInherited = Record.readInt();
630 0 : bool isImplicit = Record.readInt();
631 0 : unsigned Spelling = Record.readInt();
632 : New = new (Context) CommonAttr(Range, Context, Spelling);
633 : cast<InheritableAttr>(New)->setInherited(isInherited);
634 : New->setImplicit(isImplicit);
635 : break;
636 : }
637 62 : case attr::Const: {
638 62 : bool isInherited = Record.readInt();
639 62 : bool isImplicit = Record.readInt();
640 62 : unsigned Spelling = Record.readInt();
641 : New = new (Context) ConstAttr(Range, Context, Spelling);
642 : cast<InheritableAttr>(New)->setInherited(isInherited);
643 : New->setImplicit(isImplicit);
644 : break;
645 : }
646 0 : case attr::Constructor: {
647 0 : bool isInherited = Record.readInt();
648 0 : bool isImplicit = Record.readInt();
649 0 : unsigned Spelling = Record.readInt();
650 0 : int priority = Record.readInt();
651 : New = new (Context) ConstructorAttr(Range, Context, priority, Spelling);
652 : cast<InheritableAttr>(New)->setInherited(isInherited);
653 : New->setImplicit(isImplicit);
654 : break;
655 : }
656 0 : case attr::Consumable: {
657 0 : bool isInherited = Record.readInt();
658 0 : bool isImplicit = Record.readInt();
659 0 : unsigned Spelling = Record.readInt();
660 0 : ConsumableAttr::ConsumedState defaultState(static_cast<ConsumableAttr::ConsumedState>(Record.readInt()));
661 : New = new (Context) ConsumableAttr(Range, Context, defaultState, Spelling);
662 : cast<InheritableAttr>(New)->setInherited(isInherited);
663 : New->setImplicit(isImplicit);
664 : break;
665 : }
666 0 : case attr::ConsumableAutoCast: {
667 0 : bool isInherited = Record.readInt();
668 0 : bool isImplicit = Record.readInt();
669 0 : unsigned Spelling = Record.readInt();
670 : New = new (Context) ConsumableAutoCastAttr(Range, Context, Spelling);
671 : cast<InheritableAttr>(New)->setInherited(isInherited);
672 : New->setImplicit(isImplicit);
673 : break;
674 : }
675 0 : case attr::ConsumableSetOnRead: {
676 0 : bool isInherited = Record.readInt();
677 0 : bool isImplicit = Record.readInt();
678 0 : unsigned Spelling = Record.readInt();
679 : New = new (Context) ConsumableSetOnReadAttr(Range, Context, Spelling);
680 : cast<InheritableAttr>(New)->setInherited(isInherited);
681 : New->setImplicit(isImplicit);
682 : break;
683 : }
684 0 : case attr::Convergent: {
685 0 : bool isInherited = Record.readInt();
686 0 : bool isImplicit = Record.readInt();
687 0 : unsigned Spelling = Record.readInt();
688 : New = new (Context) ConvergentAttr(Range, Context, Spelling);
689 : cast<InheritableAttr>(New)->setInherited(isInherited);
690 : New->setImplicit(isImplicit);
691 : break;
692 : }
693 53 : case attr::DLLExport: {
694 53 : bool isInherited = Record.readInt();
695 53 : bool isImplicit = Record.readInt();
696 53 : unsigned Spelling = Record.readInt();
697 : New = new (Context) DLLExportAttr(Range, Context, Spelling);
698 : cast<InheritableAttr>(New)->setInherited(isInherited);
699 : New->setImplicit(isImplicit);
700 : break;
701 : }
702 0 : case attr::DLLImport: {
703 0 : bool isInherited = Record.readInt();
704 0 : bool isImplicit = Record.readInt();
705 0 : unsigned Spelling = Record.readInt();
706 : New = new (Context) DLLImportAttr(Range, Context, Spelling);
707 : cast<InheritableAttr>(New)->setInherited(isInherited);
708 : New->setImplicit(isImplicit);
709 : break;
710 : }
711 1 : case attr::Deprecated: {
712 1 : bool isInherited = Record.readInt();
713 1 : bool isImplicit = Record.readInt();
714 1 : unsigned Spelling = Record.readInt();
715 : std::string message= Record.readString();
716 : std::string replacement= Record.readString();
717 1 : New = new (Context) DeprecatedAttr(Range, Context, message, replacement, Spelling);
718 : cast<InheritableAttr>(New)->setInherited(isInherited);
719 : New->setImplicit(isImplicit);
720 : break;
721 : }
722 0 : case attr::Destructor: {
723 0 : bool isInherited = Record.readInt();
724 0 : bool isImplicit = Record.readInt();
725 0 : unsigned Spelling = Record.readInt();
726 0 : int priority = Record.readInt();
727 : New = new (Context) DestructorAttr(Range, Context, priority, Spelling);
728 : cast<InheritableAttr>(New)->setInherited(isInherited);
729 : New->setImplicit(isImplicit);
730 : break;
731 : }
732 0 : case attr::DiagnoseIf: {
733 0 : bool isInherited = Record.readInt();
734 0 : bool isImplicit = Record.readInt();
735 0 : unsigned Spelling = Record.readInt();
736 : Expr * cond = Record.readExpr();
737 : std::string message= Record.readString();
738 0 : DiagnoseIfAttr::DiagnosticType diagnosticType(static_cast<DiagnoseIfAttr::DiagnosticType>(Record.readInt()));
739 0 : bool argDependent = Record.readInt();
740 0 : NamedDecl * parent = Record.GetLocalDeclAs<NamedDecl >(Record.readInt());
741 0 : New = new (Context) DiagnoseIfAttr(Range, Context, cond, message, diagnosticType, argDependent, parent, Spelling);
742 : cast<InheritableAttr>(New)->setInherited(isInherited);
743 : New->setImplicit(isImplicit);
744 : break;
745 : }
746 0 : case attr::DisableTailCalls: {
747 0 : bool isInherited = Record.readInt();
748 0 : bool isImplicit = Record.readInt();
749 0 : unsigned Spelling = Record.readInt();
750 : New = new (Context) DisableTailCallsAttr(Range, Context, Spelling);
751 : cast<InheritableAttr>(New)->setInherited(isInherited);
752 : New->setImplicit(isImplicit);
753 : break;
754 : }
755 0 : case attr::EmptyBases: {
756 0 : bool isInherited = Record.readInt();
757 0 : bool isImplicit = Record.readInt();
758 0 : unsigned Spelling = Record.readInt();
759 : New = new (Context) EmptyBasesAttr(Range, Context, Spelling);
760 : cast<InheritableAttr>(New)->setInherited(isInherited);
761 : New->setImplicit(isImplicit);
762 : break;
763 : }
764 6 : case attr::EnableIf: {
765 6 : bool isInherited = Record.readInt();
766 6 : bool isImplicit = Record.readInt();
767 6 : unsigned Spelling = Record.readInt();
768 : Expr * cond = Record.readExpr();
769 : std::string message= Record.readString();
770 6 : New = new (Context) EnableIfAttr(Range, Context, cond, message, Spelling);
771 : cast<InheritableAttr>(New)->setInherited(isInherited);
772 : New->setImplicit(isImplicit);
773 : break;
774 : }
775 2 : case attr::EnumExtensibility: {
776 2 : bool isInherited = Record.readInt();
777 2 : bool isImplicit = Record.readInt();
778 2 : unsigned Spelling = Record.readInt();
779 2 : EnumExtensibilityAttr::Kind extensibility(static_cast<EnumExtensibilityAttr::Kind>(Record.readInt()));
780 : New = new (Context) EnumExtensibilityAttr(Range, Context, extensibility, Spelling);
781 : cast<InheritableAttr>(New)->setInherited(isInherited);
782 : New->setImplicit(isImplicit);
783 : break;
784 : }
785 0 : case attr::ExcludeFromExplicitInstantiation: {
786 0 : bool isInherited = Record.readInt();
787 0 : bool isImplicit = Record.readInt();
788 0 : unsigned Spelling = Record.readInt();
789 : New = new (Context) ExcludeFromExplicitInstantiationAttr(Range, Context, Spelling);
790 : cast<InheritableAttr>(New)->setInherited(isInherited);
791 : New->setImplicit(isImplicit);
792 : break;
793 : }
794 0 : case attr::ExclusiveTrylockFunction: {
795 0 : bool isInherited = Record.readInt();
796 0 : bool isImplicit = Record.readInt();
797 0 : unsigned Spelling = Record.readInt();
798 : Expr * successValue = Record.readExpr();
799 0 : unsigned argsSize = Record.readInt();
800 : SmallVector<Expr *, 4> args;
801 : args.reserve(argsSize);
802 0 : for (unsigned i = 0; i != argsSize; ++i)
803 0 : args.push_back(Record.readExpr());
804 0 : New = new (Context) ExclusiveTrylockFunctionAttr(Range, Context, successValue, args.data(), argsSize, Spelling);
805 : cast<InheritableAttr>(New)->setInherited(isInherited);
806 : New->setImplicit(isImplicit);
807 : break;
808 : }
809 0 : case attr::ExternalSourceSymbol: {
810 0 : bool isInherited = Record.readInt();
811 0 : bool isImplicit = Record.readInt();
812 0 : unsigned Spelling = Record.readInt();
813 : std::string language= Record.readString();
814 : std::string definedIn= Record.readString();
815 0 : bool generatedDeclaration = Record.readInt();
816 0 : New = new (Context) ExternalSourceSymbolAttr(Range, Context, language, definedIn, generatedDeclaration, Spelling);
817 : cast<InheritableAttr>(New)->setInherited(isInherited);
818 : New->setImplicit(isImplicit);
819 : break;
820 : }
821 4 : case attr::FallThrough: {
822 4 : bool isImplicit = Record.readInt();
823 4 : unsigned Spelling = Record.readInt();
824 : New = new (Context) FallThroughAttr(Range, Context, Spelling);
825 : New->setImplicit(isImplicit);
826 : break;
827 : }
828 0 : case attr::FastCall: {
829 0 : bool isInherited = Record.readInt();
830 0 : bool isImplicit = Record.readInt();
831 0 : unsigned Spelling = Record.readInt();
832 : New = new (Context) FastCallAttr(Range, Context, Spelling);
833 : cast<InheritableAttr>(New)->setInherited(isInherited);
834 : New->setImplicit(isImplicit);
835 : break;
836 : }
837 0 : case attr::Final: {
838 0 : bool isInherited = Record.readInt();
839 0 : bool isImplicit = Record.readInt();
840 0 : unsigned Spelling = Record.readInt();
841 : New = new (Context) FinalAttr(Range, Context, Spelling);
842 : cast<InheritableAttr>(New)->setInherited(isInherited);
843 : New->setImplicit(isImplicit);
844 : break;
845 : }
846 2 : case attr::FlagEnum: {
847 2 : bool isInherited = Record.readInt();
848 2 : bool isImplicit = Record.readInt();
849 2 : unsigned Spelling = Record.readInt();
850 : New = new (Context) FlagEnumAttr(Range, Context, Spelling);
851 : cast<InheritableAttr>(New)->setInherited(isInherited);
852 : New->setImplicit(isImplicit);
853 : break;
854 : }
855 0 : case attr::Flatten: {
856 0 : bool isInherited = Record.readInt();
857 0 : bool isImplicit = Record.readInt();
858 0 : unsigned Spelling = Record.readInt();
859 : New = new (Context) FlattenAttr(Range, Context, Spelling);
860 : cast<InheritableAttr>(New)->setInherited(isInherited);
861 : New->setImplicit(isImplicit);
862 : break;
863 : }
864 27 : case attr::Format: {
865 27 : bool isInherited = Record.readInt();
866 27 : bool isImplicit = Record.readInt();
867 27 : unsigned Spelling = Record.readInt();
868 : IdentifierInfo * type = Record.getIdentifierInfo();
869 27 : int formatIdx = Record.readInt();
870 27 : int firstArg = Record.readInt();
871 : New = new (Context) FormatAttr(Range, Context, type, formatIdx, firstArg, Spelling);
872 : cast<InheritableAttr>(New)->setInherited(isInherited);
873 : New->setImplicit(isImplicit);
874 : break;
875 : }
876 2 : case attr::FormatArg: {
877 2 : bool isInherited = Record.readInt();
878 2 : bool isImplicit = Record.readInt();
879 2 : unsigned Spelling = Record.readInt();
880 2 : ParamIdx formatIdx = ParamIdx::deserialize(Record.readInt());
881 2 : New = new (Context) FormatArgAttr(Range, Context, formatIdx, Spelling);
882 : cast<InheritableAttr>(New)->setInherited(isInherited);
883 : New->setImplicit(isImplicit);
884 : break;
885 : }
886 0 : case attr::GNUInline: {
887 0 : bool isInherited = Record.readInt();
888 0 : bool isImplicit = Record.readInt();
889 0 : unsigned Spelling = Record.readInt();
890 : New = new (Context) GNUInlineAttr(Range, Context, Spelling);
891 : cast<InheritableAttr>(New)->setInherited(isInherited);
892 : New->setImplicit(isImplicit);
893 : break;
894 : }
895 3 : case attr::GuardedBy: {
896 3 : bool isInherited = Record.readInt();
897 3 : bool isImplicit = Record.readInt();
898 3 : unsigned Spelling = Record.readInt();
899 : Expr * arg = Record.readExpr();
900 : New = new (Context) GuardedByAttr(Range, Context, arg, Spelling);
901 : cast<InheritableAttr>(New)->setInherited(isInherited);
902 : New->setImplicit(isImplicit);
903 : break;
904 : }
905 1 : case attr::GuardedVar: {
906 1 : bool isInherited = Record.readInt();
907 1 : bool isImplicit = Record.readInt();
908 1 : unsigned Spelling = Record.readInt();
909 : New = new (Context) GuardedVarAttr(Range, Context, Spelling);
910 : cast<InheritableAttr>(New)->setInherited(isInherited);
911 : New->setImplicit(isImplicit);
912 : break;
913 : }
914 0 : case attr::Hot: {
915 0 : bool isInherited = Record.readInt();
916 0 : bool isImplicit = Record.readInt();
917 0 : unsigned Spelling = Record.readInt();
918 : New = new (Context) HotAttr(Range, Context, Spelling);
919 : cast<InheritableAttr>(New)->setInherited(isInherited);
920 : New->setImplicit(isImplicit);
921 : break;
922 : }
923 2 : case attr::IBAction: {
924 2 : bool isInherited = Record.readInt();
925 2 : bool isImplicit = Record.readInt();
926 2 : unsigned Spelling = Record.readInt();
927 : New = new (Context) IBActionAttr(Range, Context, Spelling);
928 : cast<InheritableAttr>(New)->setInherited(isInherited);
929 : New->setImplicit(isImplicit);
930 : break;
931 : }
932 3 : case attr::IBOutlet: {
933 3 : bool isInherited = Record.readInt();
934 3 : bool isImplicit = Record.readInt();
935 3 : unsigned Spelling = Record.readInt();
936 : New = new (Context) IBOutletAttr(Range, Context, Spelling);
937 : cast<InheritableAttr>(New)->setInherited(isInherited);
938 : New->setImplicit(isImplicit);
939 : break;
940 : }
941 1 : case attr::IBOutletCollection: {
942 1 : bool isInherited = Record.readInt();
943 1 : bool isImplicit = Record.readInt();
944 1 : unsigned Spelling = Record.readInt();
945 : TypeSourceInfo * interface_ = Record.getTypeSourceInfo();
946 : New = new (Context) IBOutletCollectionAttr(Range, Context, interface_, Spelling);
947 : cast<InheritableAttr>(New)->setInherited(isInherited);
948 : New->setImplicit(isImplicit);
949 : break;
950 : }
951 0 : case attr::IFunc: {
952 0 : bool isImplicit = Record.readInt();
953 0 : unsigned Spelling = Record.readInt();
954 : std::string resolver= Record.readString();
955 0 : New = new (Context) IFuncAttr(Range, Context, resolver, Spelling);
956 : New->setImplicit(isImplicit);
957 : break;
958 : }
959 216 : case attr::InitPriority: {
960 216 : bool isInherited = Record.readInt();
961 216 : bool isImplicit = Record.readInt();
962 216 : unsigned Spelling = Record.readInt();
963 216 : unsigned priority = Record.readInt();
964 : New = new (Context) InitPriorityAttr(Range, Context, priority, Spelling);
965 : cast<InheritableAttr>(New)->setInherited(isInherited);
966 : New->setImplicit(isImplicit);
967 : break;
968 : }
969 0 : case attr::InitSeg: {
970 0 : bool isImplicit = Record.readInt();
971 0 : unsigned Spelling = Record.readInt();
972 : std::string section= Record.readString();
973 0 : New = new (Context) InitSegAttr(Range, Context, section, Spelling);
974 : New->setImplicit(isImplicit);
975 : break;
976 : }
977 0 : case attr::IntelOclBicc: {
978 0 : bool isInherited = Record.readInt();
979 0 : bool isImplicit = Record.readInt();
980 0 : unsigned Spelling = Record.readInt();
981 : New = new (Context) IntelOclBiccAttr(Range, Context, Spelling);
982 : cast<InheritableAttr>(New)->setInherited(isInherited);
983 : New->setImplicit(isImplicit);
984 : break;
985 : }
986 0 : case attr::InternalLinkage: {
987 0 : bool isInherited = Record.readInt();
988 0 : bool isImplicit = Record.readInt();
989 0 : unsigned Spelling = Record.readInt();
990 : New = new (Context) InternalLinkageAttr(Range, Context, Spelling);
991 : cast<InheritableAttr>(New)->setInherited(isInherited);
992 : New->setImplicit(isImplicit);
993 : break;
994 : }
995 0 : case attr::LTOVisibilityPublic: {
996 0 : bool isInherited = Record.readInt();
997 0 : bool isImplicit = Record.readInt();
998 0 : unsigned Spelling = Record.readInt();
999 : New = new (Context) LTOVisibilityPublicAttr(Range, Context, Spelling);
1000 : cast<InheritableAttr>(New)->setInherited(isInherited);
1001 : New->setImplicit(isImplicit);
1002 : break;
1003 : }
1004 0 : case attr::LayoutVersion: {
1005 0 : bool isInherited = Record.readInt();
1006 0 : bool isImplicit = Record.readInt();
1007 0 : unsigned Spelling = Record.readInt();
1008 0 : unsigned version = Record.readInt();
1009 : New = new (Context) LayoutVersionAttr(Range, Context, version, Spelling);
1010 : cast<InheritableAttr>(New)->setInherited(isInherited);
1011 : New->setImplicit(isImplicit);
1012 : break;
1013 : }
1014 0 : case attr::LifetimeBound: {
1015 0 : bool isInherited = Record.readInt();
1016 0 : bool isImplicit = Record.readInt();
1017 0 : unsigned Spelling = Record.readInt();
1018 : New = new (Context) LifetimeBoundAttr(Range, Context, Spelling);
1019 : cast<InheritableAttr>(New)->setInherited(isInherited);
1020 : New->setImplicit(isImplicit);
1021 : break;
1022 : }
1023 0 : case attr::LockReturned: {
1024 0 : bool isInherited = Record.readInt();
1025 0 : bool isImplicit = Record.readInt();
1026 0 : unsigned Spelling = Record.readInt();
1027 : Expr * arg = Record.readExpr();
1028 : New = new (Context) LockReturnedAttr(Range, Context, arg, Spelling);
1029 : cast<InheritableAttr>(New)->setInherited(isInherited);
1030 : New->setImplicit(isImplicit);
1031 : break;
1032 : }
1033 0 : case attr::LocksExcluded: {
1034 0 : bool isInherited = Record.readInt();
1035 0 : bool isImplicit = Record.readInt();
1036 0 : unsigned Spelling = Record.readInt();
1037 0 : unsigned argsSize = Record.readInt();
1038 : SmallVector<Expr *, 4> args;
1039 : args.reserve(argsSize);
1040 0 : for (unsigned i = 0; i != argsSize; ++i)
1041 0 : args.push_back(Record.readExpr());
1042 0 : New = new (Context) LocksExcludedAttr(Range, Context, args.data(), argsSize, Spelling);
1043 : cast<InheritableAttr>(New)->setInherited(isInherited);
1044 : New->setImplicit(isImplicit);
1045 : break;
1046 : }
1047 16 : case attr::LoopHint: {
1048 16 : bool isImplicit = Record.readInt();
1049 16 : unsigned Spelling = Record.readInt();
1050 16 : LoopHintAttr::OptionType option(static_cast<LoopHintAttr::OptionType>(Record.readInt()));
1051 16 : LoopHintAttr::LoopHintState state(static_cast<LoopHintAttr::LoopHintState>(Record.readInt()));
1052 : Expr * value = Record.readExpr();
1053 : New = new (Context) LoopHintAttr(Range, Context, option, state, value, Spelling);
1054 : New->setImplicit(isImplicit);
1055 : break;
1056 : }
1057 1 : case attr::MSABI: {
1058 1 : bool isInherited = Record.readInt();
1059 1 : bool isImplicit = Record.readInt();
1060 1 : unsigned Spelling = Record.readInt();
1061 : New = new (Context) MSABIAttr(Range, Context, Spelling);
1062 : cast<InheritableAttr>(New)->setInherited(isInherited);
1063 : New->setImplicit(isImplicit);
1064 : break;
1065 : }
1066 1 : case attr::MSInheritance: {
1067 1 : bool isInherited = Record.readInt();
1068 1 : bool isImplicit = Record.readInt();
1069 1 : unsigned Spelling = Record.readInt();
1070 1 : bool bestCase = Record.readInt();
1071 : New = new (Context) MSInheritanceAttr(Range, Context, bestCase, Spelling);
1072 : cast<InheritableAttr>(New)->setInherited(isInherited);
1073 : New->setImplicit(isImplicit);
1074 : break;
1075 : }
1076 0 : case attr::MSNoVTable: {
1077 0 : bool isInherited = Record.readInt();
1078 0 : bool isImplicit = Record.readInt();
1079 0 : unsigned Spelling = Record.readInt();
1080 : New = new (Context) MSNoVTableAttr(Range, Context, Spelling);
1081 : cast<InheritableAttr>(New)->setInherited(isInherited);
1082 : New->setImplicit(isImplicit);
1083 : break;
1084 : }
1085 0 : case attr::MSP430Interrupt: {
1086 0 : bool isInherited = Record.readInt();
1087 0 : bool isImplicit = Record.readInt();
1088 0 : unsigned Spelling = Record.readInt();
1089 0 : unsigned number = Record.readInt();
1090 : New = new (Context) MSP430InterruptAttr(Range, Context, number, Spelling);
1091 : cast<InheritableAttr>(New)->setInherited(isInherited);
1092 : New->setImplicit(isImplicit);
1093 : break;
1094 : }
1095 1 : case attr::MSStruct: {
1096 1 : bool isInherited = Record.readInt();
1097 1 : bool isImplicit = Record.readInt();
1098 1 : unsigned Spelling = Record.readInt();
1099 : New = new (Context) MSStructAttr(Range, Context, Spelling);
1100 : cast<InheritableAttr>(New)->setInherited(isInherited);
1101 : New->setImplicit(isImplicit);
1102 : break;
1103 : }
1104 0 : case attr::MSVtorDisp: {
1105 0 : bool isInherited = Record.readInt();
1106 0 : bool isImplicit = Record.readInt();
1107 0 : unsigned Spelling = Record.readInt();
1108 0 : unsigned vdm = Record.readInt();
1109 : New = new (Context) MSVtorDispAttr(Range, Context, vdm, Spelling);
1110 : cast<InheritableAttr>(New)->setInherited(isInherited);
1111 : New->setImplicit(isImplicit);
1112 : break;
1113 : }
1114 0 : case attr::MaxFieldAlignment: {
1115 0 : bool isInherited = Record.readInt();
1116 0 : bool isImplicit = Record.readInt();
1117 0 : unsigned Spelling = Record.readInt();
1118 0 : unsigned alignment = Record.readInt();
1119 : New = new (Context) MaxFieldAlignmentAttr(Range, Context, alignment, Spelling);
1120 : cast<InheritableAttr>(New)->setInherited(isInherited);
1121 : New->setImplicit(isImplicit);
1122 : break;
1123 : }
1124 0 : case attr::MayAlias: {
1125 0 : bool isInherited = Record.readInt();
1126 0 : bool isImplicit = Record.readInt();
1127 0 : unsigned Spelling = Record.readInt();
1128 : New = new (Context) MayAliasAttr(Range, Context, Spelling);
1129 : cast<InheritableAttr>(New)->setInherited(isInherited);
1130 : New->setImplicit(isImplicit);
1131 : break;
1132 : }
1133 0 : case attr::MicroMips: {
1134 0 : bool isInherited = Record.readInt();
1135 0 : bool isImplicit = Record.readInt();
1136 0 : unsigned Spelling = Record.readInt();
1137 : New = new (Context) MicroMipsAttr(Range, Context, Spelling);
1138 : cast<InheritableAttr>(New)->setInherited(isInherited);
1139 : New->setImplicit(isImplicit);
1140 : break;
1141 : }
1142 0 : case attr::MinSize: {
1143 0 : bool isInherited = Record.readInt();
1144 0 : bool isImplicit = Record.readInt();
1145 0 : unsigned Spelling = Record.readInt();
1146 : New = new (Context) MinSizeAttr(Range, Context, Spelling);
1147 : cast<InheritableAttr>(New)->setInherited(isInherited);
1148 : New->setImplicit(isImplicit);
1149 : break;
1150 : }
1151 5 : case attr::MinVectorWidth: {
1152 5 : bool isInherited = Record.readInt();
1153 5 : bool isImplicit = Record.readInt();
1154 5 : unsigned Spelling = Record.readInt();
1155 5 : unsigned vectorWidth = Record.readInt();
1156 : New = new (Context) MinVectorWidthAttr(Range, Context, vectorWidth, Spelling);
1157 : cast<InheritableAttr>(New)->setInherited(isInherited);
1158 : New->setImplicit(isImplicit);
1159 : break;
1160 : }
1161 0 : case attr::Mips16: {
1162 0 : bool isInherited = Record.readInt();
1163 0 : bool isImplicit = Record.readInt();
1164 0 : unsigned Spelling = Record.readInt();
1165 : New = new (Context) Mips16Attr(Range, Context, Spelling);
1166 : cast<InheritableAttr>(New)->setInherited(isInherited);
1167 : New->setImplicit(isImplicit);
1168 : break;
1169 : }
1170 0 : case attr::MipsInterrupt: {
1171 0 : bool isInherited = Record.readInt();
1172 0 : bool isImplicit = Record.readInt();
1173 0 : unsigned Spelling = Record.readInt();
1174 0 : MipsInterruptAttr::InterruptType interrupt(static_cast<MipsInterruptAttr::InterruptType>(Record.readInt()));
1175 : New = new (Context) MipsInterruptAttr(Range, Context, interrupt, Spelling);
1176 : cast<InheritableAttr>(New)->setInherited(isInherited);
1177 : New->setImplicit(isImplicit);
1178 : break;
1179 : }
1180 0 : case attr::MipsLongCall: {
1181 0 : bool isInherited = Record.readInt();
1182 0 : bool isImplicit = Record.readInt();
1183 0 : unsigned Spelling = Record.readInt();
1184 : New = new (Context) MipsLongCallAttr(Range, Context, Spelling);
1185 : cast<InheritableAttr>(New)->setInherited(isInherited);
1186 : New->setImplicit(isImplicit);
1187 : break;
1188 : }
1189 0 : case attr::MipsShortCall: {
1190 0 : bool isInherited = Record.readInt();
1191 0 : bool isImplicit = Record.readInt();
1192 0 : unsigned Spelling = Record.readInt();
1193 : New = new (Context) MipsShortCallAttr(Range, Context, Spelling);
1194 : cast<InheritableAttr>(New)->setInherited(isInherited);
1195 : New->setImplicit(isImplicit);
1196 : break;
1197 : }
1198 0 : case attr::Mode: {
1199 0 : bool isImplicit = Record.readInt();
1200 0 : unsigned Spelling = Record.readInt();
1201 : IdentifierInfo * mode = Record.getIdentifierInfo();
1202 : New = new (Context) ModeAttr(Range, Context, mode, Spelling);
1203 : New->setImplicit(isImplicit);
1204 : break;
1205 : }
1206 0 : case attr::NSConsumed: {
1207 0 : bool isInherited = Record.readInt();
1208 0 : bool isImplicit = Record.readInt();
1209 0 : unsigned Spelling = Record.readInt();
1210 : New = new (Context) NSConsumedAttr(Range, Context, Spelling);
1211 : cast<InheritableAttr>(New)->setInherited(isInherited);
1212 : New->setImplicit(isImplicit);
1213 : break;
1214 : }
1215 0 : case attr::NSConsumesSelf: {
1216 0 : bool isInherited = Record.readInt();
1217 0 : bool isImplicit = Record.readInt();
1218 0 : unsigned Spelling = Record.readInt();
1219 : New = new (Context) NSConsumesSelfAttr(Range, Context, Spelling);
1220 : cast<InheritableAttr>(New)->setInherited(isInherited);
1221 : New->setImplicit(isImplicit);
1222 : break;
1223 : }
1224 0 : case attr::NSReturnsAutoreleased: {
1225 0 : bool isInherited = Record.readInt();
1226 0 : bool isImplicit = Record.readInt();
1227 0 : unsigned Spelling = Record.readInt();
1228 : New = new (Context) NSReturnsAutoreleasedAttr(Range, Context, Spelling);
1229 : cast<InheritableAttr>(New)->setInherited(isInherited);
1230 : New->setImplicit(isImplicit);
1231 : break;
1232 : }
1233 0 : case attr::NSReturnsNotRetained: {
1234 0 : bool isInherited = Record.readInt();
1235 0 : bool isImplicit = Record.readInt();
1236 0 : unsigned Spelling = Record.readInt();
1237 : New = new (Context) NSReturnsNotRetainedAttr(Range, Context, Spelling);
1238 : cast<InheritableAttr>(New)->setInherited(isInherited);
1239 : New->setImplicit(isImplicit);
1240 : break;
1241 : }
1242 0 : case attr::NSReturnsRetained: {
1243 0 : bool isInherited = Record.readInt();
1244 0 : bool isImplicit = Record.readInt();
1245 0 : unsigned Spelling = Record.readInt();
1246 : New = new (Context) NSReturnsRetainedAttr(Range, Context, Spelling);
1247 : cast<InheritableAttr>(New)->setInherited(isInherited);
1248 : New->setImplicit(isImplicit);
1249 : break;
1250 : }
1251 0 : case attr::Naked: {
1252 0 : bool isInherited = Record.readInt();
1253 0 : bool isImplicit = Record.readInt();
1254 0 : unsigned Spelling = Record.readInt();
1255 : New = new (Context) NakedAttr(Range, Context, Spelling);
1256 : cast<InheritableAttr>(New)->setInherited(isInherited);
1257 : New->setImplicit(isImplicit);
1258 : break;
1259 : }
1260 0 : case attr::NoAlias: {
1261 0 : bool isInherited = Record.readInt();
1262 0 : bool isImplicit = Record.readInt();
1263 0 : unsigned Spelling = Record.readInt();
1264 : New = new (Context) NoAliasAttr(Range, Context, Spelling);
1265 : cast<InheritableAttr>(New)->setInherited(isInherited);
1266 : New->setImplicit(isImplicit);
1267 : break;
1268 : }
1269 0 : case attr::NoCommon: {
1270 0 : bool isInherited = Record.readInt();
1271 0 : bool isImplicit = Record.readInt();
1272 0 : unsigned Spelling = Record.readInt();
1273 : New = new (Context) NoCommonAttr(Range, Context, Spelling);
1274 : cast<InheritableAttr>(New)->setInherited(isInherited);
1275 : New->setImplicit(isImplicit);
1276 : break;
1277 : }
1278 5 : case attr::NoDebug: {
1279 5 : bool isInherited = Record.readInt();
1280 5 : bool isImplicit = Record.readInt();
1281 5 : unsigned Spelling = Record.readInt();
1282 : New = new (Context) NoDebugAttr(Range, Context, Spelling);
1283 : cast<InheritableAttr>(New)->setInherited(isInherited);
1284 : New->setImplicit(isImplicit);
1285 : break;
1286 : }
1287 0 : case attr::NoDestroy: {
1288 0 : bool isInherited = Record.readInt();
1289 0 : bool isImplicit = Record.readInt();
1290 0 : unsigned Spelling = Record.readInt();
1291 : New = new (Context) NoDestroyAttr(Range, Context, Spelling);
1292 : cast<InheritableAttr>(New)->setInherited(isInherited);
1293 : New->setImplicit(isImplicit);
1294 : break;
1295 : }
1296 0 : case attr::NoDuplicate: {
1297 0 : bool isInherited = Record.readInt();
1298 0 : bool isImplicit = Record.readInt();
1299 0 : unsigned Spelling = Record.readInt();
1300 : New = new (Context) NoDuplicateAttr(Range, Context, Spelling);
1301 : cast<InheritableAttr>(New)->setInherited(isInherited);
1302 : New->setImplicit(isImplicit);
1303 : break;
1304 : }
1305 1 : case attr::NoEscape: {
1306 1 : bool isImplicit = Record.readInt();
1307 1 : unsigned Spelling = Record.readInt();
1308 : New = new (Context) NoEscapeAttr(Range, Context, Spelling);
1309 : New->setImplicit(isImplicit);
1310 : break;
1311 : }
1312 0 : case attr::NoInline: {
1313 0 : bool isInherited = Record.readInt();
1314 0 : bool isImplicit = Record.readInt();
1315 0 : unsigned Spelling = Record.readInt();
1316 : New = new (Context) NoInlineAttr(Range, Context, Spelling);
1317 : cast<InheritableAttr>(New)->setInherited(isInherited);
1318 : New->setImplicit(isImplicit);
1319 : break;
1320 : }
1321 0 : case attr::NoInstrumentFunction: {
1322 0 : bool isInherited = Record.readInt();
1323 0 : bool isImplicit = Record.readInt();
1324 0 : unsigned Spelling = Record.readInt();
1325 : New = new (Context) NoInstrumentFunctionAttr(Range, Context, Spelling);
1326 : cast<InheritableAttr>(New)->setInherited(isInherited);
1327 : New->setImplicit(isImplicit);
1328 : break;
1329 : }
1330 0 : case attr::NoMicroMips: {
1331 0 : bool isInherited = Record.readInt();
1332 0 : bool isImplicit = Record.readInt();
1333 0 : unsigned Spelling = Record.readInt();
1334 : New = new (Context) NoMicroMipsAttr(Range, Context, Spelling);
1335 : cast<InheritableAttr>(New)->setInherited(isInherited);
1336 : New->setImplicit(isImplicit);
1337 : break;
1338 : }
1339 0 : case attr::NoMips16: {
1340 0 : bool isInherited = Record.readInt();
1341 0 : bool isImplicit = Record.readInt();
1342 0 : unsigned Spelling = Record.readInt();
1343 : New = new (Context) NoMips16Attr(Range, Context, Spelling);
1344 : cast<InheritableAttr>(New)->setInherited(isInherited);
1345 : New->setImplicit(isImplicit);
1346 : break;
1347 : }
1348 0 : case attr::NoReturn: {
1349 0 : bool isInherited = Record.readInt();
1350 0 : bool isImplicit = Record.readInt();
1351 0 : unsigned Spelling = Record.readInt();
1352 : New = new (Context) NoReturnAttr(Range, Context, Spelling);
1353 : cast<InheritableAttr>(New)->setInherited(isInherited);
1354 : New->setImplicit(isImplicit);
1355 : break;
1356 : }
1357 1 : case attr::NoSanitize: {
1358 1 : bool isInherited = Record.readInt();
1359 1 : bool isImplicit = Record.readInt();
1360 1 : unsigned Spelling = Record.readInt();
1361 1 : unsigned sanitizersSize = Record.readInt();
1362 : SmallVector<StringRef, 4> sanitizers;
1363 : sanitizers.reserve(sanitizersSize);
1364 1 : SmallVector<std::string, 4> sanitizersStorage;
1365 : sanitizersStorage.reserve(sanitizersSize);
1366 3 : for (unsigned i = 0; i != sanitizersSize; ++i)
1367 4 : sanitizersStorage.push_back(Record.readString());
1368 3 : for (unsigned i = 0; i != sanitizersSize; ++i)
1369 4 : sanitizers.push_back(sanitizersStorage[i]);
1370 1 : New = new (Context) NoSanitizeAttr(Range, Context, sanitizers.data(), sanitizersSize, Spelling);
1371 : cast<InheritableAttr>(New)->setInherited(isInherited);
1372 : New->setImplicit(isImplicit);
1373 : break;
1374 : }
1375 0 : case attr::NoSplitStack: {
1376 0 : bool isInherited = Record.readInt();
1377 0 : bool isImplicit = Record.readInt();
1378 0 : unsigned Spelling = Record.readInt();
1379 : New = new (Context) NoSplitStackAttr(Range, Context, Spelling);
1380 : cast<InheritableAttr>(New)->setInherited(isInherited);
1381 : New->setImplicit(isImplicit);
1382 : break;
1383 : }
1384 0 : case attr::NoStackProtector: {
1385 0 : bool isInherited = Record.readInt();
1386 0 : bool isImplicit = Record.readInt();
1387 0 : unsigned Spelling = Record.readInt();
1388 : New = new (Context) NoStackProtectorAttr(Range, Context, Spelling);
1389 : cast<InheritableAttr>(New)->setInherited(isInherited);
1390 : New->setImplicit(isImplicit);
1391 : break;
1392 : }
1393 0 : case attr::NoThreadSafetyAnalysis: {
1394 0 : bool isInherited = Record.readInt();
1395 0 : bool isImplicit = Record.readInt();
1396 0 : unsigned Spelling = Record.readInt();
1397 : New = new (Context) NoThreadSafetyAnalysisAttr(Range, Context, Spelling);
1398 : cast<InheritableAttr>(New)->setInherited(isInherited);
1399 : New->setImplicit(isImplicit);
1400 : break;
1401 : }
1402 33 : case attr::NoThrow: {
1403 33 : bool isInherited = Record.readInt();
1404 33 : bool isImplicit = Record.readInt();
1405 33 : unsigned Spelling = Record.readInt();
1406 : New = new (Context) NoThrowAttr(Range, Context, Spelling);
1407 : cast<InheritableAttr>(New)->setInherited(isInherited);
1408 : New->setImplicit(isImplicit);
1409 : break;
1410 : }
1411 2 : case attr::NonNull: {
1412 2 : bool isInherited = Record.readInt();
1413 2 : bool isImplicit = Record.readInt();
1414 2 : unsigned Spelling = Record.readInt();
1415 2 : unsigned argsSize = Record.readInt();
1416 : SmallVector<ParamIdx, 4> args;
1417 : args.reserve(argsSize);
1418 6 : for (unsigned i = 0; i != argsSize; ++i)
1419 8 : args.push_back(ParamIdx::deserialize(Record.readInt()));
1420 2 : New = new (Context) NonNullAttr(Range, Context, args.data(), argsSize, Spelling);
1421 : cast<InheritableAttr>(New)->setInherited(isInherited);
1422 : New->setImplicit(isImplicit);
1423 : break;
1424 : }
1425 1 : case attr::NotTailCalled: {
1426 1 : bool isInherited = Record.readInt();
1427 1 : bool isImplicit = Record.readInt();
1428 1 : unsigned Spelling = Record.readInt();
1429 : New = new (Context) NotTailCalledAttr(Range, Context, Spelling);
1430 : cast<InheritableAttr>(New)->setInherited(isInherited);
1431 : New->setImplicit(isImplicit);
1432 : break;
1433 : }
1434 4613 : case attr::OMPCaptureKind: {
1435 4613 : bool isImplicit = Record.readInt();
1436 4613 : unsigned Spelling = Record.readInt();
1437 4613 : unsigned captureKind = Record.readInt();
1438 : New = new (Context) OMPCaptureKindAttr(Range, Context, captureKind, Spelling);
1439 : New->setImplicit(isImplicit);
1440 : break;
1441 : }
1442 18 : case attr::OMPCaptureNoInit: {
1443 18 : bool isInherited = Record.readInt();
1444 18 : bool isImplicit = Record.readInt();
1445 18 : unsigned Spelling = Record.readInt();
1446 : New = new (Context) OMPCaptureNoInitAttr(Range, Context, Spelling);
1447 : cast<InheritableAttr>(New)->setInherited(isInherited);
1448 : New->setImplicit(isImplicit);
1449 : break;
1450 : }
1451 124 : case attr::OMPDeclareSimdDecl: {
1452 124 : bool isImplicit = Record.readInt();
1453 124 : unsigned Spelling = Record.readInt();
1454 124 : OMPDeclareSimdDeclAttr::BranchStateTy branchState(static_cast<OMPDeclareSimdDeclAttr::BranchStateTy>(Record.readInt()));
1455 : Expr * simdlen = Record.readExpr();
1456 124 : unsigned uniformsSize = Record.readInt();
1457 : SmallVector<Expr *, 4> uniforms;
1458 : uniforms.reserve(uniformsSize);
1459 160 : for (unsigned i = 0; i != uniformsSize; ++i)
1460 36 : uniforms.push_back(Record.readExpr());
1461 124 : unsigned alignedsSize = Record.readInt();
1462 : SmallVector<Expr *, 4> aligneds;
1463 : aligneds.reserve(alignedsSize);
1464 206 : for (unsigned i = 0; i != alignedsSize; ++i)
1465 82 : aligneds.push_back(Record.readExpr());
1466 124 : unsigned alignmentsSize = Record.readInt();
1467 : SmallVector<Expr *, 4> alignments;
1468 : alignments.reserve(alignmentsSize);
1469 206 : for (unsigned i = 0; i != alignmentsSize; ++i)
1470 82 : alignments.push_back(Record.readExpr());
1471 124 : unsigned linearsSize = Record.readInt();
1472 : SmallVector<Expr *, 4> linears;
1473 : linears.reserve(linearsSize);
1474 178 : for (unsigned i = 0; i != linearsSize; ++i)
1475 54 : linears.push_back(Record.readExpr());
1476 124 : unsigned modifiersSize = Record.readInt();
1477 : SmallVector<unsigned, 4> modifiers;
1478 : modifiers.reserve(modifiersSize);
1479 178 : for (unsigned i = 0; i != modifiersSize; ++i)
1480 54 : modifiers.push_back(Record.readInt());
1481 124 : unsigned stepsSize = Record.readInt();
1482 : SmallVector<Expr *, 4> steps;
1483 : steps.reserve(stepsSize);
1484 178 : for (unsigned i = 0; i != stepsSize; ++i)
1485 54 : steps.push_back(Record.readExpr());
1486 124 : New = new (Context) OMPDeclareSimdDeclAttr(Range, Context, branchState, simdlen, uniforms.data(), uniformsSize, aligneds.data(), alignedsSize, alignments.data(), alignmentsSize, linears.data(), linearsSize, modifiers.data(), modifiersSize, steps.data(), stepsSize, Spelling);
1487 : New->setImplicit(isImplicit);
1488 : break;
1489 : }
1490 110 : case attr::OMPDeclareTargetDecl: {
1491 110 : bool isInherited = Record.readInt();
1492 110 : bool isImplicit = Record.readInt();
1493 110 : unsigned Spelling = Record.readInt();
1494 110 : OMPDeclareTargetDeclAttr::MapTypeTy mapType(static_cast<OMPDeclareTargetDeclAttr::MapTypeTy>(Record.readInt()));
1495 : New = new (Context) OMPDeclareTargetDeclAttr(Range, Context, mapType, Spelling);
1496 : cast<InheritableAttr>(New)->setInherited(isInherited);
1497 : New->setImplicit(isImplicit);
1498 : break;
1499 : }
1500 8100 : case attr::OMPReferencedVar: {
1501 8100 : bool isImplicit = Record.readInt();
1502 8100 : unsigned Spelling = Record.readInt();
1503 : Expr * ref = Record.readExpr();
1504 : New = new (Context) OMPReferencedVarAttr(Range, Context, ref, Spelling);
1505 : New->setImplicit(isImplicit);
1506 : break;
1507 : }
1508 162 : case attr::OMPThreadPrivateDecl: {
1509 162 : bool isInherited = Record.readInt();
1510 162 : bool isImplicit = Record.readInt();
1511 162 : unsigned Spelling = Record.readInt();
1512 : New = new (Context) OMPThreadPrivateDeclAttr(Range, Context, Spelling);
1513 : cast<InheritableAttr>(New)->setInherited(isInherited);
1514 : New->setImplicit(isImplicit);
1515 : break;
1516 : }
1517 2 : case attr::ObjCBoxable: {
1518 2 : bool isImplicit = Record.readInt();
1519 2 : unsigned Spelling = Record.readInt();
1520 : New = new (Context) ObjCBoxableAttr(Range, Context, Spelling);
1521 : New->setImplicit(isImplicit);
1522 : break;
1523 : }
1524 0 : case attr::ObjCBridge: {
1525 0 : bool isInherited = Record.readInt();
1526 0 : bool isImplicit = Record.readInt();
1527 0 : unsigned Spelling = Record.readInt();
1528 : IdentifierInfo * bridgedType = Record.getIdentifierInfo();
1529 : New = new (Context) ObjCBridgeAttr(Range, Context, bridgedType, Spelling);
1530 : cast<InheritableAttr>(New)->setInherited(isInherited);
1531 : New->setImplicit(isImplicit);
1532 : break;
1533 : }
1534 0 : case attr::ObjCBridgeMutable: {
1535 0 : bool isInherited = Record.readInt();
1536 0 : bool isImplicit = Record.readInt();
1537 0 : unsigned Spelling = Record.readInt();
1538 : IdentifierInfo * bridgedType = Record.getIdentifierInfo();
1539 : New = new (Context) ObjCBridgeMutableAttr(Range, Context, bridgedType, Spelling);
1540 : cast<InheritableAttr>(New)->setInherited(isInherited);
1541 : New->setImplicit(isImplicit);
1542 : break;
1543 : }
1544 0 : case attr::ObjCBridgeRelated: {
1545 0 : bool isInherited = Record.readInt();
1546 0 : bool isImplicit = Record.readInt();
1547 0 : unsigned Spelling = Record.readInt();
1548 : IdentifierInfo * relatedClass = Record.getIdentifierInfo();
1549 : IdentifierInfo * classMethod = Record.getIdentifierInfo();
1550 : IdentifierInfo * instanceMethod = Record.getIdentifierInfo();
1551 : New = new (Context) ObjCBridgeRelatedAttr(Range, Context, relatedClass, classMethod, instanceMethod, Spelling);
1552 : cast<InheritableAttr>(New)->setInherited(isInherited);
1553 : New->setImplicit(isImplicit);
1554 : break;
1555 : }
1556 1 : case attr::ObjCDesignatedInitializer: {
1557 1 : bool isImplicit = Record.readInt();
1558 1 : unsigned Spelling = Record.readInt();
1559 : New = new (Context) ObjCDesignatedInitializerAttr(Range, Context, Spelling);
1560 : New->setImplicit(isImplicit);
1561 : break;
1562 : }
1563 0 : case attr::ObjCException: {
1564 0 : bool isInherited = Record.readInt();
1565 0 : bool isImplicit = Record.readInt();
1566 0 : unsigned Spelling = Record.readInt();
1567 : New = new (Context) ObjCExceptionAttr(Range, Context, Spelling);
1568 : cast<InheritableAttr>(New)->setInherited(isInherited);
1569 : New->setImplicit(isImplicit);
1570 : break;
1571 : }
1572 0 : case attr::ObjCExplicitProtocolImpl: {
1573 0 : bool isInherited = Record.readInt();
1574 0 : bool isImplicit = Record.readInt();
1575 0 : unsigned Spelling = Record.readInt();
1576 : New = new (Context) ObjCExplicitProtocolImplAttr(Range, Context, Spelling);
1577 : cast<InheritableAttr>(New)->setInherited(isInherited);
1578 : New->setImplicit(isImplicit);
1579 : break;
1580 : }
1581 4 : case attr::ObjCGC: {
1582 4 : bool isImplicit = Record.readInt();
1583 4 : unsigned Spelling = Record.readInt();
1584 : IdentifierInfo * kind = Record.getIdentifierInfo();
1585 : New = new (Context) ObjCGCAttr(Range, Context, kind, Spelling);
1586 : New->setImplicit(isImplicit);
1587 : break;
1588 : }
1589 0 : case attr::ObjCIndependentClass: {
1590 0 : bool isInherited = Record.readInt();
1591 0 : bool isImplicit = Record.readInt();
1592 0 : unsigned Spelling = Record.readInt();
1593 : New = new (Context) ObjCIndependentClassAttr(Range, Context, Spelling);
1594 : cast<InheritableAttr>(New)->setInherited(isInherited);
1595 : New->setImplicit(isImplicit);
1596 : break;
1597 : }
1598 0 : case attr::ObjCInertUnsafeUnretained: {
1599 0 : bool isImplicit = Record.readInt();
1600 0 : unsigned Spelling = Record.readInt();
1601 : New = new (Context) ObjCInertUnsafeUnretainedAttr(Range, Context, Spelling);
1602 : New->setImplicit(isImplicit);
1603 : break;
1604 : }
1605 2 : case attr::ObjCKindOf: {
1606 2 : bool isImplicit = Record.readInt();
1607 2 : unsigned Spelling = Record.readInt();
1608 : New = new (Context) ObjCKindOfAttr(Range, Context, Spelling);
1609 : New->setImplicit(isImplicit);
1610 : break;
1611 : }
1612 0 : case attr::ObjCMethodFamily: {
1613 0 : bool isInherited = Record.readInt();
1614 0 : bool isImplicit = Record.readInt();
1615 0 : unsigned Spelling = Record.readInt();
1616 0 : ObjCMethodFamilyAttr::FamilyKind family(static_cast<ObjCMethodFamilyAttr::FamilyKind>(Record.readInt()));
1617 : New = new (Context) ObjCMethodFamilyAttr(Range, Context, family, Spelling);
1618 : cast<InheritableAttr>(New)->setInherited(isInherited);
1619 : New->setImplicit(isImplicit);
1620 : break;
1621 : }
1622 0 : case attr::ObjCNSObject: {
1623 0 : bool isInherited = Record.readInt();
1624 0 : bool isImplicit = Record.readInt();
1625 0 : unsigned Spelling = Record.readInt();
1626 : New = new (Context) ObjCNSObjectAttr(Range, Context, Spelling);
1627 : cast<InheritableAttr>(New)->setInherited(isInherited);
1628 : New->setImplicit(isImplicit);
1629 : break;
1630 : }
1631 0 : case attr::ObjCOwnership: {
1632 0 : bool isInherited = Record.readInt();
1633 0 : bool isImplicit = Record.readInt();
1634 0 : unsigned Spelling = Record.readInt();
1635 : IdentifierInfo * kind = Record.getIdentifierInfo();
1636 : New = new (Context) ObjCOwnershipAttr(Range, Context, kind, Spelling);
1637 : cast<InheritableAttr>(New)->setInherited(isInherited);
1638 : New->setImplicit(isImplicit);
1639 : break;
1640 : }
1641 0 : case attr::ObjCPreciseLifetime: {
1642 0 : bool isInherited = Record.readInt();
1643 0 : bool isImplicit = Record.readInt();
1644 0 : unsigned Spelling = Record.readInt();
1645 : New = new (Context) ObjCPreciseLifetimeAttr(Range, Context, Spelling);
1646 : cast<InheritableAttr>(New)->setInherited(isInherited);
1647 : New->setImplicit(isImplicit);
1648 : break;
1649 : }
1650 0 : case attr::ObjCRequiresPropertyDefs: {
1651 0 : bool isInherited = Record.readInt();
1652 0 : bool isImplicit = Record.readInt();
1653 0 : unsigned Spelling = Record.readInt();
1654 : New = new (Context) ObjCRequiresPropertyDefsAttr(Range, Context, Spelling);
1655 : cast<InheritableAttr>(New)->setInherited(isInherited);
1656 : New->setImplicit(isImplicit);
1657 : break;
1658 : }
1659 0 : case attr::ObjCRequiresSuper: {
1660 0 : bool isInherited = Record.readInt();
1661 0 : bool isImplicit = Record.readInt();
1662 0 : unsigned Spelling = Record.readInt();
1663 : New = new (Context) ObjCRequiresSuperAttr(Range, Context, Spelling);
1664 : cast<InheritableAttr>(New)->setInherited(isInherited);
1665 : New->setImplicit(isImplicit);
1666 : break;
1667 : }
1668 0 : case attr::ObjCReturnsInnerPointer: {
1669 0 : bool isInherited = Record.readInt();
1670 0 : bool isImplicit = Record.readInt();
1671 0 : unsigned Spelling = Record.readInt();
1672 : New = new (Context) ObjCReturnsInnerPointerAttr(Range, Context, Spelling);
1673 : cast<InheritableAttr>(New)->setInherited(isInherited);
1674 : New->setImplicit(isImplicit);
1675 : break;
1676 : }
1677 2 : case attr::ObjCRootClass: {
1678 2 : bool isInherited = Record.readInt();
1679 2 : bool isImplicit = Record.readInt();
1680 2 : unsigned Spelling = Record.readInt();
1681 : New = new (Context) ObjCRootClassAttr(Range, Context, Spelling);
1682 : cast<InheritableAttr>(New)->setInherited(isInherited);
1683 : New->setImplicit(isImplicit);
1684 : break;
1685 : }
1686 0 : case attr::ObjCRuntimeName: {
1687 0 : bool isImplicit = Record.readInt();
1688 0 : unsigned Spelling = Record.readInt();
1689 : std::string metadataName= Record.readString();
1690 0 : New = new (Context) ObjCRuntimeNameAttr(Range, Context, metadataName, Spelling);
1691 : New->setImplicit(isImplicit);
1692 : break;
1693 : }
1694 0 : case attr::ObjCRuntimeVisible: {
1695 0 : bool isImplicit = Record.readInt();
1696 0 : unsigned Spelling = Record.readInt();
1697 : New = new (Context) ObjCRuntimeVisibleAttr(Range, Context, Spelling);
1698 : New->setImplicit(isImplicit);
1699 : break;
1700 : }
1701 0 : case attr::ObjCSubclassingRestricted: {
1702 0 : bool isInherited = Record.readInt();
1703 0 : bool isImplicit = Record.readInt();
1704 0 : unsigned Spelling = Record.readInt();
1705 : New = new (Context) ObjCSubclassingRestrictedAttr(Range, Context, Spelling);
1706 : cast<InheritableAttr>(New)->setInherited(isInherited);
1707 : New->setImplicit(isImplicit);
1708 : break;
1709 : }
1710 124 : case attr::OpenCLAccess: {
1711 124 : bool isImplicit = Record.readInt();
1712 124 : unsigned Spelling = Record.readInt();
1713 : New = new (Context) OpenCLAccessAttr(Range, Context, Spelling);
1714 : New->setImplicit(isImplicit);
1715 : break;
1716 : }
1717 0 : case attr::OpenCLConstantAddressSpace: {
1718 0 : bool isImplicit = Record.readInt();
1719 0 : unsigned Spelling = Record.readInt();
1720 : New = new (Context) OpenCLConstantAddressSpaceAttr(Range, Context, Spelling);
1721 : New->setImplicit(isImplicit);
1722 : break;
1723 : }
1724 0 : case attr::OpenCLGenericAddressSpace: {
1725 0 : bool isImplicit = Record.readInt();
1726 0 : unsigned Spelling = Record.readInt();
1727 : New = new (Context) OpenCLGenericAddressSpaceAttr(Range, Context, Spelling);
1728 : New->setImplicit(isImplicit);
1729 : break;
1730 : }
1731 0 : case attr::OpenCLGlobalAddressSpace: {
1732 0 : bool isImplicit = Record.readInt();
1733 0 : unsigned Spelling = Record.readInt();
1734 : New = new (Context) OpenCLGlobalAddressSpaceAttr(Range, Context, Spelling);
1735 : New->setImplicit(isImplicit);
1736 : break;
1737 : }
1738 0 : case attr::OpenCLIntelReqdSubGroupSize: {
1739 0 : bool isInherited = Record.readInt();
1740 0 : bool isImplicit = Record.readInt();
1741 0 : unsigned Spelling = Record.readInt();
1742 0 : unsigned subGroupSize = Record.readInt();
1743 : New = new (Context) OpenCLIntelReqdSubGroupSizeAttr(Range, Context, subGroupSize, Spelling);
1744 : cast<InheritableAttr>(New)->setInherited(isInherited);
1745 : New->setImplicit(isImplicit);
1746 : break;
1747 : }
1748 0 : case attr::OpenCLKernel: {
1749 0 : bool isInherited = Record.readInt();
1750 0 : bool isImplicit = Record.readInt();
1751 0 : unsigned Spelling = Record.readInt();
1752 : New = new (Context) OpenCLKernelAttr(Range, Context, Spelling);
1753 : cast<InheritableAttr>(New)->setInherited(isInherited);
1754 : New->setImplicit(isImplicit);
1755 : break;
1756 : }
1757 0 : case attr::OpenCLLocalAddressSpace: {
1758 0 : bool isImplicit = Record.readInt();
1759 0 : unsigned Spelling = Record.readInt();
1760 : New = new (Context) OpenCLLocalAddressSpaceAttr(Range, Context, Spelling);
1761 : New->setImplicit(isImplicit);
1762 : break;
1763 : }
1764 0 : case attr::OpenCLPrivateAddressSpace: {
1765 0 : bool isImplicit = Record.readInt();
1766 0 : unsigned Spelling = Record.readInt();
1767 : New = new (Context) OpenCLPrivateAddressSpaceAttr(Range, Context, Spelling);
1768 : New->setImplicit(isImplicit);
1769 : break;
1770 : }
1771 0 : case attr::OpenCLUnrollHint: {
1772 0 : bool isInherited = Record.readInt();
1773 0 : bool isImplicit = Record.readInt();
1774 0 : unsigned Spelling = Record.readInt();
1775 0 : unsigned unrollHint = Record.readInt();
1776 : New = new (Context) OpenCLUnrollHintAttr(Range, Context, unrollHint, Spelling);
1777 : cast<InheritableAttr>(New)->setInherited(isInherited);
1778 : New->setImplicit(isImplicit);
1779 : break;
1780 : }
1781 0 : case attr::OptimizeNone: {
1782 0 : bool isInherited = Record.readInt();
1783 0 : bool isImplicit = Record.readInt();
1784 0 : unsigned Spelling = Record.readInt();
1785 : New = new (Context) OptimizeNoneAttr(Range, Context, Spelling);
1786 : cast<InheritableAttr>(New)->setInherited(isInherited);
1787 : New->setImplicit(isImplicit);
1788 : break;
1789 : }
1790 359 : case attr::Overloadable: {
1791 359 : bool isImplicit = Record.readInt();
1792 359 : unsigned Spelling = Record.readInt();
1793 : New = new (Context) OverloadableAttr(Range, Context, Spelling);
1794 : New->setImplicit(isImplicit);
1795 : break;
1796 : }
1797 0 : case attr::Override: {
1798 0 : bool isInherited = Record.readInt();
1799 0 : bool isImplicit = Record.readInt();
1800 0 : unsigned Spelling = Record.readInt();
1801 : New = new (Context) OverrideAttr(Range, Context, Spelling);
1802 : cast<InheritableAttr>(New)->setInherited(isInherited);
1803 : New->setImplicit(isImplicit);
1804 : break;
1805 : }
1806 6 : case attr::Ownership: {
1807 6 : bool isInherited = Record.readInt();
1808 6 : bool isImplicit = Record.readInt();
1809 6 : unsigned Spelling = Record.readInt();
1810 : IdentifierInfo * module = Record.getIdentifierInfo();
1811 6 : unsigned argsSize = Record.readInt();
1812 : SmallVector<ParamIdx, 4> args;
1813 : args.reserve(argsSize);
1814 16 : for (unsigned i = 0; i != argsSize; ++i)
1815 20 : args.push_back(ParamIdx::deserialize(Record.readInt()));
1816 6 : New = new (Context) OwnershipAttr(Range, Context, module, args.data(), argsSize, Spelling);
1817 : cast<InheritableAttr>(New)->setInherited(isInherited);
1818 : New->setImplicit(isImplicit);
1819 : break;
1820 : }
1821 41 : case attr::Packed: {
1822 41 : bool isInherited = Record.readInt();
1823 41 : bool isImplicit = Record.readInt();
1824 41 : unsigned Spelling = Record.readInt();
1825 : New = new (Context) PackedAttr(Range, Context, Spelling);
1826 : cast<InheritableAttr>(New)->setInherited(isInherited);
1827 : New->setImplicit(isImplicit);
1828 : break;
1829 : }
1830 0 : case attr::ParamTypestate: {
1831 0 : bool isInherited = Record.readInt();
1832 0 : bool isImplicit = Record.readInt();
1833 0 : unsigned Spelling = Record.readInt();
1834 0 : ParamTypestateAttr::ConsumedState paramState(static_cast<ParamTypestateAttr::ConsumedState>(Record.readInt()));
1835 : New = new (Context) ParamTypestateAttr(Range, Context, paramState, Spelling);
1836 : cast<InheritableAttr>(New)->setInherited(isInherited);
1837 : New->setImplicit(isImplicit);
1838 : break;
1839 : }
1840 0 : case attr::Pascal: {
1841 0 : bool isInherited = Record.readInt();
1842 0 : bool isImplicit = Record.readInt();
1843 0 : unsigned Spelling = Record.readInt();
1844 : New = new (Context) PascalAttr(Range, Context, Spelling);
1845 : cast<InheritableAttr>(New)->setInherited(isInherited);
1846 : New->setImplicit(isImplicit);
1847 : break;
1848 : }
1849 2 : case attr::PassObjectSize: {
1850 2 : bool isInherited = Record.readInt();
1851 2 : bool isImplicit = Record.readInt();
1852 2 : unsigned Spelling = Record.readInt();
1853 2 : int type = Record.readInt();
1854 : New = new (Context) PassObjectSizeAttr(Range, Context, type, Spelling);
1855 : cast<InheritableAttr>(New)->setInherited(isInherited);
1856 : New->setImplicit(isImplicit);
1857 : break;
1858 : }
1859 0 : case attr::Pcs: {
1860 0 : bool isInherited = Record.readInt();
1861 0 : bool isImplicit = Record.readInt();
1862 0 : unsigned Spelling = Record.readInt();
1863 0 : PcsAttr::PCSType pCS(static_cast<PcsAttr::PCSType>(Record.readInt()));
1864 : New = new (Context) PcsAttr(Range, Context, pCS, Spelling);
1865 : cast<InheritableAttr>(New)->setInherited(isInherited);
1866 : New->setImplicit(isImplicit);
1867 : break;
1868 : }
1869 0 : case attr::PragmaClangBSSSection: {
1870 0 : bool isInherited = Record.readInt();
1871 0 : bool isImplicit = Record.readInt();
1872 0 : unsigned Spelling = Record.readInt();
1873 : std::string name= Record.readString();
1874 0 : New = new (Context) PragmaClangBSSSectionAttr(Range, Context, name, Spelling);
1875 : cast<InheritableAttr>(New)->setInherited(isInherited);
1876 : New->setImplicit(isImplicit);
1877 : break;
1878 : }
1879 0 : case attr::PragmaClangDataSection: {
1880 0 : bool isInherited = Record.readInt();
1881 0 : bool isImplicit = Record.readInt();
1882 0 : unsigned Spelling = Record.readInt();
1883 : std::string name= Record.readString();
1884 0 : New = new (Context) PragmaClangDataSectionAttr(Range, Context, name, Spelling);
1885 : cast<InheritableAttr>(New)->setInherited(isInherited);
1886 : New->setImplicit(isImplicit);
1887 : break;
1888 : }
1889 0 : case attr::PragmaClangRodataSection: {
1890 0 : bool isInherited = Record.readInt();
1891 0 : bool isImplicit = Record.readInt();
1892 0 : unsigned Spelling = Record.readInt();
1893 : std::string name= Record.readString();
1894 0 : New = new (Context) PragmaClangRodataSectionAttr(Range, Context, name, Spelling);
1895 : cast<InheritableAttr>(New)->setInherited(isInherited);
1896 : New->setImplicit(isImplicit);
1897 : break;
1898 : }
1899 0 : case attr::PragmaClangTextSection: {
1900 0 : bool isInherited = Record.readInt();
1901 0 : bool isImplicit = Record.readInt();
1902 0 : unsigned Spelling = Record.readInt();
1903 : std::string name= Record.readString();
1904 0 : New = new (Context) PragmaClangTextSectionAttr(Range, Context, name, Spelling);
1905 : cast<InheritableAttr>(New)->setInherited(isInherited);
1906 : New->setImplicit(isImplicit);
1907 : break;
1908 : }
1909 0 : case attr::PreserveAll: {
1910 0 : bool isInherited = Record.readInt();
1911 0 : bool isImplicit = Record.readInt();
1912 0 : unsigned Spelling = Record.readInt();
1913 : New = new (Context) PreserveAllAttr(Range, Context, Spelling);
1914 : cast<InheritableAttr>(New)->setInherited(isInherited);
1915 : New->setImplicit(isImplicit);
1916 : break;
1917 : }
1918 0 : case attr::PreserveMost: {
1919 0 : bool isInherited = Record.readInt();
1920 0 : bool isImplicit = Record.readInt();
1921 0 : unsigned Spelling = Record.readInt();
1922 : New = new (Context) PreserveMostAttr(Range, Context, Spelling);
1923 : cast<InheritableAttr>(New)->setInherited(isInherited);
1924 : New->setImplicit(isImplicit);
1925 : break;
1926 : }
1927 0 : case attr::PtGuardedBy: {
1928 0 : bool isInherited = Record.readInt();
1929 0 : bool isImplicit = Record.readInt();
1930 0 : unsigned Spelling = Record.readInt();
1931 : Expr * arg = Record.readExpr();
1932 : New = new (Context) PtGuardedByAttr(Range, Context, arg, Spelling);
1933 : cast<InheritableAttr>(New)->setInherited(isInherited);
1934 : New->setImplicit(isImplicit);
1935 : break;
1936 : }
1937 0 : case attr::PtGuardedVar: {
1938 0 : bool isInherited = Record.readInt();
1939 0 : bool isImplicit = Record.readInt();
1940 0 : unsigned Spelling = Record.readInt();
1941 : New = new (Context) PtGuardedVarAttr(Range, Context, Spelling);
1942 : cast<InheritableAttr>(New)->setInherited(isInherited);
1943 : New->setImplicit(isImplicit);
1944 : break;
1945 : }
1946 0 : case attr::Ptr32: {
1947 0 : bool isImplicit = Record.readInt();
1948 0 : unsigned Spelling = Record.readInt();
1949 : New = new (Context) Ptr32Attr(Range, Context, Spelling);
1950 : New->setImplicit(isImplicit);
1951 : break;
1952 : }
1953 0 : case attr::Ptr64: {
1954 0 : bool isImplicit = Record.readInt();
1955 0 : unsigned Spelling = Record.readInt();
1956 : New = new (Context) Ptr64Attr(Range, Context, Spelling);
1957 : New->setImplicit(isImplicit);
1958 : break;
1959 : }
1960 0 : case attr::Pure: {
1961 0 : bool isInherited = Record.readInt();
1962 0 : bool isImplicit = Record.readInt();
1963 0 : unsigned Spelling = Record.readInt();
1964 : New = new (Context) PureAttr(Range, Context, Spelling);
1965 : cast<InheritableAttr>(New)->setInherited(isInherited);
1966 : New->setImplicit(isImplicit);
1967 : break;
1968 : }
1969 0 : case attr::RISCVInterrupt: {
1970 0 : bool isInherited = Record.readInt();
1971 0 : bool isImplicit = Record.readInt();
1972 0 : unsigned Spelling = Record.readInt();
1973 0 : RISCVInterruptAttr::InterruptType interrupt(static_cast<RISCVInterruptAttr::InterruptType>(Record.readInt()));
1974 : New = new (Context) RISCVInterruptAttr(Range, Context, interrupt, Spelling);
1975 : cast<InheritableAttr>(New)->setInherited(isInherited);
1976 : New->setImplicit(isImplicit);
1977 : break;
1978 : }
1979 0 : case attr::RegCall: {
1980 0 : bool isInherited = Record.readInt();
1981 0 : bool isImplicit = Record.readInt();
1982 0 : unsigned Spelling = Record.readInt();
1983 : New = new (Context) RegCallAttr(Range, Context, Spelling);
1984 : cast<InheritableAttr>(New)->setInherited(isInherited);
1985 : New->setImplicit(isImplicit);
1986 : break;
1987 : }
1988 0 : case attr::Reinitializes: {
1989 0 : bool isInherited = Record.readInt();
1990 0 : bool isImplicit = Record.readInt();
1991 0 : unsigned Spelling = Record.readInt();
1992 : New = new (Context) ReinitializesAttr(Range, Context, Spelling);
1993 : cast<InheritableAttr>(New)->setInherited(isInherited);
1994 : New->setImplicit(isImplicit);
1995 : break;
1996 : }
1997 4 : case attr::ReleaseCapability: {
1998 4 : bool isInherited = Record.readInt();
1999 4 : bool isImplicit = Record.readInt();
2000 4 : unsigned Spelling = Record.readInt();
2001 4 : unsigned argsSize = Record.readInt();
2002 : SmallVector<Expr *, 4> args;
2003 : args.reserve(argsSize);
2004 5 : for (unsigned i = 0; i != argsSize; ++i)
2005 1 : args.push_back(Record.readExpr());
2006 4 : New = new (Context) ReleaseCapabilityAttr(Range, Context, args.data(), argsSize, Spelling);
2007 : cast<InheritableAttr>(New)->setInherited(isInherited);
2008 : New->setImplicit(isImplicit);
2009 : break;
2010 : }
2011 0 : case attr::RenderScriptKernel: {
2012 0 : bool isImplicit = Record.readInt();
2013 0 : unsigned Spelling = Record.readInt();
2014 : New = new (Context) RenderScriptKernelAttr(Range, Context, Spelling);
2015 : New->setImplicit(isImplicit);
2016 : break;
2017 : }
2018 0 : case attr::ReqdWorkGroupSize: {
2019 0 : bool isInherited = Record.readInt();
2020 0 : bool isImplicit = Record.readInt();
2021 0 : unsigned Spelling = Record.readInt();
2022 0 : unsigned xDim = Record.readInt();
2023 0 : unsigned yDim = Record.readInt();
2024 0 : unsigned zDim = Record.readInt();
2025 : New = new (Context) ReqdWorkGroupSizeAttr(Range, Context, xDim, yDim, zDim, Spelling);
2026 : cast<InheritableAttr>(New)->setInherited(isInherited);
2027 : New->setImplicit(isImplicit);
2028 : break;
2029 : }
2030 0 : case attr::RequireConstantInit: {
2031 0 : bool isInherited = Record.readInt();
2032 0 : bool isImplicit = Record.readInt();
2033 0 : unsigned Spelling = Record.readInt();
2034 : New = new (Context) RequireConstantInitAttr(Range, Context, Spelling);
2035 : cast<InheritableAttr>(New)->setInherited(isInherited);
2036 : New->setImplicit(isImplicit);
2037 : break;
2038 : }
2039 0 : case attr::RequiresCapability: {
2040 0 : bool isInherited = Record.readInt();
2041 0 : bool isImplicit = Record.readInt();
2042 0 : unsigned Spelling = Record.readInt();
2043 0 : unsigned argsSize = Record.readInt();
2044 : SmallVector<Expr *, 4> args;
2045 : args.reserve(argsSize);
2046 0 : for (unsigned i = 0; i != argsSize; ++i)
2047 0 : args.push_back(Record.readExpr());
2048 0 : New = new (Context) RequiresCapabilityAttr(Range, Context, args.data(), argsSize, Spelling);
2049 : cast<InheritableAttr>(New)->setInherited(isInherited);
2050 : New->setImplicit(isImplicit);
2051 : break;
2052 : }
2053 0 : case attr::Restrict: {
2054 0 : bool isInherited = Record.readInt();
2055 0 : bool isImplicit = Record.readInt();
2056 0 : unsigned Spelling = Record.readInt();
2057 : New = new (Context) RestrictAttr(Range, Context, Spelling);
2058 : cast<InheritableAttr>(New)->setInherited(isInherited);
2059 : New->setImplicit(isImplicit);
2060 : break;
2061 : }
2062 0 : case attr::ReturnTypestate: {
2063 0 : bool isInherited = Record.readInt();
2064 0 : bool isImplicit = Record.readInt();
2065 0 : unsigned Spelling = Record.readInt();
2066 0 : ReturnTypestateAttr::ConsumedState state(static_cast<ReturnTypestateAttr::ConsumedState>(Record.readInt()));
2067 : New = new (Context) ReturnTypestateAttr(Range, Context, state, Spelling);
2068 : cast<InheritableAttr>(New)->setInherited(isInherited);
2069 : New->setImplicit(isImplicit);
2070 : break;
2071 : }
2072 0 : case attr::ReturnsNonNull: {
2073 0 : bool isInherited = Record.readInt();
2074 0 : bool isImplicit = Record.readInt();
2075 0 : unsigned Spelling = Record.readInt();
2076 : New = new (Context) ReturnsNonNullAttr(Range, Context, Spelling);
2077 : cast<InheritableAttr>(New)->setInherited(isInherited);
2078 : New->setImplicit(isImplicit);
2079 : break;
2080 : }
2081 0 : case attr::ReturnsTwice: {
2082 0 : bool isInherited = Record.readInt();
2083 0 : bool isImplicit = Record.readInt();
2084 0 : unsigned Spelling = Record.readInt();
2085 : New = new (Context) ReturnsTwiceAttr(Range, Context, Spelling);
2086 : cast<InheritableAttr>(New)->setInherited(isInherited);
2087 : New->setImplicit(isImplicit);
2088 : break;
2089 : }
2090 0 : case attr::SPtr: {
2091 0 : bool isImplicit = Record.readInt();
2092 0 : unsigned Spelling = Record.readInt();
2093 : New = new (Context) SPtrAttr(Range, Context, Spelling);
2094 : New->setImplicit(isImplicit);
2095 : break;
2096 : }
2097 0 : case attr::ScopedLockable: {
2098 0 : bool isInherited = Record.readInt();
2099 0 : bool isImplicit = Record.readInt();
2100 0 : unsigned Spelling = Record.readInt();
2101 : New = new (Context) ScopedLockableAttr(Range, Context, Spelling);
2102 : cast<InheritableAttr>(New)->setInherited(isInherited);
2103 : New->setImplicit(isImplicit);
2104 : break;
2105 : }
2106 0 : case attr::Section: {
2107 0 : bool isInherited = Record.readInt();
2108 0 : bool isImplicit = Record.readInt();
2109 0 : unsigned Spelling = Record.readInt();
2110 : std::string name= Record.readString();
2111 0 : New = new (Context) SectionAttr(Range, Context, name, Spelling);
2112 : cast<InheritableAttr>(New)->setInherited(isInherited);
2113 : New->setImplicit(isImplicit);
2114 : break;
2115 : }
2116 0 : case attr::SelectAny: {
2117 0 : bool isInherited = Record.readInt();
2118 0 : bool isImplicit = Record.readInt();
2119 0 : unsigned Spelling = Record.readInt();
2120 : New = new (Context) SelectAnyAttr(Range, Context, Spelling);
2121 : cast<InheritableAttr>(New)->setInherited(isInherited);
2122 : New->setImplicit(isImplicit);
2123 : break;
2124 : }
2125 0 : case attr::Sentinel: {
2126 0 : bool isInherited = Record.readInt();
2127 0 : bool isImplicit = Record.readInt();
2128 0 : unsigned Spelling = Record.readInt();
2129 0 : int sentinel = Record.readInt();
2130 0 : int nullPos = Record.readInt();
2131 : New = new (Context) SentinelAttr(Range, Context, sentinel, nullPos, Spelling);
2132 : cast<InheritableAttr>(New)->setInherited(isInherited);
2133 : New->setImplicit(isImplicit);
2134 : break;
2135 : }
2136 0 : case attr::SetTypestate: {
2137 0 : bool isInherited = Record.readInt();
2138 0 : bool isImplicit = Record.readInt();
2139 0 : unsigned Spelling = Record.readInt();
2140 0 : SetTypestateAttr::ConsumedState newState(static_cast<SetTypestateAttr::ConsumedState>(Record.readInt()));
2141 : New = new (Context) SetTypestateAttr(Range, Context, newState, Spelling);
2142 : cast<InheritableAttr>(New)->setInherited(isInherited);
2143 : New->setImplicit(isImplicit);
2144 : break;
2145 : }
2146 0 : case attr::SharedTrylockFunction: {
2147 0 : bool isInherited = Record.readInt();
2148 0 : bool isImplicit = Record.readInt();
2149 0 : unsigned Spelling = Record.readInt();
2150 : Expr * successValue = Record.readExpr();
2151 0 : unsigned argsSize = Record.readInt();
2152 : SmallVector<Expr *, 4> args;
2153 : args.reserve(argsSize);
2154 0 : for (unsigned i = 0; i != argsSize; ++i)
2155 0 : args.push_back(Record.readExpr());
2156 0 : New = new (Context) SharedTrylockFunctionAttr(Range, Context, successValue, args.data(), argsSize, Spelling);
2157 : cast<InheritableAttr>(New)->setInherited(isInherited);
2158 : New->setImplicit(isImplicit);
2159 : break;
2160 : }
2161 0 : case attr::StdCall: {
2162 0 : bool isInherited = Record.readInt();
2163 0 : bool isImplicit = Record.readInt();
2164 0 : unsigned Spelling = Record.readInt();
2165 : New = new (Context) StdCallAttr(Range, Context, Spelling);
2166 : cast<InheritableAttr>(New)->setInherited(isInherited);
2167 : New->setImplicit(isImplicit);
2168 : break;
2169 : }
2170 0 : case attr::Suppress: {
2171 0 : bool isImplicit = Record.readInt();
2172 0 : unsigned Spelling = Record.readInt();
2173 0 : unsigned diagnosticIdentifiersSize = Record.readInt();
2174 : SmallVector<StringRef, 4> diagnosticIdentifiers;
2175 : diagnosticIdentifiers.reserve(diagnosticIdentifiersSize);
2176 0 : SmallVector<std::string, 4> diagnosticIdentifiersStorage;
2177 : diagnosticIdentifiersStorage.reserve(diagnosticIdentifiersSize);
2178 0 : for (unsigned i = 0; i != diagnosticIdentifiersSize; ++i)
2179 0 : diagnosticIdentifiersStorage.push_back(Record.readString());
2180 0 : for (unsigned i = 0; i != diagnosticIdentifiersSize; ++i)
2181 0 : diagnosticIdentifiers.push_back(diagnosticIdentifiersStorage[i]);
2182 0 : New = new (Context) SuppressAttr(Range, Context, diagnosticIdentifiers.data(), diagnosticIdentifiersSize, Spelling);
2183 : New->setImplicit(isImplicit);
2184 : break;
2185 : }
2186 0 : case attr::SwiftCall: {
2187 0 : bool isInherited = Record.readInt();
2188 0 : bool isImplicit = Record.readInt();
2189 0 : unsigned Spelling = Record.readInt();
2190 : New = new (Context) SwiftCallAttr(Range, Context, Spelling);
2191 : cast<InheritableAttr>(New)->setInherited(isInherited);
2192 : New->setImplicit(isImplicit);
2193 : break;
2194 : }
2195 0 : case attr::SwiftContext: {
2196 0 : bool isInherited = Record.readInt();
2197 0 : bool isImplicit = Record.readInt();
2198 0 : unsigned Spelling = Record.readInt();
2199 : New = new (Context) SwiftContextAttr(Range, Context, Spelling);
2200 : cast<InheritableAttr>(New)->setInherited(isInherited);
2201 : New->setImplicit(isImplicit);
2202 : break;
2203 : }
2204 0 : case attr::SwiftErrorResult: {
2205 0 : bool isInherited = Record.readInt();
2206 0 : bool isImplicit = Record.readInt();
2207 0 : unsigned Spelling = Record.readInt();
2208 : New = new (Context) SwiftErrorResultAttr(Range, Context, Spelling);
2209 : cast<InheritableAttr>(New)->setInherited(isInherited);
2210 : New->setImplicit(isImplicit);
2211 : break;
2212 : }
2213 0 : case attr::SwiftIndirectResult: {
2214 0 : bool isInherited = Record.readInt();
2215 0 : bool isImplicit = Record.readInt();
2216 0 : unsigned Spelling = Record.readInt();
2217 : New = new (Context) SwiftIndirectResultAttr(Range, Context, Spelling);
2218 : cast<InheritableAttr>(New)->setInherited(isInherited);
2219 : New->setImplicit(isImplicit);
2220 : break;
2221 : }
2222 0 : case attr::SysVABI: {
2223 0 : bool isInherited = Record.readInt();
2224 0 : bool isImplicit = Record.readInt();
2225 0 : unsigned Spelling = Record.readInt();
2226 : New = new (Context) SysVABIAttr(Range, Context, Spelling);
2227 : cast<InheritableAttr>(New)->setInherited(isInherited);
2228 : New->setImplicit(isImplicit);
2229 : break;
2230 : }
2231 0 : case attr::TLSModel: {
2232 0 : bool isInherited = Record.readInt();
2233 0 : bool isImplicit = Record.readInt();
2234 0 : unsigned Spelling = Record.readInt();
2235 : std::string model= Record.readString();
2236 0 : New = new (Context) TLSModelAttr(Range, Context, model, Spelling);
2237 : cast<InheritableAttr>(New)->setInherited(isInherited);
2238 : New->setImplicit(isImplicit);
2239 : break;
2240 : }
2241 9 : case attr::Target: {
2242 9 : bool isInherited = Record.readInt();
2243 9 : bool isImplicit = Record.readInt();
2244 9 : unsigned Spelling = Record.readInt();
2245 : std::string featuresStr= Record.readString();
2246 9 : New = new (Context) TargetAttr(Range, Context, featuresStr, Spelling);
2247 : cast<InheritableAttr>(New)->setInherited(isInherited);
2248 : New->setImplicit(isImplicit);
2249 : break;
2250 : }
2251 0 : case attr::TestTypestate: {
2252 0 : bool isInherited = Record.readInt();
2253 0 : bool isImplicit = Record.readInt();
2254 0 : unsigned Spelling = Record.readInt();
2255 0 : TestTypestateAttr::ConsumedState testState(static_cast<TestTypestateAttr::ConsumedState>(Record.readInt()));
2256 : New = new (Context) TestTypestateAttr(Range, Context, testState, Spelling);
2257 : cast<InheritableAttr>(New)->setInherited(isInherited);
2258 : New->setImplicit(isImplicit);
2259 : break;
2260 : }
2261 0 : case attr::ThisCall: {
2262 0 : bool isInherited = Record.readInt();
2263 0 : bool isImplicit = Record.readInt();
2264 0 : unsigned Spelling = Record.readInt();
2265 : New = new (Context) ThisCallAttr(Range, Context, Spelling);
2266 : cast<InheritableAttr>(New)->setInherited(isInherited);
2267 : New->setImplicit(isImplicit);
2268 : break;
2269 : }
2270 0 : case attr::Thread: {
2271 0 : bool isImplicit = Record.readInt();
2272 0 : unsigned Spelling = Record.readInt();
2273 : New = new (Context) ThreadAttr(Range, Context, Spelling);
2274 : New->setImplicit(isImplicit);
2275 : break;
2276 : }
2277 0 : case attr::TransparentUnion: {
2278 0 : bool isInherited = Record.readInt();
2279 0 : bool isImplicit = Record.readInt();
2280 0 : unsigned Spelling = Record.readInt();
2281 : New = new (Context) TransparentUnionAttr(Range, Context, Spelling);
2282 : cast<InheritableAttr>(New)->setInherited(isInherited);
2283 : New->setImplicit(isImplicit);
2284 : break;
2285 : }
2286 0 : case attr::TrivialABI: {
2287 0 : bool isInherited = Record.readInt();
2288 0 : bool isImplicit = Record.readInt();
2289 0 : unsigned Spelling = Record.readInt();
2290 : New = new (Context) TrivialABIAttr(Range, Context, Spelling);
2291 : cast<InheritableAttr>(New)->setInherited(isInherited);
2292 : New->setImplicit(isImplicit);
2293 : break;
2294 : }
2295 0 : case attr::TryAcquireCapability: {
2296 0 : bool isInherited = Record.readInt();
2297 0 : bool isImplicit = Record.readInt();
2298 0 : unsigned Spelling = Record.readInt();
2299 : Expr * successValue = Record.readExpr();
2300 0 : unsigned argsSize = Record.readInt();
2301 : SmallVector<Expr *, 4> args;
2302 : args.reserve(argsSize);
2303 0 : for (unsigned i = 0; i != argsSize; ++i)
2304 0 : args.push_back(Record.readExpr());
2305 0 : New = new (Context) TryAcquireCapabilityAttr(Range, Context, successValue, args.data(), argsSize, Spelling);
2306 : cast<InheritableAttr>(New)->setInherited(isInherited);
2307 : New->setImplicit(isImplicit);
2308 : break;
2309 : }
2310 0 : case attr::TypeNonNull: {
2311 0 : bool isImplicit = Record.readInt();
2312 0 : unsigned Spelling = Record.readInt();
2313 : New = new (Context) TypeNonNullAttr(Range, Context, Spelling);
2314 : New->setImplicit(isImplicit);
2315 : break;
2316 : }
2317 0 : case attr::TypeNullUnspecified: {
2318 0 : bool isImplicit = Record.readInt();
2319 0 : unsigned Spelling = Record.readInt();
2320 : New = new (Context) TypeNullUnspecifiedAttr(Range, Context, Spelling);
2321 : New->setImplicit(isImplicit);
2322 : break;
2323 : }
2324 4 : case attr::TypeNullable: {
2325 4 : bool isImplicit = Record.readInt();
2326 4 : unsigned Spelling = Record.readInt();
2327 : New = new (Context) TypeNullableAttr(Range, Context, Spelling);
2328 : New->setImplicit(isImplicit);
2329 : break;
2330 : }
2331 0 : case attr::TypeTagForDatatype: {
2332 0 : bool isInherited = Record.readInt();
2333 0 : bool isImplicit = Record.readInt();
2334 0 : unsigned Spelling = Record.readInt();
2335 : IdentifierInfo * argumentKind = Record.getIdentifierInfo();
2336 : TypeSourceInfo * matchingCType = Record.getTypeSourceInfo();
2337 0 : bool layoutCompatible = Record.readInt();
2338 0 : bool mustBeNull = Record.readInt();
2339 : New = new (Context) TypeTagForDatatypeAttr(Range, Context, argumentKind, matchingCType, layoutCompatible, mustBeNull, Spelling);
2340 : cast<InheritableAttr>(New)->setInherited(isInherited);
2341 : New->setImplicit(isImplicit);
2342 : break;
2343 : }
2344 9 : case attr::TypeVisibility: {
2345 9 : bool isInherited = Record.readInt();
2346 9 : bool isImplicit = Record.readInt();
2347 9 : unsigned Spelling = Record.readInt();
2348 9 : TypeVisibilityAttr::VisibilityType visibility(static_cast<TypeVisibilityAttr::VisibilityType>(Record.readInt()));
2349 : New = new (Context) TypeVisibilityAttr(Range, Context, visibility, Spelling);
2350 : cast<InheritableAttr>(New)->setInherited(isInherited);
2351 : New->setImplicit(isImplicit);
2352 : break;
2353 : }
2354 0 : case attr::UPtr: {
2355 0 : bool isImplicit = Record.readInt();
2356 0 : unsigned Spelling = Record.readInt();
2357 : New = new (Context) UPtrAttr(Range, Context, Spelling);
2358 : New->setImplicit(isImplicit);
2359 : break;
2360 : }
2361 8 : case attr::Unavailable: {
2362 8 : bool isInherited = Record.readInt();
2363 8 : bool isImplicit = Record.readInt();
2364 8 : unsigned Spelling = Record.readInt();
2365 : std::string message= Record.readString();
2366 8 : UnavailableAttr::ImplicitReason implicitReason(static_cast<UnavailableAttr::ImplicitReason>(Record.readInt()));
2367 8 : New = new (Context) UnavailableAttr(Range, Context, message, implicitReason, Spelling);
2368 : cast<InheritableAttr>(New)->setInherited(isInherited);
2369 : New->setImplicit(isImplicit);
2370 : break;
2371 : }
2372 0 : case attr::Unused: {
2373 0 : bool isInherited = Record.readInt();
2374 0 : bool isImplicit = Record.readInt();
2375 0 : unsigned Spelling = Record.readInt();
2376 : New = new (Context) UnusedAttr(Range, Context, Spelling);
2377 : cast<InheritableAttr>(New)->setInherited(isInherited);
2378 : New->setImplicit(isImplicit);
2379 : break;
2380 : }
2381 0 : case attr::Used: {
2382 0 : bool isInherited = Record.readInt();
2383 0 : bool isImplicit = Record.readInt();
2384 0 : unsigned Spelling = Record.readInt();
2385 : New = new (Context) UsedAttr(Range, Context, Spelling);
2386 : cast<InheritableAttr>(New)->setInherited(isInherited);
2387 : New->setImplicit(isImplicit);
2388 : break;
2389 : }
2390 0 : case attr::Uuid: {
2391 0 : bool isInherited = Record.readInt();
2392 0 : bool isImplicit = Record.readInt();
2393 0 : unsigned Spelling = Record.readInt();
2394 : std::string guid= Record.readString();
2395 0 : New = new (Context) UuidAttr(Range, Context, guid, Spelling);
2396 : cast<InheritableAttr>(New)->setInherited(isInherited);
2397 : New->setImplicit(isImplicit);
2398 : break;
2399 : }
2400 0 : case attr::VecReturn: {
2401 0 : bool isInherited = Record.readInt();
2402 0 : bool isImplicit = Record.readInt();
2403 0 : unsigned Spelling = Record.readInt();
2404 : New = new (Context) VecReturnAttr(Range, Context, Spelling);
2405 : cast<InheritableAttr>(New)->setInherited(isInherited);
2406 : New->setImplicit(isImplicit);
2407 : break;
2408 : }
2409 0 : case attr::VecTypeHint: {
2410 0 : bool isInherited = Record.readInt();
2411 0 : bool isImplicit = Record.readInt();
2412 0 : unsigned Spelling = Record.readInt();
2413 : TypeSourceInfo * typeHint = Record.getTypeSourceInfo();
2414 : New = new (Context) VecTypeHintAttr(Range, Context, typeHint, Spelling);
2415 : cast<InheritableAttr>(New)->setInherited(isInherited);
2416 : New->setImplicit(isImplicit);
2417 : break;
2418 : }
2419 0 : case attr::VectorCall: {
2420 0 : bool isInherited = Record.readInt();
2421 0 : bool isImplicit = Record.readInt();
2422 0 : unsigned Spelling = Record.readInt();
2423 : New = new (Context) VectorCallAttr(Range, Context, Spelling);
2424 : cast<InheritableAttr>(New)->setInherited(isInherited);
2425 : New->setImplicit(isImplicit);
2426 : break;
2427 : }
2428 76 : case attr::Visibility: {
2429 76 : bool isInherited = Record.readInt();
2430 76 : bool isImplicit = Record.readInt();
2431 76 : unsigned Spelling = Record.readInt();
2432 76 : VisibilityAttr::VisibilityType visibility(static_cast<VisibilityAttr::VisibilityType>(Record.readInt()));
2433 : New = new (Context) VisibilityAttr(Range, Context, visibility, Spelling);
2434 : cast<InheritableAttr>(New)->setInherited(isInherited);
2435 : New->setImplicit(isImplicit);
2436 : break;
2437 : }
2438 0 : case attr::WarnUnused: {
2439 0 : bool isInherited = Record.readInt();
2440 0 : bool isImplicit = Record.readInt();
2441 0 : unsigned Spelling = Record.readInt();
2442 : New = new (Context) WarnUnusedAttr(Range, Context, Spelling);
2443 : cast<InheritableAttr>(New)->setInherited(isInherited);
2444 : New->setImplicit(isImplicit);
2445 : break;
2446 : }
2447 0 : case attr::WarnUnusedResult: {
2448 0 : bool isInherited = Record.readInt();
2449 0 : bool isImplicit = Record.readInt();
2450 0 : unsigned Spelling = Record.readInt();
2451 : New = new (Context) WarnUnusedResultAttr(Range, Context, Spelling);
2452 : cast<InheritableAttr>(New)->setInherited(isInherited);
2453 : New->setImplicit(isImplicit);
2454 : break;
2455 : }
2456 140 : case attr::Weak: {
2457 140 : bool isInherited = Record.readInt();
2458 140 : bool isImplicit = Record.readInt();
2459 140 : unsigned Spelling = Record.readInt();
2460 : New = new (Context) WeakAttr(Range, Context, Spelling);
2461 : cast<InheritableAttr>(New)->setInherited(isInherited);
2462 : New->setImplicit(isImplicit);
2463 : break;
2464 : }
2465 0 : case attr::WeakImport: {
2466 0 : bool isInherited = Record.readInt();
2467 0 : bool isImplicit = Record.readInt();
2468 0 : unsigned Spelling = Record.readInt();
2469 : New = new (Context) WeakImportAttr(Range, Context, Spelling);
2470 : cast<InheritableAttr>(New)->setInherited(isInherited);
2471 : New->setImplicit(isImplicit);
2472 : break;
2473 : }
2474 2 : case attr::WeakRef: {
2475 2 : bool isInherited = Record.readInt();
2476 2 : bool isImplicit = Record.readInt();
2477 2 : unsigned Spelling = Record.readInt();
2478 : std::string aliasee= Record.readString();
2479 2 : New = new (Context) WeakRefAttr(Range, Context, aliasee, Spelling);
2480 : cast<InheritableAttr>(New)->setInherited(isInherited);
2481 : New->setImplicit(isImplicit);
2482 : break;
2483 : }
2484 0 : case attr::WorkGroupSizeHint: {
2485 0 : bool isInherited = Record.readInt();
2486 0 : bool isImplicit = Record.readInt();
2487 0 : unsigned Spelling = Record.readInt();
2488 0 : unsigned xDim = Record.readInt();
2489 0 : unsigned yDim = Record.readInt();
2490 0 : unsigned zDim = Record.readInt();
2491 : New = new (Context) WorkGroupSizeHintAttr(Range, Context, xDim, yDim, zDim, Spelling);
2492 : cast<InheritableAttr>(New)->setInherited(isInherited);
2493 : New->setImplicit(isImplicit);
2494 : break;
2495 : }
2496 0 : case attr::X86ForceAlignArgPointer: {
2497 0 : bool isInherited = Record.readInt();
2498 0 : bool isImplicit = Record.readInt();
2499 0 : unsigned Spelling = Record.readInt();
2500 : New = new (Context) X86ForceAlignArgPointerAttr(Range, Context, Spelling);
2501 : cast<InheritableAttr>(New)->setInherited(isInherited);
2502 : New->setImplicit(isImplicit);
2503 : break;
2504 : }
2505 0 : case attr::XRayInstrument: {
2506 0 : bool isInherited = Record.readInt();
2507 0 : bool isImplicit = Record.readInt();
2508 0 : unsigned Spelling = Record.readInt();
2509 : New = new (Context) XRayInstrumentAttr(Range, Context, Spelling);
2510 : cast<InheritableAttr>(New)->setInherited(isInherited);
2511 : New->setImplicit(isImplicit);
2512 : break;
2513 : }
2514 2 : case attr::XRayLogArgs: {
2515 2 : bool isInherited = Record.readInt();
2516 2 : bool isImplicit = Record.readInt();
2517 2 : unsigned Spelling = Record.readInt();
2518 2 : unsigned argumentCount = Record.readInt();
2519 : New = new (Context) XRayLogArgsAttr(Range, Context, argumentCount, Spelling);
2520 : cast<InheritableAttr>(New)->setInherited(isInherited);
2521 : New->setImplicit(isImplicit);
2522 : break;
2523 : }
2524 : }
|
