Add support for __declspec(code_seg("segname"))

[Manna]

Summary

Add support for __declspec(code_seg("segname"))

This patch is built on the existing support for #pragma code_seg. The code_seg declspec is allowed on functions and classes. The attribute enables the placement of code into separate named segments, including compiler-generated members and template instantiations.

For more information, please see the following:
https://msdn.microsoft.com/en-us/library/dn636922.aspx

A new CodeSeg attribute is used instead of adding a new spelling to the existing Section attribute since they don’t apply to the same Subjects. Section attributes are also added for the code_seg declspec since they are used for #pragma code_seg. No CodeSeg attributes are added to the AST.

The patch is written to match with the Microsoft compiler’s behavior even where that behavior is a little complicated (see https://reviews.llvm.org/D22931, the Microsoft feedback page is no longer available since MS has removed the page). That code is in getImplicitSectionAttrFromClass routine.

Diagnostics messages are added to match with the Microsoft compiler for code-seg attribute mismatches on base and derived classes and virtual overrides.

[rnk]

Thanks!

Can you add a test for special member functions? I wasn't able to find one, but maybe there is one already. I tried this and it looks like MSVC uses the class code_seg:

struct NonTrivialCopy {
  NonTrivialCopy();
  NonTrivialCopy(const NonTrivialCopy &);
  ~NonTrivialCopy();
  void *p;
};
struct __declspec(code_seg("asdf")) Foo {
  NonTrivialCopy f1;
};
Foo copy_foo(const Foo &f) {
  return f;
}

test/CodeGenCXX/code_seg3.cpp

4–6 ↗

(On Diff #134501)

There's some encoding confusion here, the em-dash seems to have been re-encoded as a smart quote.

[aaron.ballman]

include/clang/Basic/Attr.td

1775

Does code_seg work with structures in C as well, or is only used in C++? If it works in C, you should change CXXRecord to be Record and add some C test cases.

include/clang/Basic/DiagnosticSemaKinds.td

2672

I think this should be "derived class must specify the same code segment as its base classes"

I'd like to see test cases where multiple inheritance is involved and the code segments all agree, all disagree, and partially agree between the bases and the derived class. Also, does virtual inheritance change any of the rules?

2674

Similar here: "overriding virtual function must specify the same code segment as its overridden function"

I assume that *overloads* can be in different code segments? Should have test coverage for that.

include/clang/Sema/Sema.h

1937

The FunctionDecl * can be const.

5840

An extra space snuck in here.

lib/Sema/SemaDecl.cpp

2671

const auto *

8727

Please don't use auto here as the type is not explicitly spelled out in the initialization.

8730

SAttr will never be anything but SectionAttr, so you should use cast<> here instead.

9195

const FunctionDecl *

9196

const auto *.

9200

const auto *.

9201

Attr * instead of auto *.

9212

const auto *

9213

Attr *

9232

Spurious newline

lib/Sema/SemaDeclAttr.cpp

2858

const auto *

2952

Attr -> AL (or anything else that doesn't conflict with a type name).

2961–2964

I'd knock this down into a one-liner: S.Diag(Attr.getLoc(), ExistingAttr->getName() == Str ? diag::warn_ : diag::err_);

lib/Sema/SemaDeclCXX.cpp

2237–2238

const auto *

2243

You can just pass in CXXBaseDecl directly -- the diagnostics engine will handle properly quoting everything for you.

14560–14561

const auto *.

lib/Sema/SemaLambda.cpp

913

Don't use auto here.

[Manna]

New Lit tests are added and patches are updated based on Feedbacks.

[Manna]

There is a test (CodeGenCXX/code_seg1.cpp) for special member functions. I have updated code_seg1.cpp so the test has struct NonTrivialCopy. Could you let me know if it is sufficient?

In D43352#1009418, @rnk wrote:

Thanks!

Can you add a test for special member functions? I wasn't able to find one, but maybe there is one already. I tried this and it looks like MSVC uses the class code_seg:

struct NonTrivialCopy {
  NonTrivialCopy();
  NonTrivialCopy(const NonTrivialCopy &);
  ~NonTrivialCopy();
  void *p;
};
struct __declspec(code_seg("asdf")) Foo {
  NonTrivialCopy f1;
};
Foo copy_foo(const Foo &f) {
  return f;
}

[Manna]

include/clang/Basic/Attr.td

1775

__declspec(code_seg(...)) can only be applied to a class or a function.
Code_seg doesn't work with structures in C. We cannot define a function within a struct in C program.

include/clang/Basic/DiagnosticSemaKinds.td

2672

Lit test SemaCXX/code_seg1.cpp is added to show the test cases where multiple inheritance is involved and the code segments all agree, all disagree, and partially disagree between the bases and the derived.

Virtual inheritance doesn't change any rule. It follows the same rule. Lit test SemaCXX/code_seg1.cpp also shows the test cases where virtual inheritance is involved and the code segments all agree, all disagree, and partially disagree between the bases and the derived.

2674

Lit test CodeGenCXX/code_seg4.cpp is added for function overloading.

test/CodeGenCXX/code_seg3.cpp

4–6 ↗

(On Diff #134501)

The encoding is fixed.

[rnk]

Thanks, this is pretty exhaustive testing. I'll let @aaron.ballman finish off the review. He identified a fair number of style issues.

lib/Sema/SemaDeclAttr.cpp

2950–2972

Keep a blank line here.

[aaron.ballman]

lib/Sema/SemaDeclAttr.cpp

2951

Please do not name the last parameter Attr as that's the name of a type. Other places use AL.

2967

You should not pass in 0 as the last argument, but instead pass the result from a call to getAttributeSpellingListIndex().

lib/Sema/SemaDeclCXX.cpp

2242–2243

This formatting looks off to me, did clang-format produce it?

5598

Don't use auto here as the type's not spelled out.

14565

This return statement seems a bit strange to me -- shouldn't that be return true; after the second call to Diag()?

[Manna]

lib/Sema/SemaDeclCXX.cpp

2242–2243

Updated patch is submitted based on your comments.

I have fixed this format issue with the new uploaded patch.

Thanks.

[aaron.ballman]

Aside from a minor formatting nit, LGTM!

lib/Sema/SemaDeclAttr.cpp

2951

Add a preceding newline.

[Manna]

Thanks!

I have fixed the formatting issue with this uploaded patches.

[Manna]

lib/Sema/SemaDeclAttr.cpp

2951

Preceding newline is added.

[erichkeane]

Woops, forgot the tests when commiting, so see R332492 for the lit tests.

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];
 }
 
+def CodeSeg : InheritableAttr {
+  let Spellings = [Declspec<"code_seg">];
+  let Args = [StringArgument<"Name">];
+  let Subjects = SubjectList<[Function, CXXRecord], ErrorDiag>;
+  let Documentation = [CodeSegDocs];
+}
+
 def PragmaClangBSSSection : InheritableAttr {
   // This attribute has no spellings as it is only ever created implicitly.
   let Spellings = [];
   let Args = [StringArgument<"Name">];
   let Subjects = SubjectList<[GlobalVar], ErrorDiag>;
   let Documentation = [Undocumented];
 }
 

include/clang/Basic/AttrDocs.td

.. Note:: This attribute works differently in clang than it does in GCC.
   Specifically, clang will only trace ``const`` pointers (as above); we give up
   on pointers that are not marked as ``const``. In the vast majority of cases,
   this is unimportant, because LLVM has support for the ``alloc_size``
   attribute. However, this may cause mildly unintuitive behavior when used with
   other attributes, such as ``enable_if``.
   }];
 }
 
