clang-cl: Port cl.exe's C4659 to clang-cl

[rnk]

clang/lib/Sema/SemaDeclCXX.cpp

2283 ↗

(On Diff #208434)

This file seems untouched except for whitespace changes, let's revert them.

clang/test/Sema/pragma-section.c

57 ↗

(On Diff #208434)

I agree it probably shouldn't, I imagine mingw users will want to be able to use this kind of code pattern to interop between GCC and Clang:

__attribute__((section(".drective")))
const char LinkerFlags[] = "-export:foo -export:bar";

[thakis]

comments

[thakis]

Thanks!

clang/test/Sema/pragma-section.c

57 ↗

(On Diff #208434)

That's a nice argument, added as comment :)

[rnk]

lgtm

May I ask what inspired this? :)

[thakis]

In D64349#1574742, @rnk wrote:

lgtm

Thanks!

May I ask what inspired this? :)

I was looking through lld/COFF/Driver.cpp for something…ah, right, because D64156 touched it, and because I looked through all uses of getSpelling() for D64253, and noticed that LinkerDriver::parseDirectives() had an empty branch for OPT_natvis. I figured that was probably from before lld-link supported /natvis: and made a note to implement support for /natvis: in a .drectve (anticlimatic result of that sidequest was "link.exe doesn't allow /natvis in .drective", resulting in D64352), and I remembered #pragma data_seg(".drectve") before remembering #pragma comment(linker) and saw that cl.exe had this warning and I thought it was kind of useful.

cfe/trunk/include/clang/Basic/Attr.td

 def Section : InheritableAttr {
   let Spellings = [GCC<"section">, Declspec<"allocate">];
   let Args = [StringArgument<"Name">];
   let Subjects =
       SubjectList<[ Function, GlobalVar, ObjCMethod, ObjCProperty ], ErrorDiag>;
   let Documentation = [SectionDocs];
 }
 
+// This is used for `__declspec(code_seg("segname"))`, but not for
+// `#pragma code_seg("segname")`.
 def CodeSeg : InheritableAttr {
   let Spellings = [Declspec<"code_seg">];
   let Args = [StringArgument<"Name">];
   let Subjects = SubjectList<[Function, CXXRecord], ErrorDiag>;
   let Documentation = [CodeSegDocs];
 }
 
 def PragmaClangBSSSection : InheritableAttr {

cfe/trunk/include/clang/Basic/DiagnosticGroups.td

def GNU : DiagGroup<"gnu", [GNUAlignofExpression, GNUAnonymousStruct,
                             GNUUnionCast, GNUVariableSizedTypeNotAtEnd,
                             ZeroLengthArray, GNUZeroLineDirective,
                             GNUZeroVariadicMacroArguments]>;
 // A warning group for warnings about code that clang accepts but gcc doesn't.
 def GccCompat : DiagGroup<"gcc-compat">;
 
 // Warnings for Microsoft extensions.
 def MicrosoftCharize : DiagGroup<"microsoft-charize">;
+def MicrosoftDrectveSection : DiagGroup<"microsoft-drectve-section">;
 def MicrosoftInclude : DiagGroup<"microsoft-include">;
 def MicrosoftCppMacro : DiagGroup<"microsoft-cpp-macro">;
 def MicrosoftFixedEnum : DiagGroup<"microsoft-fixed-enum">;
 def MicrosoftSealed : DiagGroup<"microsoft-sealed">;
 def MicrosoftUnqualifiedFriend : DiagGroup<"microsoft-unqualified-friend">;
 def MicrosoftExceptionSpec : DiagGroup<"microsoft-exception-spec">;
 def MicrosoftUsingDecl : DiagGroup<"microsoft-using-decl">;
 def MicrosoftMutableReference : DiagGroup<"microsoft-mutable-reference">;

 def MicrosoftEndOfFile : DiagGroup<"microsoft-end-of-file">;
 def MicrosoftInaccessibleBase : DiagGroup<"microsoft-inaccessible-base">;
 // Aliases.
 def : DiagGroup<"msvc-include", [MicrosoftInclude]>;
                 // -Wmsvc-include = -Wmicrosoft-include
 
 // Warnings group for warnings about Microsoft extensions.
 def Microsoft : DiagGroup<"microsoft",
-    [MicrosoftCharize, MicrosoftInclude, MicrosoftCppMacro, MicrosoftFixedEnum,
-     MicrosoftSealed, MicrosoftUnqualifiedFriend, MicrosoftExceptionSpec,
-     MicrosoftUsingDecl, MicrosoftMutableReference, MicrosoftPureDefinition,
+    [MicrosoftCharize, MicrosoftDrectveSection, MicrosoftInclude,
+     MicrosoftCppMacro, MicrosoftFixedEnum, MicrosoftSealed,
+     MicrosoftUnqualifiedFriend, MicrosoftExceptionSpec, MicrosoftUsingDecl,
+     MicrosoftMutableReference, MicrosoftPureDefinition,
      MicrosoftUnionMemberReference, MicrosoftExplicitConstructorCall,
      MicrosoftEnumValue, MicrosoftDefaultArgRedefinition, MicrosoftTemplate,
      MicrosoftRedeclareStatic, MicrosoftEnumForwardReference, MicrosoftGoto,
      MicrosoftFlexibleArray, MicrosoftExtraQualification, MicrosoftCast,
      MicrosoftConstInit, MicrosoftVoidPseudoDtor, MicrosoftAnonTag,
      MicrosoftCommentPaste, MicrosoftEndOfFile,
      MicrosoftInconsistentDllImport]>;
 

cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td

def err_tls_var_aligned_over_maximum : Error<
   "alignment (%0) of thread-local variable %1 is greater than the maximum supported "
   "alignment (%2) for a thread-local variable on this target">;
 
 def err_only_annotate_after_access_spec : Error<
   "access specifier can only have annotation attributes">;
 
 def err_attribute_section_invalid_for_target : Error<
   "argument to %select{'code_seg'|'section'}1 attribute is not valid for this target: %0">;
+def warn_attribute_section_drectve : Warning<
+  "#pragma %0(\".drectve\") has undefined behavior, "
+  "use #pragma comment(linker, ...) instead">, InGroup<MicrosoftDrectveSection>;
 def warn_mismatched_section : Warning<
   "%select{codeseg|section}0 does not match previous declaration">, InGroup<Section>;
 def warn_attribute_section_on_redeclaration : Warning<
   "section attribute is specified on redeclared variable">, InGroup<Section>;
 def err_mismatched_code_seg_base : Error<
   "derived class must specify the same code segment as its base classes">;
 def err_mismatched_code_seg_override : Error<
   "overriding virtual function must specify the same code segment as its overridden function">;

cfe/trunk/lib/Sema/SemaAttr.cpp

PragmaStack<StringLiteral *> *Stack =
     llvm::StringSwitch<PragmaStack<StringLiteral *> *>(PragmaName)
         .Case("data_seg", &DataSegStack)
         .Case("bss_seg", &BSSSegStack)
         .Case("const_seg", &ConstSegStack)
         .Case("code_seg", &CodeSegStack);
   if (Action & PSK_Pop && Stack->Stack.empty())
     Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName
         << "stack empty";
-  if (SegmentName &&
-      !checkSectionName(SegmentName->getBeginLoc(), SegmentName->getString()))
+  if (SegmentName) {
+    if (!checkSectionName(SegmentName->getBeginLoc(), SegmentName->getString()))
       return;
+
+    if (SegmentName->getString() == ".drectve" &&
+        Context.getTargetInfo().getCXXABI().isMicrosoft())
+      Diag(PragmaLocation, diag::warn_attribute_section_drectve) << PragmaName;
+  }
+
   Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName);
 }
 
 /// Called on well formed \#pragma bss_seg().
 void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation,
                                 int SectionFlags, StringLiteral *SegmentName) {
   UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation);
 }

