[ATTR] Automatic line feed after pragma-like attribute.

[ABataev]

Summary

Automatically insert line feed after pretty printing of all pragma-like attributes.

[aaron.ballman]

LGTM, thanks! If you would be so kind as to add a test for #pragma init_seg("bss"), that would be great -- it seems its printPrettyPragma never put a newline in there for that attribute, and so I would guess there's lacking test coverage that this change should fix.

~Aaron

[ABataev]

Ok, will do

Best regards,

Alexey Bataev

Software Engineer
Intel Compiler Team

08.10.2015 16:02, Aaron Ballman пишет:

aaron.ballman accepted this revision.
aaron.ballman added a comment.
This revision is now accepted and ready to land.

LGTM, thanks! If you would be so kind as to add a test for #pragma init_seg("bss"), that would be great -- it seems its printPrettyPragma never put a newline in there for that attribute, and so I would guess there's lacking test coverage that this change should fix.

~Aaron

http://reviews.llvm.org/D13546

[ABataev]

Printing of pragma-like attributes for declarations did not worked at all. Fixed it and added test for printing #pragma init_seg.

[aaron.ballman]

Wow, good catch on the fact that this didn't work at all! Thank you for tackling it.

lib/AST/DeclPrinter.cpp

197

Would it make more sense to add a prettyPrintPragmas(Decl *D) function instead?

test/SemaCXX/pragma-init_seg.cpp

1

I think this should be a new test under Misc\. We have ast-print-pragmas.cpp that looks like a good place for it to go.

[ABataev]

lib/AST/DeclPrinter.cpp

197

Ok, will do

test/SemaCXX/pragma-init_seg.cpp

1

Ok

[ABataev]

Update after review

[aaron.ballman]

Looks great, thank you!

~Aaron

include/clang/Basic/Attr.td

static const char *getOptionName(int Option) {
     }
     llvm_unreachable("Unhandled LoopHint option.");
   }
 
   void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
     unsigned SpellingIndex = getSpellingListIndex();
     // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
     // "nounroll" is already emitted as the pragma name.
-    if (SpellingIndex == Pragma_nounroll) {
-      OS << "\n";
+    if (SpellingIndex == Pragma_nounroll)
       return;
-    }
     else if (SpellingIndex == Pragma_unroll) {
-      OS << getValueString(Policy) << "\n";
+      OS << getValueString(Policy);
       return;
     }
 
     assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
-    OS << getOptionName(option) << getValueString(Policy) << "\n";
+    OS << getOptionName(option) << getValueString(Policy);
   }
 
   // Return a string containing the loop hint argument including the
   // enclosing parentheses.
   std::string getValueString(const PrintingPolicy &Policy) const {
     std::string ValueName;
     llvm::raw_string_ostream OS(ValueName);
     OS << "(";

lib/AST/DeclPrinter.cpp

public:
     void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
     void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
     void VisitUsingDecl(UsingDecl *D);
     void VisitUsingShadowDecl(UsingShadowDecl *D);
     void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
 
     void PrintTemplateParameters(const TemplateParameterList *Params,
                                  const TemplateArgumentList *Args = nullptr);
-    void prettyPrintAttributes(Decl *D);
+    void prettyPrintAttributes(Decl *D, bool PrintPragmas = false);
     void printDeclType(QualType T, StringRef DeclName, bool Pack = false);
   };
 }
 
 void Decl::print(raw_ostream &Out, unsigned Indentation,
                  bool PrintInstantiation) const {
   print(Out, getASTContext().getPrintingPolicy(), Indentation, PrintInstantiation);
 }

 }
 
 raw_ostream& DeclPrinter::Indent(unsigned Indentation) {
   for (unsigned i = 0; i != Indentation; ++i)
     Out << "  ";
   return Out;
 }
 
