1 //===- USRGeneration.cpp - Routines for USR generation --------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "clang/Index/USRGeneration.h"
10 #include "clang/AST/ASTContext.h"
11 #include "clang/AST/Attr.h"
12 #include "clang/AST/DeclTemplate.h"
13 #include "clang/AST/DeclVisitor.h"
14 #include "clang/Basic/FileManager.h"
15 #include "clang/Lex/PreprocessingRecord.h"
16 #include "llvm/Support/Path.h"
17 #include "llvm/Support/raw_ostream.h"
18
19 using namespace clang;
20 using namespace clang::index;
21
22 //===----------------------------------------------------------------------===//
23 // USR generation.
24 //===----------------------------------------------------------------------===//
25
26 /// \returns true on error.
printLoc(llvm::raw_ostream & OS,SourceLocation Loc,const SourceManager & SM,bool IncludeOffset)27 static bool printLoc(llvm::raw_ostream &OS, SourceLocation Loc,
28 const SourceManager &SM, bool IncludeOffset) {
29 if (Loc.isInvalid()) {
30 return true;
31 }
32 Loc = SM.getExpansionLoc(Loc);
33 const std::pair<FileID, unsigned> &Decomposed = SM.getDecomposedLoc(Loc);
34 const FileEntry *FE = SM.getFileEntryForID(Decomposed.first);
35 if (FE) {
36 OS << llvm::sys::path::filename(FE->getName());
37 } else {
38 // This case really isn't interesting.
39 return true;
40 }
41 if (IncludeOffset) {
42 // Use the offest into the FileID to represent the location. Using
43 // a line/column can cause us to look back at the original source file,
44 // which is expensive.
45 OS << '@' << Decomposed.second;
46 }
47 return false;
48 }
49
GetExternalSourceContainer(const NamedDecl * D)50 static StringRef GetExternalSourceContainer(const NamedDecl *D) {
51 if (!D)
52 return StringRef();
53 if (auto *attr = D->getExternalSourceSymbolAttr()) {
54 return attr->getDefinedIn();
55 }
56 return StringRef();
57 }
58
59 namespace {
60 class USRGenerator : public ConstDeclVisitor<USRGenerator> {
61 SmallVectorImpl<char> &Buf;
62 llvm::raw_svector_ostream Out;
63 bool IgnoreResults;
64 ASTContext *Context;
65 bool generatedLoc;
66
67 llvm::DenseMap<const Type *, unsigned> TypeSubstitutions;
68
69 public:
USRGenerator(ASTContext * Ctx,SmallVectorImpl<char> & Buf)70 explicit USRGenerator(ASTContext *Ctx, SmallVectorImpl<char> &Buf)
71 : Buf(Buf),
72 Out(Buf),
73 IgnoreResults(false),
74 Context(Ctx),
75 generatedLoc(false)
76 {
77 // Add the USR space prefix.
78 Out << getUSRSpacePrefix();
79 }
80
ignoreResults() const81 bool ignoreResults() const { return IgnoreResults; }
82
83 // Visitation methods from generating USRs from AST elements.
84 void VisitDeclContext(const DeclContext *D);
85 void VisitFieldDecl(const FieldDecl *D);
86 void VisitFunctionDecl(const FunctionDecl *D);
87 void VisitNamedDecl(const NamedDecl *D);
88 void VisitNamespaceDecl(const NamespaceDecl *D);
89 void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D);
90 void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D);
91 void VisitClassTemplateDecl(const ClassTemplateDecl *D);
92 void VisitObjCContainerDecl(const ObjCContainerDecl *CD,
93 const ObjCCategoryDecl *CatD = nullptr);
94 void VisitObjCMethodDecl(const ObjCMethodDecl *MD);
95 void VisitObjCPropertyDecl(const ObjCPropertyDecl *D);
96 void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D);
97 void VisitTagDecl(const TagDecl *D);
98 void VisitTypedefDecl(const TypedefDecl *D);
99 void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D);
100 void VisitVarDecl(const VarDecl *D);
101 void VisitBindingDecl(const BindingDecl *D);
102 void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D);
103 void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D);
104 void VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D);
105 void VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D);
106
VisitLinkageSpecDecl(const LinkageSpecDecl * D)107 void VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
108 IgnoreResults = true; // No USRs for linkage specs themselves.
109 }
110
VisitUsingDirectiveDecl(const UsingDirectiveDecl * D)111 void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
112 IgnoreResults = true;
113 }
114
VisitUsingDecl(const UsingDecl * D)115 void VisitUsingDecl(const UsingDecl *D) {
116 VisitDeclContext(D->getDeclContext());
117 Out << "@UD@";
118
119 bool EmittedDeclName = !EmitDeclName(D);
120 assert(EmittedDeclName && "EmitDeclName can not fail for UsingDecls");
121 (void)EmittedDeclName;
122 }
123
124 bool ShouldGenerateLocation(const NamedDecl *D);
125
isLocal(const NamedDecl * D)126 bool isLocal(const NamedDecl *D) {
127 return D->getParentFunctionOrMethod() != nullptr;
128 }
129
130 void GenExtSymbolContainer(const NamedDecl *D);
131
132 /// Generate the string component containing the location of the
133 /// declaration.
134 bool GenLoc(const Decl *D, bool IncludeOffset);
135
136 /// String generation methods used both by the visitation methods
137 /// and from other clients that want to directly generate USRs. These
138 /// methods do not construct complete USRs (which incorporate the parents
139 /// of an AST element), but only the fragments concerning the AST element
140 /// itself.
141
142 /// Generate a USR for an Objective-C class.
GenObjCClass(StringRef cls,StringRef ExtSymDefinedIn,StringRef CategoryContextExtSymbolDefinedIn)143 void GenObjCClass(StringRef cls, StringRef ExtSymDefinedIn,
144 StringRef CategoryContextExtSymbolDefinedIn) {
145 generateUSRForObjCClass(cls, Out, ExtSymDefinedIn,
146 CategoryContextExtSymbolDefinedIn);
147 }
148
149 /// Generate a USR for an Objective-C class category.
GenObjCCategory(StringRef cls,StringRef cat,StringRef clsExt,StringRef catExt)150 void GenObjCCategory(StringRef cls, StringRef cat,
151 StringRef clsExt, StringRef catExt) {
152 generateUSRForObjCCategory(cls, cat, Out, clsExt, catExt);
153 }
154
155 /// Generate a USR fragment for an Objective-C property.
GenObjCProperty(StringRef prop,bool isClassProp)156 void GenObjCProperty(StringRef prop, bool isClassProp) {
157 generateUSRForObjCProperty(prop, isClassProp, Out);
158 }
159
160 /// Generate a USR for an Objective-C protocol.
GenObjCProtocol(StringRef prot,StringRef ext)161 void GenObjCProtocol(StringRef prot, StringRef ext) {
162 generateUSRForObjCProtocol(prot, Out, ext);
163 }
164
165 void VisitType(QualType T);
166 void VisitTemplateParameterList(const TemplateParameterList *Params);
167 void VisitTemplateName(TemplateName Name);
168 void VisitTemplateArgument(const TemplateArgument &Arg);
169
170 /// Emit a Decl's name using NamedDecl::printName() and return true if
171 /// the decl had no name.
172 bool EmitDeclName(const NamedDecl *D);
173 };
174 } // end anonymous namespace
175
176 //===----------------------------------------------------------------------===//
177 // Generating USRs from ASTS.
178 //===----------------------------------------------------------------------===//
179
EmitDeclName(const NamedDecl * D)180 bool USRGenerator::EmitDeclName(const NamedDecl *D) {
181 const unsigned startSize = Buf.size();
182 D->printName(Out);
183 const unsigned endSize = Buf.size();
184 return startSize == endSize;
185 }
186
ShouldGenerateLocation(const NamedDecl * D)187 bool USRGenerator::ShouldGenerateLocation(const NamedDecl *D) {
188 if (D->isExternallyVisible())
189 return false;
190 if (D->getParentFunctionOrMethod())
191 return true;
192 SourceLocation Loc = D->getLocation();
193 if (Loc.isInvalid())
194 return false;
195 const SourceManager &SM = Context->getSourceManager();
196 return !SM.isInSystemHeader(Loc);
197 }
198
VisitDeclContext(const DeclContext * DC)199 void USRGenerator::VisitDeclContext(const DeclContext *DC) {
200 if (const NamedDecl *D = dyn_cast<NamedDecl>(DC))
201 Visit(D);
202 else if (isa<LinkageSpecDecl>(DC)) // Linkage specs are transparent in USRs.
203 VisitDeclContext(DC->getParent());
204 }
205
VisitFieldDecl(const FieldDecl * D)206 void USRGenerator::VisitFieldDecl(const FieldDecl *D) {
207 // The USR for an ivar declared in a class extension is based on the
208 // ObjCInterfaceDecl, not the ObjCCategoryDecl.
209 if (const ObjCInterfaceDecl *ID = Context->getObjContainingInterface(D))
210 Visit(ID);
211 else
212 VisitDeclContext(D->getDeclContext());
213 Out << (isa<ObjCIvarDecl>(D) ? "@" : "@FI@");
214 if (EmitDeclName(D)) {
215 // Bit fields can be anonymous.
216 IgnoreResults = true;
217 return;
218 }
219 }
220
VisitFunctionDecl(const FunctionDecl * D)221 void USRGenerator::VisitFunctionDecl(const FunctionDecl *D) {
222 if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
223 return;
224
225 const unsigned StartSize = Buf.size();
226 VisitDeclContext(D->getDeclContext());
227 if (Buf.size() == StartSize)
228 GenExtSymbolContainer(D);
229
230 bool IsTemplate = false;
231 if (FunctionTemplateDecl *FunTmpl = D->getDescribedFunctionTemplate()) {
232 IsTemplate = true;
233 Out << "@FT@";
234 VisitTemplateParameterList(FunTmpl->getTemplateParameters());
235 } else
236 Out << "@F@";
237
238 PrintingPolicy Policy(Context->getLangOpts());
239 // Forward references can have different template argument names. Suppress the
240 // template argument names in constructors to make their USR more stable.
241 Policy.SuppressTemplateArgsInCXXConstructors = true;
242 D->getDeclName().print(Out, Policy);
243
244 ASTContext &Ctx = *Context;
245 if ((!Ctx.getLangOpts().CPlusPlus || D->isExternC()) &&
246 !D->hasAttr<OverloadableAttr>())
247 return;
248
249 if (const TemplateArgumentList *
250 SpecArgs = D->getTemplateSpecializationArgs()) {
251 Out << '<';
252 for (unsigned I = 0, N = SpecArgs->size(); I != N; ++I) {
253 Out << '#';
254 VisitTemplateArgument(SpecArgs->get(I));
255 }
256 Out << '>';
257 }
258
259 // Mangle in type information for the arguments.
260 for (auto PD : D->parameters()) {
261 Out << '#';
262 VisitType(PD->getType());
263 }
264 if (D->isVariadic())
265 Out << '.';
266 if (IsTemplate) {
267 // Function templates can be overloaded by return type, for example:
268 // \code
269 // template <class T> typename T::A foo() {}
270 // template <class T> typename T::B foo() {}
271 // \endcode
272 Out << '#';
273 VisitType(D->getReturnType());
274 }
275 Out << '#';
276 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
277 if (MD->isStatic())
278 Out << 'S';
279 // FIXME: OpenCL: Need to consider address spaces
280 if (unsigned quals = MD->getMethodQualifiers().getCVRUQualifiers())
281 Out << (char)('0' + quals);
282 switch (MD->getRefQualifier()) {
283 case RQ_None: break;
284 case RQ_LValue: Out << '&'; break;
285 case RQ_RValue: Out << "&&"; break;
286 }
287 }
288 }
289
VisitNamedDecl(const NamedDecl * D)290 void USRGenerator::VisitNamedDecl(const NamedDecl *D) {
291 VisitDeclContext(D->getDeclContext());
292 Out << "@";
293
294 if (EmitDeclName(D)) {
295 // The string can be empty if the declaration has no name; e.g., it is
296 // the ParmDecl with no name for declaration of a function pointer type,
297 // e.g.: void (*f)(void *);
298 // In this case, don't generate a USR.
299 IgnoreResults = true;
300 }
301 }
302
VisitVarDecl(const VarDecl * D)303 void USRGenerator::VisitVarDecl(const VarDecl *D) {
304 // VarDecls can be declared 'extern' within a function or method body,
305 // but their enclosing DeclContext is the function, not the TU. We need
306 // to check the storage class to correctly generate the USR.
307 if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
308 return;
309
310 VisitDeclContext(D->getDeclContext());
311
312 if (VarTemplateDecl *VarTmpl = D->getDescribedVarTemplate()) {
313 Out << "@VT";
314 VisitTemplateParameterList(VarTmpl->getTemplateParameters());
315 } else if (const VarTemplatePartialSpecializationDecl *PartialSpec
316 = dyn_cast<VarTemplatePartialSpecializationDecl>(D)) {
317 Out << "@VP";
318 VisitTemplateParameterList(PartialSpec->getTemplateParameters());
319 }
320
321 // Variables always have simple names.
322 StringRef s = D->getName();
323
324 // The string can be empty if the declaration has no name; e.g., it is
325 // the ParmDecl with no name for declaration of a function pointer type, e.g.:
326 // void (*f)(void *);
327 // In this case, don't generate a USR.
328 if (s.empty())
329 IgnoreResults = true;
330 else
331 Out << '@' << s;
332
333 // For a template specialization, mangle the template arguments.
334 if (const VarTemplateSpecializationDecl *Spec
335 = dyn_cast<VarTemplateSpecializationDecl>(D)) {
336 const TemplateArgumentList &Args = Spec->getTemplateArgs();
337 Out << '>';
338 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
339 Out << '#';
340 VisitTemplateArgument(Args.get(I));
341 }
342 }
343 }
344
VisitBindingDecl(const BindingDecl * D)345 void USRGenerator::VisitBindingDecl(const BindingDecl *D) {
346 if (isLocal(D) && GenLoc(D, /*IncludeOffset=*/true))
347 return;
348 VisitNamedDecl(D);
349 }
350
VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl * D)351 void USRGenerator::VisitNonTypeTemplateParmDecl(
352 const NonTypeTemplateParmDecl *D) {
353 GenLoc(D, /*IncludeOffset=*/true);
354 }
355
VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl * D)356 void USRGenerator::VisitTemplateTemplateParmDecl(
357 const TemplateTemplateParmDecl *D) {
358 GenLoc(D, /*IncludeOffset=*/true);
359 }
360
VisitNamespaceDecl(const NamespaceDecl * D)361 void USRGenerator::VisitNamespaceDecl(const NamespaceDecl *D) {
362 if (D->isAnonymousNamespace()) {
363 Out << "@aN";
364 return;
365 }
366
367 VisitDeclContext(D->getDeclContext());
368 if (!IgnoreResults)
369 Out << "@N@" << D->getName();
370 }
371
VisitFunctionTemplateDecl(const FunctionTemplateDecl * D)372 void USRGenerator::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
373 VisitFunctionDecl(D->getTemplatedDecl());
374 }
375
VisitClassTemplateDecl(const ClassTemplateDecl * D)376 void USRGenerator::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
377 VisitTagDecl(D->getTemplatedDecl());
378 }
379
VisitNamespaceAliasDecl(const NamespaceAliasDecl * D)380 void USRGenerator::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
381 VisitDeclContext(D->getDeclContext());
382 if (!IgnoreResults)
383 Out << "@NA@" << D->getName();
384 }
385
getCategoryContext(const NamedDecl * D)386 static const ObjCCategoryDecl *getCategoryContext(const NamedDecl *D) {
387 if (auto *CD = dyn_cast<ObjCCategoryDecl>(D->getDeclContext()))
388 return CD;
389 if (auto *ICD = dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext()))
390 return ICD->getCategoryDecl();
391 return nullptr;
392 }
393
VisitObjCMethodDecl(const ObjCMethodDecl * D)394 void USRGenerator::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
395 const DeclContext *container = D->getDeclContext();
396 if (const ObjCProtocolDecl *pd = dyn_cast<ObjCProtocolDecl>(container)) {
397 Visit(pd);
398 }
399 else {
400 // The USR for a method declared in a class extension or category is based on
401 // the ObjCInterfaceDecl, not the ObjCCategoryDecl.
402 const ObjCInterfaceDecl *ID = D->getClassInterface();
403 if (!ID) {
404 IgnoreResults = true;
405 return;
406 }
407 auto *CD = getCategoryContext(D);
408 VisitObjCContainerDecl(ID, CD);
409 }
410 // Ideally we would use 'GenObjCMethod', but this is such a hot path
411 // for Objective-C code that we don't want to use
412 // DeclarationName::getAsString().
413 Out << (D->isInstanceMethod() ? "(im)" : "(cm)")
414 << DeclarationName(D->getSelector());
415 }
416
VisitObjCContainerDecl(const ObjCContainerDecl * D,const ObjCCategoryDecl * CatD)417 void USRGenerator::VisitObjCContainerDecl(const ObjCContainerDecl *D,
418 const ObjCCategoryDecl *CatD) {
419 switch (D->getKind()) {
420 default:
421 llvm_unreachable("Invalid ObjC container.");
422 case Decl::ObjCInterface:
423 case Decl::ObjCImplementation:
424 GenObjCClass(D->getName(), GetExternalSourceContainer(D),
425 GetExternalSourceContainer(CatD));
426 break;
427 case Decl::ObjCCategory: {
428 const ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(D);
429 const ObjCInterfaceDecl *ID = CD->getClassInterface();
430 if (!ID) {
431 // Handle invalid code where the @interface might not
432 // have been specified.
433 // FIXME: We should be able to generate this USR even if the
434 // @interface isn't available.
435 IgnoreResults = true;
436 return;
437 }
438 // Specially handle class extensions, which are anonymous categories.
439 // We want to mangle in the location to uniquely distinguish them.
440 if (CD->IsClassExtension()) {
441 Out << "objc(ext)" << ID->getName() << '@';
442 GenLoc(CD, /*IncludeOffset=*/true);
443 }
444 else
445 GenObjCCategory(ID->getName(), CD->getName(),
446 GetExternalSourceContainer(ID),
447 GetExternalSourceContainer(CD));
448
449 break;
450 }
451 case Decl::ObjCCategoryImpl: {
452 const ObjCCategoryImplDecl *CD = cast<ObjCCategoryImplDecl>(D);
453 const ObjCInterfaceDecl *ID = CD->getClassInterface();
454 if (!ID) {
455 // Handle invalid code where the @interface might not
456 // have been specified.
457 // FIXME: We should be able to generate this USR even if the
458 // @interface isn't available.
459 IgnoreResults = true;
460 return;
461 }
462 GenObjCCategory(ID->getName(), CD->getName(),
463 GetExternalSourceContainer(ID),
464 GetExternalSourceContainer(CD));
465 break;
466 }
467 case Decl::ObjCProtocol: {
468 const ObjCProtocolDecl *PD = cast<ObjCProtocolDecl>(D);
469 GenObjCProtocol(PD->getName(), GetExternalSourceContainer(PD));
470 break;
471 }
472 }
473 }
474
VisitObjCPropertyDecl(const ObjCPropertyDecl * D)475 void USRGenerator::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
476 // The USR for a property declared in a class extension or category is based
477 // on the ObjCInterfaceDecl, not the ObjCCategoryDecl.
478 if (const ObjCInterfaceDecl *ID = Context->getObjContainingInterface(D))
479 VisitObjCContainerDecl(ID, getCategoryContext(D));
480 else
481 Visit(cast<Decl>(D->getDeclContext()));
482 GenObjCProperty(D->getName(), D->isClassProperty());
483 }
484
VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl * D)485 void USRGenerator::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
486 if (ObjCPropertyDecl *PD = D->getPropertyDecl()) {
487 VisitObjCPropertyDecl(PD);
488 return;
489 }
490
491 IgnoreResults = true;
492 }
493
VisitTagDecl(const TagDecl * D)494 void USRGenerator::VisitTagDecl(const TagDecl *D) {
495 // Add the location of the tag decl to handle resolution across
496 // translation units.
497 if (!isa<EnumDecl>(D) &&
498 ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
499 return;
500
501 GenExtSymbolContainer(D);
502
503 D = D->getCanonicalDecl();
504 VisitDeclContext(D->getDeclContext());
505
506 bool AlreadyStarted = false;
507 if (const CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(D)) {
508 if (ClassTemplateDecl *ClassTmpl = CXXRecord->getDescribedClassTemplate()) {
509 AlreadyStarted = true;
510
511 switch (D->getTagKind()) {
512 case TTK_Interface:
513 case TTK_Class:
514 case TTK_Struct: Out << "@ST"; break;
515 case TTK_Union: Out << "@UT"; break;
516 case TTK_Enum: llvm_unreachable("enum template");
517 }
518 VisitTemplateParameterList(ClassTmpl->getTemplateParameters());
519 } else if (const ClassTemplatePartialSpecializationDecl *PartialSpec
520 = dyn_cast<ClassTemplatePartialSpecializationDecl>(CXXRecord)) {
521 AlreadyStarted = true;
522
523 switch (D->getTagKind()) {
524 case TTK_Interface:
525 case TTK_Class:
526 case TTK_Struct: Out << "@SP"; break;
527 case TTK_Union: Out << "@UP"; break;
528 case TTK_Enum: llvm_unreachable("enum partial specialization");
529 }
530 VisitTemplateParameterList(PartialSpec->getTemplateParameters());
531 }
532 }
533
534 if (!AlreadyStarted) {
535 switch (D->getTagKind()) {
536 case TTK_Interface:
537 case TTK_Class:
538 case TTK_Struct: Out << "@S"; break;
539 case TTK_Union: Out << "@U"; break;
540 case TTK_Enum: Out << "@E"; break;
541 }
542 }
543
544 Out << '@';
545 assert(Buf.size() > 0);
546 const unsigned off = Buf.size() - 1;
547
548 if (EmitDeclName(D)) {
549 if (const TypedefNameDecl *TD = D->getTypedefNameForAnonDecl()) {
550 Buf[off] = 'A';
551 Out << '@' << *TD;
552 }
553 else {
554 if (D->isEmbeddedInDeclarator() && !D->isFreeStanding()) {
555 printLoc(Out, D->getLocation(), Context->getSourceManager(), true);
556 } else {
557 Buf[off] = 'a';
558 if (auto *ED = dyn_cast<EnumDecl>(D)) {
559 // Distinguish USRs of anonymous enums by using their first enumerator.
560 auto enum_range = ED->enumerators();
561 if (enum_range.begin() != enum_range.end()) {
562 Out << '@' << **enum_range.begin();
563 }
564 }
565 }
566 }
567 }
568
569 // For a class template specialization, mangle the template arguments.
570 if (const ClassTemplateSpecializationDecl *Spec
571 = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
572 const TemplateArgumentList &Args = Spec->getTemplateArgs();
573 Out << '>';
574 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
575 Out << '#';
576 VisitTemplateArgument(Args.get(I));
577 }
578 }
579 }
580
VisitTypedefDecl(const TypedefDecl * D)581 void USRGenerator::VisitTypedefDecl(const TypedefDecl *D) {
582 if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
583 return;
584 const DeclContext *DC = D->getDeclContext();
585 if (const NamedDecl *DCN = dyn_cast<NamedDecl>(DC))
586 Visit(DCN);
587 Out << "@T@";
588 Out << D->getName();
589 }
590
VisitTemplateTypeParmDecl(const TemplateTypeParmDecl * D)591 void USRGenerator::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
592 GenLoc(D, /*IncludeOffset=*/true);
593 }
594
GenExtSymbolContainer(const NamedDecl * D)595 void USRGenerator::GenExtSymbolContainer(const NamedDecl *D) {
596 StringRef Container = GetExternalSourceContainer(D);
597 if (!Container.empty())
598 Out << "@M@" << Container;
599 }
600
GenLoc(const Decl * D,bool IncludeOffset)601 bool USRGenerator::GenLoc(const Decl *D, bool IncludeOffset) {
602 if (generatedLoc)
603 return IgnoreResults;
604 generatedLoc = true;
605
606 // Guard against null declarations in invalid code.
607 if (!D) {
608 IgnoreResults = true;
609 return true;
610 }
611
612 // Use the location of canonical decl.
613 D = D->getCanonicalDecl();
614
615 IgnoreResults =
616 IgnoreResults || printLoc(Out, D->getBeginLoc(),
617 Context->getSourceManager(), IncludeOffset);
618
619 return IgnoreResults;
620 }
621
printQualifier(llvm::raw_ostream & Out,ASTContext & Ctx,NestedNameSpecifier * NNS)622 static void printQualifier(llvm::raw_ostream &Out, ASTContext &Ctx, NestedNameSpecifier *NNS) {
623 // FIXME: Encode the qualifier, don't just print it.
624 PrintingPolicy PO(Ctx.getLangOpts());
625 PO.SuppressTagKeyword = true;
626 PO.SuppressUnwrittenScope = true;
627 PO.ConstantArraySizeAsWritten = false;
628 PO.AnonymousTagLocations = false;
629 NNS->print(Out, PO);
630 }
631
VisitType(QualType T)632 void USRGenerator::VisitType(QualType T) {
633 // This method mangles in USR information for types. It can possibly
634 // just reuse the naming-mangling logic used by codegen, although the
635 // requirements for USRs might not be the same.
636 ASTContext &Ctx = *Context;
637
638 do {
639 T = Ctx.getCanonicalType(T);
640 Qualifiers Q = T.getQualifiers();
641 unsigned qVal = 0;
642 if (Q.hasConst())
643 qVal |= 0x1;
644 if (Q.hasVolatile())
645 qVal |= 0x2;
646 if (Q.hasRestrict())
647 qVal |= 0x4;
648 if(qVal)
649 Out << ((char) ('0' + qVal));
650
651 // Mangle in ObjC GC qualifiers?
652
653 if (const PackExpansionType *Expansion = T->getAs<PackExpansionType>()) {
654 Out << 'P';
655 T = Expansion->getPattern();
656 }
657
658 if (const BuiltinType *BT = T->getAs<BuiltinType>()) {
659 unsigned char c = '\0';
660 switch (BT->getKind()) {
661 case BuiltinType::Void:
662 c = 'v'; break;
663 case BuiltinType::Bool:
664 c = 'b'; break;
665 case BuiltinType::UChar:
666 c = 'c'; break;
667 case BuiltinType::Char8:
668 c = 'u'; break; // FIXME: Check this doesn't collide
669 case BuiltinType::Char16:
670 c = 'q'; break;
671 case BuiltinType::Char32:
672 c = 'w'; break;
673 case BuiltinType::UShort:
674 c = 's'; break;
675 case BuiltinType::UInt:
676 c = 'i'; break;
677 case BuiltinType::ULong:
678 c = 'l'; break;
679 case BuiltinType::ULongLong:
680 c = 'k'; break;
681 case BuiltinType::UInt128:
682 c = 'j'; break;
683 case BuiltinType::Char_U:
684 case BuiltinType::Char_S:
685 c = 'C'; break;
686 case BuiltinType::SChar:
687 c = 'r'; break;
688 case BuiltinType::WChar_S:
689 case BuiltinType::WChar_U:
690 c = 'W'; break;
691 case BuiltinType::Short:
692 c = 'S'; break;
693 case BuiltinType::Int:
694 c = 'I'; break;
695 case BuiltinType::Long:
696 c = 'L'; break;
697 case BuiltinType::LongLong:
698 c = 'K'; break;
699 case BuiltinType::Int128:
700 c = 'J'; break;
701 case BuiltinType::Float16:
702 case BuiltinType::Half:
703 c = 'h'; break;
704 case BuiltinType::Float:
705 c = 'f'; break;
706 case BuiltinType::Double:
707 c = 'd'; break;
708 case BuiltinType::LongDouble:
709 c = 'D'; break;
710 case BuiltinType::Float128:
711 c = 'Q'; break;
712 case BuiltinType::NullPtr:
713 c = 'n'; break;
714 #define BUILTIN_TYPE(Id, SingletonId)
715 #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
716 #include "clang/AST/BuiltinTypes.def"
717 case BuiltinType::Dependent:
718 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
719 case BuiltinType::Id:
720 #include "clang/Basic/OpenCLImageTypes.def"
721 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
722 case BuiltinType::Id:
723 #include "clang/Basic/OpenCLExtensionTypes.def"
724 case BuiltinType::OCLEvent:
725 case BuiltinType::OCLClkEvent:
726 case BuiltinType::OCLQueue:
727 case BuiltinType::OCLReserveID:
728 case BuiltinType::OCLSampler:
729 #define SVE_TYPE(Name, Id, SingletonId) \
730 case BuiltinType::Id:
731 #include "clang/Basic/AArch64SVEACLETypes.def"
732 #define PPC_VECTOR_TYPE(Name, Id, Size) \
733 case BuiltinType::Id:
734 #include "clang/Basic/PPCTypes.def"
735 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
736 #include "clang/Basic/RISCVVTypes.def"
737 case BuiltinType::ShortAccum:
738 case BuiltinType::Accum:
739 case BuiltinType::LongAccum:
740 case BuiltinType::UShortAccum:
741 case BuiltinType::UAccum:
742 case BuiltinType::ULongAccum:
743 case BuiltinType::ShortFract:
744 case BuiltinType::Fract:
745 case BuiltinType::LongFract:
746 case BuiltinType::UShortFract:
747 case BuiltinType::UFract:
748 case BuiltinType::ULongFract:
749 case BuiltinType::SatShortAccum:
750 case BuiltinType::SatAccum:
751 case BuiltinType::SatLongAccum:
752 case BuiltinType::SatUShortAccum:
753 case BuiltinType::SatUAccum:
754 case BuiltinType::SatULongAccum:
755 case BuiltinType::SatShortFract:
756 case BuiltinType::SatFract:
757 case BuiltinType::SatLongFract:
758 case BuiltinType::SatUShortFract:
759 case BuiltinType::SatUFract:
760 case BuiltinType::SatULongFract:
761 case BuiltinType::BFloat16:
762 IgnoreResults = true;
763 return;
764 case BuiltinType::ObjCId:
765 c = 'o'; break;
766 case BuiltinType::ObjCClass:
767 c = 'O'; break;
768 case BuiltinType::ObjCSel:
769 c = 'e'; break;
770 }
771 Out << c;
772 return;
773 }
774
775 // If we have already seen this (non-built-in) type, use a substitution
776 // encoding.
777 llvm::DenseMap<const Type *, unsigned>::iterator Substitution
778 = TypeSubstitutions.find(T.getTypePtr());
779 if (Substitution != TypeSubstitutions.end()) {
780 Out << 'S' << Substitution->second << '_';
781 return;
782 } else {
783 // Record this as a substitution.
784 unsigned Number = TypeSubstitutions.size();
785 TypeSubstitutions[T.getTypePtr()] = Number;
786 }
787
788 if (const PointerType *PT = T->getAs<PointerType>()) {
789 Out << '*';
790 T = PT->getPointeeType();
791 continue;
792 }
793 if (const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>()) {
794 Out << '*';
795 T = OPT->getPointeeType();
796 continue;
797 }
798 if (const RValueReferenceType *RT = T->getAs<RValueReferenceType>()) {
799 Out << "&&";
800 T = RT->getPointeeType();
801 continue;
802 }
803 if (const ReferenceType *RT = T->getAs<ReferenceType>()) {
804 Out << '&';
805 T = RT->getPointeeType();
806 continue;
807 }
808 if (const FunctionProtoType *FT = T->getAs<FunctionProtoType>()) {
809 Out << 'F';
810 VisitType(FT->getReturnType());
811 Out << '(';
812 for (const auto &I : FT->param_types()) {
813 Out << '#';
814 VisitType(I);
815 }
816 Out << ')';
817 if (FT->isVariadic())
818 Out << '.';
819 return;
820 }
821 if (const BlockPointerType *BT = T->getAs<BlockPointerType>()) {
822 Out << 'B';
823 T = BT->getPointeeType();
824 continue;
825 }
826 if (const ComplexType *CT = T->getAs<ComplexType>()) {
827 Out << '<';
828 T = CT->getElementType();
829 continue;
830 }
831 if (const TagType *TT = T->getAs<TagType>()) {
832 Out << '$';
833 VisitTagDecl(TT->getDecl());
834 return;
835 }
836 if (const ObjCInterfaceType *OIT = T->getAs<ObjCInterfaceType>()) {
837 Out << '$';
838 VisitObjCInterfaceDecl(OIT->getDecl());
839 return;
840 }
841 if (const ObjCObjectType *OIT = T->getAs<ObjCObjectType>()) {
842 Out << 'Q';
843 VisitType(OIT->getBaseType());
844 for (auto *Prot : OIT->getProtocols())
845 VisitObjCProtocolDecl(Prot);
846 return;
847 }
848 if (const TemplateTypeParmType *TTP = T->getAs<TemplateTypeParmType>()) {
849 Out << 't' << TTP->getDepth() << '.' << TTP->getIndex();
850 return;
851 }
852 if (const TemplateSpecializationType *Spec
853 = T->getAs<TemplateSpecializationType>()) {
854 Out << '>';
855 VisitTemplateName(Spec->getTemplateName());
856 Out << Spec->getNumArgs();
857 for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
858 VisitTemplateArgument(Spec->getArg(I));
859 return;
860 }
861 if (const DependentNameType *DNT = T->getAs<DependentNameType>()) {
862 Out << '^';
863 printQualifier(Out, Ctx, DNT->getQualifier());
864 Out << ':' << DNT->getIdentifier()->getName();
865 return;
866 }
867 if (const InjectedClassNameType *InjT = T->getAs<InjectedClassNameType>()) {
868 T = InjT->getInjectedSpecializationType();
869 continue;
870 }
871 if (const auto *VT = T->getAs<VectorType>()) {
872 Out << (T->isExtVectorType() ? ']' : '[');
873 Out << VT->getNumElements();
874 T = VT->getElementType();
875 continue;
876 }
877 if (const auto *const AT = dyn_cast<ArrayType>(T)) {
878 Out << '{';
879 switch (AT->getSizeModifier()) {
880 case ArrayType::Static:
881 Out << 's';
882 break;
883 case ArrayType::Star:
884 Out << '*';
885 break;
886 case ArrayType::Normal:
887 Out << 'n';
888 break;
889 }
890 if (const auto *const CAT = dyn_cast<ConstantArrayType>(T))
891 Out << CAT->getSize();
892
893 T = AT->getElementType();
894 continue;
895 }
896
897 // Unhandled type.
898 Out << ' ';
899 break;
900 } while (true);
901 }
902
VisitTemplateParameterList(const TemplateParameterList * Params)903 void USRGenerator::VisitTemplateParameterList(
904 const TemplateParameterList *Params) {
905 if (!Params)
906 return;
907 Out << '>' << Params->size();
908 for (TemplateParameterList::const_iterator P = Params->begin(),
909 PEnd = Params->end();
910 P != PEnd; ++P) {
911 Out << '#';
912 if (isa<TemplateTypeParmDecl>(*P)) {
913 if (cast<TemplateTypeParmDecl>(*P)->isParameterPack())
914 Out<< 'p';
915 Out << 'T';
916 continue;
917 }
918
919 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
920 if (NTTP->isParameterPack())
921 Out << 'p';
922 Out << 'N';
923 VisitType(NTTP->getType());
924 continue;
925 }
926
927 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
928 if (TTP->isParameterPack())
929 Out << 'p';
930 Out << 't';
931 VisitTemplateParameterList(TTP->getTemplateParameters());
932 }
933 }
934
VisitTemplateName(TemplateName Name)935 void USRGenerator::VisitTemplateName(TemplateName Name) {
936 if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
937 if (TemplateTemplateParmDecl *TTP
938 = dyn_cast<TemplateTemplateParmDecl>(Template)) {
939 Out << 't' << TTP->getDepth() << '.' << TTP->getIndex();
940 return;
941 }
942
943 Visit(Template);
944 return;
945 }
946
947 // FIXME: Visit dependent template names.
948 }
949
VisitTemplateArgument(const TemplateArgument & Arg)950 void USRGenerator::VisitTemplateArgument(const TemplateArgument &Arg) {
951 switch (Arg.getKind()) {
952 case TemplateArgument::Null:
953 break;
954
955 case TemplateArgument::Declaration:
956 Visit(Arg.getAsDecl());
957 break;
958
959 case TemplateArgument::NullPtr:
960 break;
961
962 case TemplateArgument::TemplateExpansion:
963 Out << 'P'; // pack expansion of...
964 LLVM_FALLTHROUGH;
965 case TemplateArgument::Template:
966 VisitTemplateName(Arg.getAsTemplateOrTemplatePattern());
967 break;
968
969 case TemplateArgument::Expression:
970 // FIXME: Visit expressions.
971 break;
972
973 case TemplateArgument::Pack:
974 Out << 'p' << Arg.pack_size();
975 for (const auto &P : Arg.pack_elements())
976 VisitTemplateArgument(P);
977 break;
978
979 case TemplateArgument::Type:
980 VisitType(Arg.getAsType());
981 break;
982
983 case TemplateArgument::Integral:
984 Out << 'V';
985 VisitType(Arg.getIntegralType());
986 Out << Arg.getAsIntegral();
987 break;
988 }
989 }
990
VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl * D)991 void USRGenerator::VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D) {
992 if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
993 return;
994 VisitDeclContext(D->getDeclContext());
995 Out << "@UUV@";
996 printQualifier(Out, D->getASTContext(), D->getQualifier());
997 EmitDeclName(D);
998 }
999
VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl * D)1000 void USRGenerator::VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D) {
1001 if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
1002 return;
1003 VisitDeclContext(D->getDeclContext());
1004 Out << "@UUT@";
1005 printQualifier(Out, D->getASTContext(), D->getQualifier());
1006 Out << D->getName(); // Simple name.
1007 }
1008
1009
1010
1011 //===----------------------------------------------------------------------===//
1012 // USR generation functions.
1013 //===----------------------------------------------------------------------===//
1014
combineClassAndCategoryExtContainers(StringRef ClsSymDefinedIn,StringRef CatSymDefinedIn,raw_ostream & OS)1015 static void combineClassAndCategoryExtContainers(StringRef ClsSymDefinedIn,
1016 StringRef CatSymDefinedIn,
1017 raw_ostream &OS) {
1018 if (ClsSymDefinedIn.empty() && CatSymDefinedIn.empty())
1019 return;
1020 if (CatSymDefinedIn.empty()) {
1021 OS << "@M@" << ClsSymDefinedIn << '@';
1022 return;
1023 }
1024 OS << "@CM@" << CatSymDefinedIn << '@';
1025 if (ClsSymDefinedIn != CatSymDefinedIn) {
1026 OS << ClsSymDefinedIn << '@';
1027 }
1028 }
1029
generateUSRForObjCClass(StringRef Cls,raw_ostream & OS,StringRef ExtSymDefinedIn,StringRef CategoryContextExtSymbolDefinedIn)1030 void clang::index::generateUSRForObjCClass(StringRef Cls, raw_ostream &OS,
1031 StringRef ExtSymDefinedIn,
1032 StringRef CategoryContextExtSymbolDefinedIn) {
1033 combineClassAndCategoryExtContainers(ExtSymDefinedIn,
1034 CategoryContextExtSymbolDefinedIn, OS);
1035 OS << "objc(cs)" << Cls;
1036 }
1037
generateUSRForObjCCategory(StringRef Cls,StringRef Cat,raw_ostream & OS,StringRef ClsSymDefinedIn,StringRef CatSymDefinedIn)1038 void clang::index::generateUSRForObjCCategory(StringRef Cls, StringRef Cat,
1039 raw_ostream &OS,
1040 StringRef ClsSymDefinedIn,
1041 StringRef CatSymDefinedIn) {
1042 combineClassAndCategoryExtContainers(ClsSymDefinedIn, CatSymDefinedIn, OS);
1043 OS << "objc(cy)" << Cls << '@' << Cat;
1044 }
1045
generateUSRForObjCIvar(StringRef Ivar,raw_ostream & OS)1046 void clang::index::generateUSRForObjCIvar(StringRef Ivar, raw_ostream &OS) {
1047 OS << '@' << Ivar;
1048 }
1049
generateUSRForObjCMethod(StringRef Sel,bool IsInstanceMethod,raw_ostream & OS)1050 void clang::index::generateUSRForObjCMethod(StringRef Sel,
1051 bool IsInstanceMethod,
1052 raw_ostream &OS) {
1053 OS << (IsInstanceMethod ? "(im)" : "(cm)") << Sel;
1054 }
1055
generateUSRForObjCProperty(StringRef Prop,bool isClassProp,raw_ostream & OS)1056 void clang::index::generateUSRForObjCProperty(StringRef Prop, bool isClassProp,
1057 raw_ostream &OS) {
1058 OS << (isClassProp ? "(cpy)" : "(py)") << Prop;
1059 }
1060
generateUSRForObjCProtocol(StringRef Prot,raw_ostream & OS,StringRef ExtSymDefinedIn)1061 void clang::index::generateUSRForObjCProtocol(StringRef Prot, raw_ostream &OS,
1062 StringRef ExtSymDefinedIn) {
1063 if (!ExtSymDefinedIn.empty())
1064 OS << "@M@" << ExtSymDefinedIn << '@';
1065 OS << "objc(pl)" << Prot;
1066 }
1067
generateUSRForGlobalEnum(StringRef EnumName,raw_ostream & OS,StringRef ExtSymDefinedIn)1068 void clang::index::generateUSRForGlobalEnum(StringRef EnumName, raw_ostream &OS,
1069 StringRef ExtSymDefinedIn) {
1070 if (!ExtSymDefinedIn.empty())
1071 OS << "@M@" << ExtSymDefinedIn;
1072 OS << "@E@" << EnumName;
1073 }
1074
generateUSRForEnumConstant(StringRef EnumConstantName,raw_ostream & OS)1075 void clang::index::generateUSRForEnumConstant(StringRef EnumConstantName,
1076 raw_ostream &OS) {
1077 OS << '@' << EnumConstantName;
1078 }
1079
generateUSRForDecl(const Decl * D,SmallVectorImpl<char> & Buf)1080 bool clang::index::generateUSRForDecl(const Decl *D,
1081 SmallVectorImpl<char> &Buf) {
1082 if (!D)
1083 return true;
1084 // We don't ignore decls with invalid source locations. Implicit decls, like
1085 // C++'s operator new function, can have invalid locations but it is fine to
1086 // create USRs that can identify them.
1087
1088 USRGenerator UG(&D->getASTContext(), Buf);
1089 UG.Visit(D);
1090 return UG.ignoreResults();
1091 }
1092
generateUSRForMacro(const MacroDefinitionRecord * MD,const SourceManager & SM,SmallVectorImpl<char> & Buf)1093 bool clang::index::generateUSRForMacro(const MacroDefinitionRecord *MD,
1094 const SourceManager &SM,
1095 SmallVectorImpl<char> &Buf) {
1096 if (!MD)
1097 return true;
1098 return generateUSRForMacro(MD->getName()->getName(), MD->getLocation(),
1099 SM, Buf);
1100
1101 }
1102
generateUSRForMacro(StringRef MacroName,SourceLocation Loc,const SourceManager & SM,SmallVectorImpl<char> & Buf)1103 bool clang::index::generateUSRForMacro(StringRef MacroName, SourceLocation Loc,
1104 const SourceManager &SM,
1105 SmallVectorImpl<char> &Buf) {
1106 if (MacroName.empty())
1107 return true;
1108
1109 llvm::raw_svector_ostream Out(Buf);
1110
1111 // Assume that system headers are sane. Don't put source location
1112 // information into the USR if the macro comes from a system header.
1113 bool ShouldGenerateLocation = Loc.isValid() && !SM.isInSystemHeader(Loc);
1114
1115 Out << getUSRSpacePrefix();
1116 if (ShouldGenerateLocation)
1117 printLoc(Out, Loc, SM, /*IncludeOffset=*/true);
1118 Out << "@macro@";
1119 Out << MacroName;
1120 return false;
1121 }
1122
generateUSRForType(QualType T,ASTContext & Ctx,SmallVectorImpl<char> & Buf)1123 bool clang::index::generateUSRForType(QualType T, ASTContext &Ctx,
1124 SmallVectorImpl<char> &Buf) {
1125 if (T.isNull())
1126 return true;
1127 T = T.getCanonicalType();
1128
1129 USRGenerator UG(&Ctx, Buf);
1130 UG.VisitType(T);
1131 return UG.ignoreResults();
1132 }
1133
generateFullUSRForModule(const Module * Mod,raw_ostream & OS)1134 bool clang::index::generateFullUSRForModule(const Module *Mod,
1135 raw_ostream &OS) {
1136 if (!Mod->Parent)
1137 return generateFullUSRForTopLevelModuleName(Mod->Name, OS);
1138 if (generateFullUSRForModule(Mod->Parent, OS))
1139 return true;
1140 return generateUSRFragmentForModule(Mod, OS);
1141 }
1142
generateFullUSRForTopLevelModuleName(StringRef ModName,raw_ostream & OS)1143 bool clang::index::generateFullUSRForTopLevelModuleName(StringRef ModName,
1144 raw_ostream &OS) {
1145 OS << getUSRSpacePrefix();
1146 return generateUSRFragmentForModuleName(ModName, OS);
1147 }
1148
generateUSRFragmentForModule(const Module * Mod,raw_ostream & OS)1149 bool clang::index::generateUSRFragmentForModule(const Module *Mod,
1150 raw_ostream &OS) {
1151 return generateUSRFragmentForModuleName(Mod->Name, OS);
1152 }
1153
generateUSRFragmentForModuleName(StringRef ModName,raw_ostream & OS)1154 bool clang::index::generateUSRFragmentForModuleName(StringRef ModName,
1155 raw_ostream &OS) {
1156 OS << "@M@" << ModName;
1157 return false;
1158 }
1159