1 //===- TypeLoc.cpp - Type Source Info Wrapper -----------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  This file defines the TypeLoc subclasses implementations.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/TypeLoc.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Expr.h"
17 #include "clang/AST/NestedNameSpecifier.h"
18 #include "clang/AST/TemplateBase.h"
19 #include "clang/AST/TemplateName.h"
20 #include "clang/AST/TypeLocVisitor.h"
21 #include "clang/Basic/SourceLocation.h"
22 #include "clang/Basic/Specifiers.h"
23 #include "llvm/Support/ErrorHandling.h"
24 #include "llvm/Support/MathExtras.h"
25 #include <algorithm>
26 #include <cassert>
27 #include <cstdint>
28 #include <cstring>
29 
30 using namespace clang;
31 
32 static const unsigned TypeLocMaxDataAlign = alignof(void *);
33 
34 //===----------------------------------------------------------------------===//
35 // TypeLoc Implementation
36 //===----------------------------------------------------------------------===//
37 
38 namespace {
39 
40 class TypeLocRanger : public TypeLocVisitor<TypeLocRanger, SourceRange> {
41 public:
42 #define ABSTRACT_TYPELOC(CLASS, PARENT)
43 #define TYPELOC(CLASS, PARENT) \
44   SourceRange Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
45     return TyLoc.getLocalSourceRange(); \
46   }
47 #include "clang/AST/TypeLocNodes.def"
48 };
49 
50 } // namespace
51 
getLocalSourceRangeImpl(TypeLoc TL)52 SourceRange TypeLoc::getLocalSourceRangeImpl(TypeLoc TL) {
53   if (TL.isNull()) return SourceRange();
54   return TypeLocRanger().Visit(TL);
55 }
56 
57 namespace {
58 
59 class TypeAligner : public TypeLocVisitor<TypeAligner, unsigned> {
60 public:
61 #define ABSTRACT_TYPELOC(CLASS, PARENT)
62 #define TYPELOC(CLASS, PARENT) \
63   unsigned Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
64     return TyLoc.getLocalDataAlignment(); \
65   }
66 #include "clang/AST/TypeLocNodes.def"
67 };
68 
69 } // namespace
70 
71 /// Returns the alignment of the type source info data block.
getLocalAlignmentForType(QualType Ty)72 unsigned TypeLoc::getLocalAlignmentForType(QualType Ty) {
73   if (Ty.isNull()) return 1;
74   return TypeAligner().Visit(TypeLoc(Ty, nullptr));
75 }
76 
77 namespace {
78 
79 class TypeSizer : public TypeLocVisitor<TypeSizer, unsigned> {
80 public:
81 #define ABSTRACT_TYPELOC(CLASS, PARENT)
82 #define TYPELOC(CLASS, PARENT) \
83   unsigned Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
84     return TyLoc.getLocalDataSize(); \
85   }
86 #include "clang/AST/TypeLocNodes.def"
87 };
88 
89 } // namespace
90 
91 /// Returns the size of the type source info data block.
getFullDataSizeForType(QualType Ty)92 unsigned TypeLoc::getFullDataSizeForType(QualType Ty) {
93   unsigned Total = 0;
94   TypeLoc TyLoc(Ty, nullptr);
95   unsigned MaxAlign = 1;
96   while (!TyLoc.isNull()) {
97     unsigned Align = getLocalAlignmentForType(TyLoc.getType());
98     MaxAlign = std::max(Align, MaxAlign);
99     Total = llvm::alignTo(Total, Align);
100     Total += TypeSizer().Visit(TyLoc);
101     TyLoc = TyLoc.getNextTypeLoc();
102   }
103   Total = llvm::alignTo(Total, MaxAlign);
104   return Total;
105 }
106 
107 namespace {
108 
109 class NextLoc : public TypeLocVisitor<NextLoc, TypeLoc> {
110 public:
111 #define ABSTRACT_TYPELOC(CLASS, PARENT)
112 #define TYPELOC(CLASS, PARENT) \
113   TypeLoc Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
114     return TyLoc.getNextTypeLoc(); \
115   }
116 #include "clang/AST/TypeLocNodes.def"
117 };
118 
119 } // namespace
120 
121 /// Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the
122 /// TypeLoc is a PointerLoc and next TypeLoc is for "int".
getNextTypeLocImpl(TypeLoc TL)123 TypeLoc TypeLoc::getNextTypeLocImpl(TypeLoc TL) {
124   return NextLoc().Visit(TL);
125 }
126 
127 /// Initializes a type location, and all of its children
128 /// recursively, as if the entire tree had been written in the
129 /// given location.
initializeImpl(ASTContext & Context,TypeLoc TL,SourceLocation Loc)130 void TypeLoc::initializeImpl(ASTContext &Context, TypeLoc TL,
131                              SourceLocation Loc) {
132   while (true) {
133     switch (TL.getTypeLocClass()) {
134 #define ABSTRACT_TYPELOC(CLASS, PARENT)
135 #define TYPELOC(CLASS, PARENT)        \
136     case CLASS: {                     \
137       CLASS##TypeLoc TLCasted = TL.castAs<CLASS##TypeLoc>(); \
138       TLCasted.initializeLocal(Context, Loc);  \
139       TL = TLCasted.getNextTypeLoc(); \
140       if (!TL) return;                \
141       continue;                       \
142     }
143 #include "clang/AST/TypeLocNodes.def"
144     }
145   }
146 }
147 
148 namespace {
149 
150 class TypeLocCopier : public TypeLocVisitor<TypeLocCopier> {
151   TypeLoc Source;
152 
153 public:
TypeLocCopier(TypeLoc source)154   TypeLocCopier(TypeLoc source) : Source(source) {}
155 
156 #define ABSTRACT_TYPELOC(CLASS, PARENT)
157 #define TYPELOC(CLASS, PARENT)                          \
158   void Visit##CLASS##TypeLoc(CLASS##TypeLoc dest) {   \
159     dest.copyLocal(Source.castAs<CLASS##TypeLoc>());  \
160   }
161 #include "clang/AST/TypeLocNodes.def"
162 };
163 
164 } // namespace
165 
copy(TypeLoc other)166 void TypeLoc::copy(TypeLoc other) {
167   assert(getFullDataSize() == other.getFullDataSize());
168 
169   // If both data pointers are aligned to the maximum alignment, we
170   // can memcpy because getFullDataSize() accurately reflects the
171   // layout of the data.
172   if (reinterpret_cast<uintptr_t>(Data) ==
173           llvm::alignTo(reinterpret_cast<uintptr_t>(Data),
174                         TypeLocMaxDataAlign) &&
175       reinterpret_cast<uintptr_t>(other.Data) ==
176           llvm::alignTo(reinterpret_cast<uintptr_t>(other.Data),
177                         TypeLocMaxDataAlign)) {
178     memcpy(Data, other.Data, getFullDataSize());
179     return;
180   }
181 
182   // Copy each of the pieces.
183   TypeLoc TL(getType(), Data);
184   do {
185     TypeLocCopier(other).Visit(TL);
186     other = other.getNextTypeLoc();
187   } while ((TL = TL.getNextTypeLoc()));
188 }
189 
getBeginLoc() const190 SourceLocation TypeLoc::getBeginLoc() const {
191   TypeLoc Cur = *this;
192   TypeLoc LeftMost = Cur;
193   while (true) {
194     switch (Cur.getTypeLocClass()) {
195     case Elaborated:
196       LeftMost = Cur;
197       break;
198     case FunctionProto:
199       if (Cur.castAs<FunctionProtoTypeLoc>().getTypePtr()
200               ->hasTrailingReturn()) {
201         LeftMost = Cur;
202         break;
203       }
204       LLVM_FALLTHROUGH;
205     case FunctionNoProto:
206     case ConstantArray:
207     case DependentSizedArray:
208     case IncompleteArray:
209     case VariableArray:
210       // FIXME: Currently QualifiedTypeLoc does not have a source range
211     case Qualified:
212       Cur = Cur.getNextTypeLoc();
213       continue;
214     default:
215       if (Cur.getLocalSourceRange().getBegin().isValid())
216         LeftMost = Cur;
217       Cur = Cur.getNextTypeLoc();
218       if (Cur.isNull())
219         break;
220       continue;
221     } // switch
222     break;
223   } // while
224   return LeftMost.getLocalSourceRange().getBegin();
225 }
226 
getEndLoc() const227 SourceLocation TypeLoc::getEndLoc() const {
228   TypeLoc Cur = *this;
229   TypeLoc Last;
230   while (true) {
231     switch (Cur.getTypeLocClass()) {
232     default:
233       if (!Last)
234         Last = Cur;
235       return Last.getLocalSourceRange().getEnd();
236     case Paren:
237     case ConstantArray:
238     case DependentSizedArray:
239     case IncompleteArray:
240     case VariableArray:
241     case FunctionNoProto:
242       Last = Cur;
243       break;
244     case FunctionProto:
245       if (Cur.castAs<FunctionProtoTypeLoc>().getTypePtr()->hasTrailingReturn())
246         Last = TypeLoc();
247       else
248         Last = Cur;
249       break;
250     case Pointer:
251     case BlockPointer:
252     case MemberPointer:
253     case LValueReference:
254     case RValueReference:
255     case PackExpansion:
256       if (!Last)
257         Last = Cur;
258       break;
259     case Qualified:
260     case Elaborated:
261       break;
262     }
263     Cur = Cur.getNextTypeLoc();
264   }
265 }
266 
267 namespace {
268 
269 struct TSTChecker : public TypeLocVisitor<TSTChecker, bool> {
270   // Overload resolution does the real work for us.
isTypeSpec__anon5cfb1ec00611::TSTChecker271   static bool isTypeSpec(TypeSpecTypeLoc _) { return true; }
isTypeSpec__anon5cfb1ec00611::TSTChecker272   static bool isTypeSpec(TypeLoc _) { return false; }
273 
274 #define ABSTRACT_TYPELOC(CLASS, PARENT)
275 #define TYPELOC(CLASS, PARENT) \
276   bool Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
277     return isTypeSpec(TyLoc); \
278   }
279 #include "clang/AST/TypeLocNodes.def"
280 };
281 
282 } // namespace
283 
284 /// Determines if the given type loc corresponds to a
285 /// TypeSpecTypeLoc.  Since there is not actually a TypeSpecType in
286 /// the type hierarchy, this is made somewhat complicated.
287 ///
288 /// There are a lot of types that currently use TypeSpecTypeLoc
289 /// because it's a convenient base class.  Ideally we would not accept
290 /// those here, but ideally we would have better implementations for
291 /// them.
isKind(const TypeLoc & TL)292 bool TypeSpecTypeLoc::isKind(const TypeLoc &TL) {
293   if (TL.getType().hasLocalQualifiers()) return false;
294   return TSTChecker().Visit(TL);
295 }
296 
297 // Reimplemented to account for GNU/C++ extension
298 //     typeof unary-expression
299 // where there are no parentheses.
getLocalSourceRange() const300 SourceRange TypeOfExprTypeLoc::getLocalSourceRange() const {
301   if (getRParenLoc().isValid())
302     return SourceRange(getTypeofLoc(), getRParenLoc());
303   else
304     return SourceRange(getTypeofLoc(),
305                        getUnderlyingExpr()->getSourceRange().getEnd());
306 }
307 
308 
getWrittenTypeSpec() const309 TypeSpecifierType BuiltinTypeLoc::getWrittenTypeSpec() const {
310   if (needsExtraLocalData())
311     return static_cast<TypeSpecifierType>(getWrittenBuiltinSpecs().Type);
312   switch (getTypePtr()->getKind()) {
313   case BuiltinType::Void:
314     return TST_void;
315   case BuiltinType::Bool:
316     return TST_bool;
317   case BuiltinType::Char_U:
318   case BuiltinType::Char_S:
319     return TST_char;
320   case BuiltinType::Char8:
321     return TST_char8;
322   case BuiltinType::Char16:
323     return TST_char16;
324   case BuiltinType::Char32:
325     return TST_char32;
326   case BuiltinType::WChar_S:
327   case BuiltinType::WChar_U:
328     return TST_wchar;
329   case BuiltinType::UChar:
330   case BuiltinType::UShort:
331   case BuiltinType::UInt:
332   case BuiltinType::ULong:
333   case BuiltinType::ULongLong:
334   case BuiltinType::UInt128:
335   case BuiltinType::SChar:
336   case BuiltinType::Short:
337   case BuiltinType::Int:
338   case BuiltinType::Long:
339   case BuiltinType::LongLong:
340   case BuiltinType::Int128:
341   case BuiltinType::Half:
342   case BuiltinType::Float:
343   case BuiltinType::Double:
344   case BuiltinType::LongDouble:
345   case BuiltinType::Float16:
346   case BuiltinType::Float128:
347   case BuiltinType::ShortAccum:
348   case BuiltinType::Accum:
349   case BuiltinType::LongAccum:
350   case BuiltinType::UShortAccum:
351   case BuiltinType::UAccum:
352   case BuiltinType::ULongAccum:
353   case BuiltinType::ShortFract:
354   case BuiltinType::Fract:
355   case BuiltinType::LongFract:
356   case BuiltinType::UShortFract:
357   case BuiltinType::UFract:
358   case BuiltinType::ULongFract:
359   case BuiltinType::SatShortAccum:
360   case BuiltinType::SatAccum:
361   case BuiltinType::SatLongAccum:
362   case BuiltinType::SatUShortAccum:
363   case BuiltinType::SatUAccum:
364   case BuiltinType::SatULongAccum:
365   case BuiltinType::SatShortFract:
366   case BuiltinType::SatFract:
367   case BuiltinType::SatLongFract:
368   case BuiltinType::SatUShortFract:
369   case BuiltinType::SatUFract:
370   case BuiltinType::SatULongFract:
371     llvm_unreachable("Builtin type needs extra local data!");
372     // Fall through, if the impossible happens.
373 
374   case BuiltinType::NullPtr:
375   case BuiltinType::Overload:
376   case BuiltinType::Dependent:
377   case BuiltinType::BoundMember:
378   case BuiltinType::UnknownAny:
379   case BuiltinType::ARCUnbridgedCast:
380   case BuiltinType::PseudoObject:
381   case BuiltinType::ObjCId:
382   case BuiltinType::ObjCClass:
383   case BuiltinType::ObjCSel:
384 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
385   case BuiltinType::Id:
386 #include "clang/Basic/OpenCLImageTypes.def"
387 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
388   case BuiltinType::Id:
389 #include "clang/Basic/OpenCLExtensionTypes.def"
390   case BuiltinType::OCLSampler:
391   case BuiltinType::OCLEvent:
392   case BuiltinType::OCLClkEvent:
393   case BuiltinType::OCLQueue:
394   case BuiltinType::OCLReserveID:
395   case BuiltinType::BuiltinFn:
396   case BuiltinType::OMPArraySection:
397     return TST_unspecified;
398   }
399 
400   llvm_unreachable("Invalid BuiltinType Kind!");
401 }
402 
IgnoreParensImpl(TypeLoc TL)403 TypeLoc TypeLoc::IgnoreParensImpl(TypeLoc TL) {
404   while (ParenTypeLoc PTL = TL.getAs<ParenTypeLoc>())
405     TL = PTL.getInnerLoc();
406   return TL;
407 }
408 
findNullabilityLoc() const409 SourceLocation TypeLoc::findNullabilityLoc() const {
410   if (auto ATL = getAs<AttributedTypeLoc>()) {
411     const Attr *A = ATL.getAttr();
412     if (A && (isa<TypeNullableAttr>(A) || isa<TypeNonNullAttr>(A) ||
413               isa<TypeNullUnspecifiedAttr>(A)))
414       return A->getLocation();
415   }
416 
417   return {};
418 }
419 
findExplicitQualifierLoc() const420 TypeLoc TypeLoc::findExplicitQualifierLoc() const {
421   // Qualified types.
422   if (auto qual = getAs<QualifiedTypeLoc>())
423     return qual;
424 
425   TypeLoc loc = IgnoreParens();
426 
427   // Attributed types.
428   if (auto attr = loc.getAs<AttributedTypeLoc>()) {
429     if (attr.isQualifier()) return attr;
430     return attr.getModifiedLoc().findExplicitQualifierLoc();
431   }
432 
433   // C11 _Atomic types.
434   if (auto atomic = loc.getAs<AtomicTypeLoc>()) {
435     return atomic;
436   }
437 
438   return {};
439 }
440 
initializeLocal(ASTContext & Context,SourceLocation Loc)441 void ObjCTypeParamTypeLoc::initializeLocal(ASTContext &Context,
442                                            SourceLocation Loc) {
443   setNameLoc(Loc);
444   if (!getNumProtocols()) return;
445 
446   setProtocolLAngleLoc(Loc);
447   setProtocolRAngleLoc(Loc);
448   for (unsigned i = 0, e = getNumProtocols(); i != e; ++i)
449     setProtocolLoc(i, Loc);
450 }
451 
initializeLocal(ASTContext & Context,SourceLocation Loc)452 void ObjCObjectTypeLoc::initializeLocal(ASTContext &Context,
453                                         SourceLocation Loc) {
454   setHasBaseTypeAsWritten(true);
455   setTypeArgsLAngleLoc(Loc);
456   setTypeArgsRAngleLoc(Loc);
457   for (unsigned i = 0, e = getNumTypeArgs(); i != e; ++i) {
458     setTypeArgTInfo(i,
459                    Context.getTrivialTypeSourceInfo(
460                      getTypePtr()->getTypeArgsAsWritten()[i], Loc));
461   }
462   setProtocolLAngleLoc(Loc);
463   setProtocolRAngleLoc(Loc);
464   for (unsigned i = 0, e = getNumProtocols(); i != e; ++i)
465     setProtocolLoc(i, Loc);
466 }
467 
initializeLocal(ASTContext & Context,SourceLocation Loc)468 void TypeOfTypeLoc::initializeLocal(ASTContext &Context,
469                                        SourceLocation Loc) {
470   TypeofLikeTypeLoc<TypeOfTypeLoc, TypeOfType, TypeOfTypeLocInfo>
471       ::initializeLocal(Context, Loc);
472   this->getLocalData()->UnderlyingTInfo = Context.getTrivialTypeSourceInfo(
473       getUnderlyingType(), Loc);
474 }
475 
initializeLocal(ASTContext & Context,SourceLocation Loc)476 void UnaryTransformTypeLoc::initializeLocal(ASTContext &Context,
477                                        SourceLocation Loc) {
478     setKWLoc(Loc);
479     setRParenLoc(Loc);
480     setLParenLoc(Loc);
481     this->setUnderlyingTInfo(
482         Context.getTrivialTypeSourceInfo(getTypePtr()->getBaseType(), Loc));
483 }
484 
initializeLocal(ASTContext & Context,SourceLocation Loc)485 void ElaboratedTypeLoc::initializeLocal(ASTContext &Context,
486                                         SourceLocation Loc) {
487   setElaboratedKeywordLoc(Loc);
488   NestedNameSpecifierLocBuilder Builder;
489   Builder.MakeTrivial(Context, getTypePtr()->getQualifier(), Loc);
490   setQualifierLoc(Builder.getWithLocInContext(Context));
491 }
492 
initializeLocal(ASTContext & Context,SourceLocation Loc)493 void DependentNameTypeLoc::initializeLocal(ASTContext &Context,
494                                            SourceLocation Loc) {
495   setElaboratedKeywordLoc(Loc);
496   NestedNameSpecifierLocBuilder Builder;
497   Builder.MakeTrivial(Context, getTypePtr()->getQualifier(), Loc);
498   setQualifierLoc(Builder.getWithLocInContext(Context));
499   setNameLoc(Loc);
500 }
501 
502 void
initializeLocal(ASTContext & Context,SourceLocation Loc)503 DependentTemplateSpecializationTypeLoc::initializeLocal(ASTContext &Context,
504                                                         SourceLocation Loc) {
505   setElaboratedKeywordLoc(Loc);
506   if (getTypePtr()->getQualifier()) {
507     NestedNameSpecifierLocBuilder Builder;
508     Builder.MakeTrivial(Context, getTypePtr()->getQualifier(), Loc);
509     setQualifierLoc(Builder.getWithLocInContext(Context));
510   } else {
511     setQualifierLoc(NestedNameSpecifierLoc());
512   }
513   setTemplateKeywordLoc(Loc);
514   setTemplateNameLoc(Loc);
515   setLAngleLoc(Loc);
516   setRAngleLoc(Loc);
517   TemplateSpecializationTypeLoc::initializeArgLocs(Context, getNumArgs(),
518                                                    getTypePtr()->getArgs(),
519                                                    getArgInfos(), Loc);
520 }
521 
initializeArgLocs(ASTContext & Context,unsigned NumArgs,const TemplateArgument * Args,TemplateArgumentLocInfo * ArgInfos,SourceLocation Loc)522 void TemplateSpecializationTypeLoc::initializeArgLocs(ASTContext &Context,
523                                                       unsigned NumArgs,
524                                                   const TemplateArgument *Args,
525                                               TemplateArgumentLocInfo *ArgInfos,
526                                                       SourceLocation Loc) {
527   for (unsigned i = 0, e = NumArgs; i != e; ++i) {
528     switch (Args[i].getKind()) {
529     case TemplateArgument::Null:
530       llvm_unreachable("Impossible TemplateArgument");
531 
532     case TemplateArgument::Integral:
533     case TemplateArgument::Declaration:
534     case TemplateArgument::NullPtr:
535       ArgInfos[i] = TemplateArgumentLocInfo();
536       break;
537 
538     case TemplateArgument::Expression:
539       ArgInfos[i] = TemplateArgumentLocInfo(Args[i].getAsExpr());
540       break;
541 
542     case TemplateArgument::Type:
543       ArgInfos[i] = TemplateArgumentLocInfo(
544                           Context.getTrivialTypeSourceInfo(Args[i].getAsType(),
545                                                            Loc));
546       break;
547 
548     case TemplateArgument::Template:
549     case TemplateArgument::TemplateExpansion: {
550       NestedNameSpecifierLocBuilder Builder;
551       TemplateName Template = Args[i].getAsTemplateOrTemplatePattern();
552       if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
553         Builder.MakeTrivial(Context, DTN->getQualifier(), Loc);
554       else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
555         Builder.MakeTrivial(Context, QTN->getQualifier(), Loc);
556 
557       ArgInfos[i] = TemplateArgumentLocInfo(
558           Builder.getWithLocInContext(Context), Loc,
559           Args[i].getKind() == TemplateArgument::Template ? SourceLocation()
560                                                           : Loc);
561       break;
562     }
563 
564     case TemplateArgument::Pack:
565       ArgInfos[i] = TemplateArgumentLocInfo();
566       break;
567     }
568   }
569 }
570