-void DeclPrinter::prettyPrintAttributes(Decl *D) {
+void DeclPrinter::prettyPrintAttributes(Decl *D, bool PrintPragmas) {
   if (Policy.PolishForDeclaration)
     return;
-  
   if (D->hasAttrs()) {
     AttrVec &Attrs = D->getAttrs();
-    for (AttrVec::const_iterator i=Attrs.begin(), e=Attrs.end(); i!=e; ++i) {
-      Attr *A = *i;
+    for (auto *A : Attrs) {
+      switch (A->getKind()) {
+#define ATTR(X)
+#define PRAGMA_SPELLING_ATTR(X) case attr::X:
+#include "clang/Basic/AttrList.inc"
+        if (PrintPragmas) {
           A->printPretty(Out, Policy);
+          Indent();
+        }
+        break;
+      default:
+        if (!PrintPragmas)
+          A->printPretty(Out, Policy);
+        break;
+      }
     }
   }
 }
 
 void DeclPrinter::printDeclType(QualType T, StringRef DeclName, bool Pack) {
   // Normally, a PackExpansionType is written as T[3]... (for instance, as a
   // template argument), but if it is the type of a declaration, the ellipsis
   // is placed before the name being declared.
void DeclPrinter::VisitEnumConstantDecl(EnumConstantDecl *D) {
   Out << *D;
   if (Expr *Init = D->getInitExpr()) {
     Out << " = ";
     Init->printPretty(Out, nullptr, Policy, Indentation);
   }
 }
 
 void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) {
+  if (!D->getDescribedFunctionTemplate() &&
+      !D->isFunctionTemplateSpecialization())
+    prettyPrintAttributes(D, /*PrintPragmas=*/true);
+
   CXXConstructorDecl *CDecl = dyn_cast<CXXConstructorDecl>(D);
   CXXConversionDecl *ConversionDecl = dyn_cast<CXXConversionDecl>(D);
   if (!Policy.SuppressSpecifiers) {
     switch (D->getStorageClass()) {
     case SC_None: break;
     case SC_Extern: Out << "extern "; break;
     case SC_Static: Out << "static "; break;
     case SC_PrivateExtern: Out << "__private_extern__ "; break;
void DeclPrinter::VisitFriendDecl(FriendDecl *D) {
   else if (ClassTemplateDecl *CTD =
            dyn_cast<ClassTemplateDecl>(D->getFriendDecl())) {
     Out << "friend ";
     VisitRedeclarableTemplateDecl(CTD);
   }
 }
 
 void DeclPrinter::VisitFieldDecl(FieldDecl *D) {
+  // FIXME: add printing of pragma attributes if required.
   if (!Policy.SuppressSpecifiers && D->isMutable())
     Out << "mutable ";
   if (!Policy.SuppressSpecifiers && D->isModulePrivate())
     Out << "__module_private__ ";
 
   Out << D->getASTContext().getUnqualifiedObjCPointerType(D->getType()).
             stream(Policy, D->getName());
 
void DeclPrinter::VisitFieldDecl(FieldDecl *D) {
   prettyPrintAttributes(D);
 }
 
 void DeclPrinter::VisitLabelDecl(LabelDecl *D) {
   Out << *D << ":";
 }
 
 void DeclPrinter::VisitVarDecl(VarDecl *D) {
+  prettyPrintAttributes(D, /*PrintPragmas=*/true);
   if (!Policy.SuppressSpecifiers) {
     StorageClass SC = D->getStorageClass();
     if (SC != SC_None)
       Out << VarDecl::getStorageClassSpecifierString(SC) << " ";
 
     switch (D->getTSCSpec()) {
     case TSCS_unspecified:
       break;
void DeclPrinter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
   Out << *D->getAliasedNamespace();
 }
 
 void DeclPrinter::VisitEmptyDecl(EmptyDecl *D) {
   prettyPrintAttributes(D);
 }
 
 void DeclPrinter::VisitCXXRecordDecl(CXXRecordDecl *D) {
+  // FIXME: add printing of pragma attributes if required.
   if (!Policy.SuppressSpecifiers && D->isModulePrivate())
     Out << "__module_private__ ";
   Out << D->getKindName();
 
   prettyPrintAttributes(D);
 
   if (D->getIdentifier())
     Out << ' ' << *D;
if (const TemplateTemplateParmDecl *TTP =
     Visit(D->getTemplatedDecl());
   }
 }
 
 void DeclPrinter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
   if (PrintInstantiation) {
     TemplateParameterList *Params = D->getTemplateParameters();
     for (auto *I : D->specializations()) {
+      prettyPrintAttributes(I, /*PrintPragmas=*/true);
       PrintTemplateParameters(Params, I->getTemplateSpecializationArgs());
       Visit(I);
     }
   }
 
+  prettyPrintAttributes(D->getTemplatedDecl(), /*PrintPragmas=*/true);
   return VisitRedeclarableTemplateDecl(D);
 }
 
 void DeclPrinter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
   if (PrintInstantiation) {
     TemplateParameterList *Params = D->getTemplateParameters();
     for (auto *I : D->specializations()) {
       PrintTemplateParameters(Params, &I->getTemplateArgs());

test/SemaCXX/pragma-init_seg.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -fms-extensions %s -triple x86_64-pc-win32
+// RUN: %clang_cc1 -fsyntax-only -verify -fms-extensions %s -triple x86_64-pc-win32 -ast-print | FileCheck %s
 // RUN: %clang_cc1 -fsyntax-only -verify -fms-extensions %s -triple i386-apple-darwin13.3.0
 
 #ifndef __APPLE__
 #pragma init_seg(L".my_seg") // expected-warning {{expected 'compiler', 'lib', 'user', or a string literal}}
 #pragma init_seg( // expected-warning {{expected 'compiler', 'lib', 'user', or a string literal}}
 #pragma init_seg asdf // expected-warning {{missing '('}}
 #pragma init_seg) // expected-warning {{missing '('}}
 #pragma init_seg("a" "b") // no warning
 #pragma init_seg("a", "b") // expected-warning {{missing ')'}}
 #pragma init_seg("a") asdf // expected-warning {{extra tokens at end of '#pragma init_seg'}}
 #pragma init_seg("\x") // expected-error {{\x used with no following hex digits}}
 #pragma init_seg("a" L"b") // expected-warning {{expected non-wide string literal in '#pragma init_seg'}}
 
 #pragma init_seg(compiler)
 #else
 #pragma init_seg(compiler) // expected-warning {{'#pragma init_seg' is only supported when targeting a Microsoft environment}}
 #endif
 
 int f();
+// CHECK: #pragma init_seg (.CRT$XCC)
+// CHECK-NEXT: int x = f() __declspec(thread);
 int __declspec(thread) x = f(); // expected-error {{initializer for thread-local variable must be a constant expression}}

utils/TableGen/ClangAttrEmitter.cpp

for (unsigned I = 0; I < Spellings.size(); ++ I) {
 
     OS <<
       "  case " << I << " : {\n"
       "    OS << \"" << Prefix << Spelling;
 
     if (Variety == "Pragma") {
       OS << " \";\n";
       OS << "    printPrettyPragma(OS, Policy);\n";
+      OS << "    OS << \"\\n\";";
       OS << "    break;\n";
       OS << "  }\n";
       continue;
     }
 
     // FIXME: always printing the parenthesis isn't the correct behavior for
     // attributes which have optional arguments that were not provided. For
     // instance: __attribute__((aligned)) will be pretty printed as