cfe/trunk/lib/Sema/SemaDeclAttr.cpp

static void handleSectionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   }
 
   unsigned Index = AL.getAttributeSpellingListIndex();
   SectionAttr *NewAttr = S.mergeSectionAttr(D, AL.getRange(), Str, Index);
   if (NewAttr)
     D->addAttr(NewAttr);
 }
 
-static bool checkCodeSegName(Sema&S, SourceLocation LiteralLoc, StringRef CodeSegName) {
-  std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(CodeSegName);
+// This is used for `__declspec(code_seg("segname"))` on a decl.
+// `#pragma code_seg("segname")` uses checkSectionName() instead.
+static bool checkCodeSegName(Sema &S, SourceLocation LiteralLoc,
+                             StringRef CodeSegName) {
+  std::string Error =
+      S.Context.getTargetInfo().isValidSectionSpecifier(CodeSegName);
   if (!Error.empty()) {
-    S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target) << Error
-           << 0 /*'code-seg'*/;
+    S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
+        << Error << 0 /*'code-seg'*/;
     return false;
   }
+
   return true;
 }
 
 CodeSegAttr *Sema::mergeCodeSegAttr(Decl *D, SourceRange Range,
                                     StringRef Name,
                                     unsigned AttrSpellingListIndex) {
   // Explicit or partial specializations do not inherit
   // the code_seg attribute from the primary template.

cfe/trunk/test/Sema/pragma-section.c

 #pragma section(".my_seg" // expected-warning {{missing ')' after '#pragma section' - ignoring}}
 #pragma section(".my_seg" 1  // expected-warning {{missing ')' after '#pragma section' - ignoring}}
 #pragma section(".my_seg",  // expected-warning {{expected action or ')' in '#pragma section' - ignored}}
 #pragma section(".my_seg", read) // expected-error {{this causes a section type conflict with a prior #pragma section}}
 #pragma section(".my_seg", bogus) // expected-warning {{unknown action 'bogus' for '#pragma section' - ignored}}
 #pragma section(".my_seg", nopage) // expected-warning {{known but unsupported action 'nopage' for '#pragma section' - ignored}}
 #pragma section(".my_seg", read, write) // expected-error {{this causes a section type conflict with a prior #pragma section}}
 #pragma section(".my_seg", read, write, 1) //  expected-warning {{expected action or ')' in '#pragma section' - ignored}}
+
+#pragma bss_seg(".drectve") // expected-warning{{#pragma bss_seg(".drectve") has undefined behavior, use #pragma comment(linker, ...) instead}}
+#pragma code_seg(".drectve") // expected-warning{{#pragma code_seg(".drectve") has undefined behavior, use #pragma comment(linker, ...) instead}} 
+#pragma const_seg(".drectve")  // expected-warning{{#pragma const_seg(".drectve") has undefined behavior, use #pragma comment(linker, ...) instead}}
+#pragma data_seg(".drectve")  // expected-warning{{#pragma data_seg(".drectve") has undefined behavior, use #pragma comment(linker, ...) instead}}
+#pragma code_seg(".my_seg")
+
+// cl.exe doesn't warn on this, so match that.
+// (Technically it ICEs on this particular example, but if it's on a class then
+// it just doesn't warn.)
+__declspec(code_seg(".drectve")) void drectve_fn(void) {}
+
+// This shouldn't warn; mingw users likely want to use
+//     __attribute__((section(".drective")))
+//     const char LinkerFlags[] = "-export:foo -export:bar";
+// for interop with gcc.
+__attribute__((section(".drectve"))) int drectve_int;