+def CodeSegDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+The ``__declspec(code_seg)`` attribute enables the placement of code into separate
+named segments that can be paged or locked in memory individually. This attribute
+is used to control the placement of instantiated templates and compiler-generated
+code. See the documentation for `__declspec(code_seg)`_ on MSDN.
+
+.. _`__declspec(code_seg)`: http://msdn.microsoft.com/en-us/library/dn636922.aspx
+  }];
+}
+
 def AllocAlignDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 Use ``__attribute__((alloc_align(<alignment>))`` on a function
 declaration to specify that the return value of the function (which must be a
 pointer type) is at least as aligned as the value of the indicated parameter. The
 parameter is given by its index in the list of formal parameters; the first
 parameter has index 1 unless the function is a C++ non-static member function,

include/clang/Basic/DiagnosticSemaKinds.td

 
 def err_attribute_section_invalid_for_target : Error<
   "argument to 'section' attribute is not valid for this target: %0">;
 def warn_mismatched_section : Warning<
   "section 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">;
+def err_conflicting_codeseg_attribute : Error<
+  "conflicting code segment specifiers">;
+def warn_duplicate_codeseg_attribute : Warning<
+  "duplicate code segment specifiers">, InGroup<Section>;
 def err_anonymous_property: Error<
   "anonymous property is not supported">;
 def err_property_is_variably_modified : Error<
   "property %0 has a variably modified type">;
 def err_no_accessor_for_property : Error<
   "no %select{getter|setter}0 defined for property %1">;
 def err_cannot_find_suitable_accessor : Error<
   "cannot find suitable %select{getter|setter}0 for property %1">;

include/clang/Sema/Sema.h

void NoteHiddenVirtualMethods(CXXMethodDecl *MD,
                           SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
   // Returns true if the function declaration is a redeclaration
   bool CheckFunctionDeclaration(Scope *S,
                                 FunctionDecl *NewFD, LookupResult &Previous,
                                 bool IsMemberSpecialization);
   bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl);
   void CheckMain(FunctionDecl *FD, const DeclSpec &D);
   void CheckMSVCRTEntryPoint(FunctionDecl *FD);
+  Attr *getImplicitSectionAttrForFunction(const FunctionDecl *FD, bool IsDefinition = true);
   Decl *ActOnParamDeclarator(Scope *S, Declarator &D);
   ParmVarDecl *BuildParmVarDeclForTypedef(DeclContext *DC,
                                           SourceLocation Loc,
                                           QualType T);
   ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,
                               SourceLocation NameLoc, IdentifierInfo *Name,
                               QualType T, TypeSourceInfo *TSInfo,
                               StorageClass SC);
void ActOnMemInitializers(Decl *ConstructorDecl,
                             SourceLocation ColonLoc,
                             ArrayRef<CXXCtorInitializer*> MemInits,
                             bool AnyErrors);
 
   /// Check class-level dllimport/dllexport attribute. The caller must
   /// ensure that referenceDLLExportedClassMethods is called some point later
   /// when all outer classes of Class are complete.
   void checkClassLevelDLLAttribute(CXXRecordDecl *Class);
+  void checkClassLevelSectionAttribute(CXXRecordDecl *Class);
 
   void referenceDLLExportedClassMethods();
 
   void propagateDLLAttrToBaseClassTemplate(
       CXXRecordDecl *Class, Attr *ClassAttr,
       ClassTemplateSpecializationDecl *BaseTemplateSpec,
       SourceLocation BaseLoc);
 

lib/Sema/SemaDecl.cpp

void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old,
 
   // This redeclaration adds a section attribute.
   if (New->hasAttr<SectionAttr>() && !Old->hasAttr<SectionAttr>()) {
     if (auto *VD = dyn_cast<VarDecl>(New)) {
       if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly) {
         Diag(New->getLocation(), diag::warn_attribute_section_on_redeclaration);
         Diag(Old->getLocation(), diag::note_previous_declaration);
       }
+    } else if (isa<CXXMethodDecl>(New)) {
+      const auto *NewSA = New->getAttr<SectionAttr>();
+      if (!NewSA->isImplicit()) {
+        Diag(New->getLocation(), diag::warn_mismatched_section);
+        Diag(Old->getLocation(), diag::note_previous_declaration);
+      }
     }
   }
-
   if (!Old->hasAttrs())
     return;
 
   bool foundAny = New->hasAttrs();
 
   // Ensure that any moving of objects within the allocated map is done before
   // we process them.
   if (!foundAny) New->setAttrs(AttrVec());
Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
   // Apply an implicit SectionAttr if '#pragma clang section text' is active
   if (PragmaClangTextSection.Valid && D.isFunctionDefinition() &&
       !NewFD->hasAttr<SectionAttr>()) {
     NewFD->addAttr(PragmaClangTextSectionAttr::CreateImplicit(Context,
                                                  PragmaClangTextSection.SectionName,
                                                  PragmaClangTextSection.PragmaLocation));
   }
 
-  // Apply an implicit SectionAttr if #pragma code_seg is active.
-  if (CodeSegStack.CurrentValue && D.isFunctionDefinition() &&
-      !NewFD->hasAttr<SectionAttr>()) {
-    NewFD->addAttr(
-        SectionAttr::CreateImplicit(Context, SectionAttr::Declspec_allocate,
-                                    CodeSegStack.CurrentValue->getString(),
-                                    CodeSegStack.CurrentPragmaLocation));
-    if (UnifySection(CodeSegStack.CurrentValue->getString(),
+  // Apply an implicit SectionAttr from class declspec or from
+  // #pragma code_seg if active.
+  if (!NewFD->hasAttr<SectionAttr>()) {
+    if (Attr *SAttr = getImplicitSectionAttrForFunction(NewFD,
+                                                        D.isFunctionDefinition())) {
+      NewFD->addAttr(SAttr);
+      if (UnifySection(cast<SectionAttr>(SAttr)->getName(),
                        ASTContext::PSF_Implicit | ASTContext::PSF_Execute |
-                         ASTContext::PSF_Read,
                        NewFD))
         NewFD->dropAttr<SectionAttr>();
     }
+  }
 
   // Handle attributes.
   ProcessDeclAttributes(S, NewFD, D);
 
   if (getLangOpts().OpenCL) {
     // OpenCL v1.1 s6.5: Using an address space qualifier in a function return
     // type declaration will generate a compilation error.
     LangAS AddressSpace = NewFD->getReturnType().getAddressSpace();
if (NewFD->hasAttr<DestructorAttr>()) {
           << 2;
       NewFD->dropAttr<AvailabilityAttr>();
     }
   }
 
   return NewFD;
 }
 
+/// Return a SectionAttr from a containing class.  The Microsoft docs say
+/// when __declspec(code_seg) "is applied to a class, all member functions of
+/// the class and nested classes -- this includes compiler-generated special
+/// member functions -- are put in the specified segment."
+/// The actual behavior is a little more complicated. The Microsoft compiler
+/// won't check outer classes if there is an active value from #pragma code_seg.
+/// The section is always applied from the direct parent but only from outer
+/// classes when the #pragma code_seg stack is empty. See:
+/// https://reviews.llvm.org/D22931, the Microsoft feedback page is no longer
+/// available since MS has removed the page.
+static Attr *getImplicitSectionAttrFromClass(Sema &S, const FunctionDecl *FD) {
+  const auto *Method = dyn_cast<CXXMethodDecl>(FD);
+  if (!Method)
+    return nullptr;
+  const CXXRecordDecl *Parent = Method->getParent();
+  if (const auto *SAttr = Parent->getAttr<SectionAttr>()) {
+    Attr *NewAttr = SAttr->clone(S.getASTContext());
+    NewAttr->setImplicit(true);
+    return NewAttr;
+  }
+
+  // The Microsoft compiler won't check outer classes for the section
+  // when the #pragma code_seg stack is active.
+  if (S.CodeSegStack.CurrentValue)
+    return nullptr;
+
+  while ((Parent = dyn_cast<CXXRecordDecl>(Parent->getParent()))) {
+    if (const auto *SAttr = Parent->getAttr<SectionAttr>()) {
+      Attr *NewAttr = SAttr->clone(S.getASTContext());
+      NewAttr->setImplicit(true);
+      return NewAttr;
+    }
+  }
+  return nullptr;
+}
+
+/// \brief Returns an implicit SectionAttr for a function.
+///
+/// \param FD Function being declared.
+/// \param IsDefinition Whether it is a definition or just a declarartion.
+/// \returns A SectionAttr to apply to the function or nullptr if no
+///          attribute should be added.
+///
+/// First tries to find a SectionAttr on a containing class (from
+/// a __declspec(code_seg)).  If not found on the class, and if the function is
+/// also a definition it will use the current #pragma code_seg value.
+Attr *Sema::getImplicitSectionAttrForFunction(const FunctionDecl *FD, bool IsDefinition) {
+  if (Attr *A = getImplicitSectionAttrFromClass(*this, FD))
+    return A;
+  if (IsDefinition && CodeSegStack.CurrentValue) {
+    return SectionAttr::CreateImplicit(getASTContext(),
+                                       SectionAttr::Declspec_allocate,
+                                       CodeSegStack.CurrentValue->getString(),
+                                       CodeSegStack.CurrentPragmaLocation);
+  }
+  return nullptr;
+}
+
 /// Checks if the new declaration declared in dependent context must be
 /// put in the same redeclaration chain as the specified declaration.
 ///
 /// \param D Declaration that is checked.
 /// \param PrevDecl Previous declaration found with proper lookup method for the
 ///                 same declaration name.
 /// \returns True if D must be added to the redeclaration chain which PrevDecl
 ///          belongs to.

lib/Sema/SemaDeclAttr.cpp

static void handleVecTypeHint(Sema &S, Decl *D, const AttributeList &AL) {
   D->addAttr(::new (S.Context) VecTypeHintAttr(AL.getLoc(), S.Context,
                                                ParmTSI,
                                         AL.getAttributeSpellingListIndex()));
 }
 
 SectionAttr *Sema::mergeSectionAttr(Decl *D, SourceRange Range,
                                     StringRef Name,
                                     unsigned AttrSpellingListIndex) {
+  // Explicit or partial specializations do not inherit
+  // the code_seg attribute from the primary template.
+  if (const auto *FD = dyn_cast<FunctionDecl>(D)){
+    if (FD->isFunctionTemplateSpecialization())
+      return nullptr;
+  }
+
   if (SectionAttr *ExistingAttr = D->getAttr<SectionAttr>()) {
     if (ExistingAttr->getName() == Name)
       return nullptr;
     Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section);
     Diag(Range.getBegin(), diag::note_previous_attribute);
     return nullptr;
   }
   return ::new (Context) SectionAttr(Range, Context, Name,
static void handleTargetAttr(Sema &S, Decl *D, const AttributeList &AL) {
   if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc) ||
       S.checkTargetAttr(LiteralLoc, Str))
     return;
 
   unsigned Index = AL.getAttributeSpellingListIndex();
   TargetAttr *NewAttr =
       ::new (S.Context) TargetAttr(AL.getRange(), S.Context, Str, Index);
   D->addAttr(NewAttr);
 }
 
+static void handleCodeSegAttr(Sema &S, Decl *D, const AttributeList &AL) {
+  StringRef Str;
+  SourceLocation LiteralLoc;
+  if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
+    return;
+  if (!S.checkSectionName(LiteralLoc, Str))
+    return;
+  if (const auto *ExistingAttr = D->getAttr<SectionAttr>()) {
+    if (!ExistingAttr->isImplicit()) {
+      S.Diag(AL.getLoc(), 
+             ExistingAttr->getName() == Str 
+             ? diag::warn_duplicate_codeseg_attribute
+             : diag::err_conflicting_codeseg_attribute);      
+      return;
+    }
+    D->dropAttr<SectionAttr>();
+  }
+  D->addAttr(::new (S.Context) SectionAttr(
+      AL.getRange(), S.Context, Str, AL.getAttributeSpellingListIndex()));
+}
+
 static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &AL) {
   Expr *E = AL.getArgAsExpr(0);
   SourceLocation Loc = E->getExprLoc();
   FunctionDecl *FD = nullptr;
   DeclarationNameInfo NI;
 
   // gcc only allows for simple identifiers. Since we support more than gcc, we
   // will warn the user.
case AttributeList::AT_MSNoVTable:
     handleSimpleAttribute<MSNoVTableAttr>(S, D, AL);
     break;
   case AttributeList::AT_MSStruct:
     handleSimpleAttribute<MSStructAttr>(S, D, AL);
     break;
   case AttributeList::AT_Uuid:
     handleUuidAttr(S, D, AL);
     break;
+  case AttributeList::AT_CodeSeg:
+    handleCodeSegAttr(S, D, AL);
+    break;
   case AttributeList::AT_MSInheritance:
     handleMSInheritanceAttr(S, D, AL);
     break;
   case AttributeList::AT_SelectAny:
     handleSimpleAttribute<SelectAnyAttr>(S, D, AL);
     break;
   case AttributeList::AT_Thread:
     handleDeclspecThreadAttr(S, D, AL);

lib/Sema/SemaDeclCXX.cpp

Sema::CheckBaseSpecifier(CXXRecordDecl *Class,
   // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
   RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl();
   assert(BaseDecl && "Record type has no declaration");
   BaseDecl = BaseDecl->getDefinition();
   assert(BaseDecl && "Base type is not incomplete, but has no definition");
   CXXRecordDecl *CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
   assert(CXXBaseDecl && "Base type is not a C++ type");
 
+  // Microsoft docs say:
+  // "If a base-class has a code_seg attribute, derived classes must have the
+  // same attribute."
+   const auto *BaseSA = CXXBaseDecl->getAttr<SectionAttr>();
+   const auto *DerivedSA = Class->getAttr<SectionAttr>();
+   if (BaseSA || DerivedSA) {
+     if (!BaseSA || !DerivedSA || BaseSA->getName() != DerivedSA->getName()) {
+       Diag(Class->getLocation(), diag::err_mismatched_code_seg_base);
+       Diag(CXXBaseDecl->getLocation(), diag::note_base_class_specified_here)
+         << CXXBaseDecl;
+       return nullptr;
+     }
+   }
+
   // A class which contains a flexible array member is not suitable for use as a
   // base class:
   //   - If the layout determines that a base comes before another base,
   //     the flexible array member would index into the subsequent base.
   //   - If the layout determines that base comes before the derived class,
   //     the flexible array member would index into the derived class.
   if (CXXBaseDecl->hasFlexibleArrayMember()) {
     Diag(BaseLoc, diag::err_base_class_has_flexible_array_member)
if (LastExportedDefaultCtor) {
       S.Diag(CD->getLocation(), diag::note_entity_declared_at)
           << CD->getDeclName();
       return;
     }
     LastExportedDefaultCtor = CD;
   }
 }
 
+void Sema::checkClassLevelSectionAttribute(CXXRecordDecl *Class) {
+  // Mark any compiler-generated routines with the implicit Section attribute.
+  for (auto *Method : Class->methods()) {
+    if (Method->isUserProvided())
+      continue;
+    if (Attr *A = getImplicitSectionAttrForFunction(Method))
+      Method->addAttr(A);
+  }
+}
+
 /// Check class-level dllimport/dllexport attribute.
 void Sema::checkClassLevelDLLAttribute(CXXRecordDecl *Class) {
   Attr *ClassAttr = getDLLAttr(Class);
 
   // MSVC inherits DLL attributes to partial class template specializations.
   if (Context.getTargetInfo().getCXXABI().isMicrosoft() && !ClassAttr) {
     if (auto *Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(Class)) {
       if (Attr *TemplateAttr =
void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
   // really rely on MSVC-compatible layout for.  We must therefore
   // support "ms_struct except for C++ stuff" as a secondary ABI.
   if (Record->isMsStruct(Context) &&
       (Record->isPolymorphic() || Record->getNumBases())) {
     Diag(Record->getLocation(), diag::warn_cxx_ms_struct);
   }
 
   checkClassLevelDLLAttribute(Record);
+  checkClassLevelSectionAttribute(Record);
 
   bool ClangABICompat4 =
       Context.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver4;
   TargetInfo::CallingConvKind CCK =
       Context.getTargetInfo().getCallingConvKind(ClangABICompat4);
   bool CanPass = canPassInRegisters(*this, Record, CCK);
 
   // Do not change ArgPassingRestrictions if it has already been set to
for (unsigned I = 0, E = OldFT->getNumParams(); I != E; ++I)
       if (OldFT->getExtParameterInfo(I).isNoEscape() &&
           !NewFT->getExtParameterInfo(I).isNoEscape()) {
         Diag(New->getParamDecl(I)->getLocation(),
              diag::warn_overriding_method_missing_noescape);
         Diag(Old->getParamDecl(I)->getLocation(),
              diag::note_overridden_marked_noescape);
       }
   }
+  // Virtual overrides must have the same code_seg.
+  const auto *OldSA = Old->getAttr<SectionAttr>();
+  const auto *NewSA = New->getAttr<SectionAttr>();
+  if (OldSA || NewSA) {
+    if (!OldSA || !NewSA || NewSA->getName() != OldSA->getName()) {
+      Diag(New->getLocation(), diag::err_mismatched_code_seg_override);
+      Diag(Old->getLocation(), diag::note_previous_declaration);
+      return true;
+    }
+  }
 
   CallingConv NewCC = NewFT->getCallConv(), OldCC = OldFT->getCallConv();
 
   // If the calling conventions match, everything is fine
   if (NewCC == OldCC)
     return false;
 
   // If the calling conventions mismatch because the new function is static,

lib/Sema/SemaLambda.cpp

void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
   if (ExplicitParams)
     CheckCXXDefaultArguments(Method);
 
   // This represents the function body for the lambda function, check if we
   // have to apply optnone due to a pragma.
   AddRangeBasedOptnone(Method);
   
   // Attributes on the lambda apply to the method.  
+  if (Attr *A = getImplicitSectionAttrForFunction(Method))
+    Method->addAttr(A);
+  
+  // Attributes on the lambda apply to the method.
   ProcessDeclAttributes(CurScope, Method, ParamInfo);
 
   // CUDA lambdas get implicit attributes based on the scope in which they're
   // declared.
   if (getLangOpts().CUDA)
     CUDASetLambdaAttrs(Method);
 
   // Introduce the function call operator as the current declaration context.