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

5–7

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

1769

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

2670

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?

2672

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

1936

The FunctionDecl * can be const.

5839

An extra space snuck in here.

lib/Sema/SemaDecl.cpp

2671

const auto *

8706

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

8709

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

9174

const FunctionDecl *

9175

const auto *.

9179

const auto *.

9180

Attr * instead of auto *.

9191

const auto *

9192

Attr *

9211

Spurious newline

lib/Sema/SemaDeclAttr.cpp

2858

const auto *

2970

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

2979–2982

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.

14547–14548

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

1769

__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

2670

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.

2672

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

test/CodeGenCXX/code_seg3.cpp

5–7

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–2951

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.

14552

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);
 
   /// \brief 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;
+}
+
 /// \brief 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 &Attr) {
+  StringRef Str;
+  SourceLocation LiteralLoc;
+  if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &LiteralLoc))
+    return;
+  if (!S.checkSectionName(LiteralLoc, Str))
+    return;
+  if (const auto *ExistingAttr = D->getAttr<SectionAttr>()) {
+    if (!ExistingAttr->isImplicit()) {
+      S.Diag(Attr.getLoc(), ExistingAttr->getName() == Str 
+                ? diag::warn_duplicate_codeseg_attribute
+          : diag::err_conflicting_codeseg_attribute);     
+      return;
+    }
+    D->dropAttr<SectionAttr>();
+  }
+  D->addAttr(::new (S.Context) SectionAttr(Attr.getRange(), S.Context, Str, 0));
+}
 
 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.
   if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
     if (DRE->hasQualifier())
       S.Diag(Loc, diag::warn_cleanup_ext);
     FD = dyn_cast<FunctionDecl>(DRE->getDecl());
     NI = DRE->getNameInfo();
     if (!FD) {
       S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 1
         << NI.getName();
       return;
     }
   } else if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
     if (ULE->hasExplicitTemplateArgs())
       S.Diag(Loc, diag::warn_cleanup_ext);
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 (auto *A = getImplicitSectionAttrForFunction(Method))
+      Method->addAttr(A);
+  }
+}
+
 /// \brief 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 DestroyedInCallee = paramCanBeDestroyedInCallee(*this, Record, CCK);
 
   if (Record->hasNonTrivialDestructor())
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);
+      return Diag(Old->getLocation(), diag::note_previous_declaration);
+    }
+  }
 
   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.

test/CodeGenCXX/code_seg1.cpp

+// RUN: %clang_cc1 -emit-llvm -triple i686-pc-win32 -fms-extensions -verify -o - %s | FileCheck %s
+// expected-no-diagnostics
+
+// Simple case
+
+int __declspec(code_seg("foo_one")) bar_one() { return 1; }
+//CHECK: define {{.*}}bar_one{{.*}} section "foo_one"
+
+// Simple case - explicit attribute used over pragma
+#pragma code_seg("foo_two")
+int __declspec(code_seg("foo_three")) bar2() { return 2; }
+//CHECK: define {{.*}}bar2{{.*}} section "foo_three"
+
+// Check that attribute on one function doesn't affect another
+int another1() { return 1001; }
+//CHECK: define {{.*}}another1{{.*}} section "foo_two"
+
+// Member functions
+
+struct __declspec(code_seg("foo_four")) Foo {
+  int bar3() {return 0;}
+  int bar4();
+  int __declspec(code_seg("foo_six")) bar6() { return 6; }
+  int bar7() { return 7; }
+  struct Inner {
+    int bar5() { return 5; }
+  } z;
+  virtual int baz1() { return 1; }
+};
+
+struct __declspec(code_seg("foo_four")) FooTwo : Foo {
+  int baz1() { return 20; }
+};
+
+int caller1() {
+  Foo f; return f.bar3();
+}
+
+//CHECK: define {{.*}}bar3@Foo{{.*}} section "foo_four"
+int Foo::bar4() { return 4; }
+//CHECK: define {{.*}}bar4@Foo{{.*}} section "foo_four"
+
+#pragma code_seg("someother")
+
+int caller2() {
+  Foo f;
+  Foo *fp = new FooTwo;
+  return f.z.bar5() + f.bar6() + f.bar7() + fp->baz1();
+}
+// TBD: MS Compiler and Docs do not match for nested routines
+// Doc says:      define {{.*}}bar5@Inner@Foo{{.*}} section "foo_four"
+// Compiler says: define {{.*}}bar5@Inner@Foo{{.*}} section "foo_two"
+//CHECK: define {{.*}}bar6@Foo{{.*}} section "foo_six"
+//CHECK: define {{.*}}bar7@Foo{{.*}} section "foo_four"
+// Check that code_seg active at class declaration is not used on member
+// declared outside class when it is not active.
+
+#pragma code_seg(push,"AnotherSeg")
+
+struct FooThree {
+  int bar8();
+  int bar9() { return 9; }
+};
+
+#pragma code_seg(pop)
+
+
+int FooThree::bar8() {return 0;}
+
+int caller3()
+{
+  FooThree f;
+  return f.bar8() + f.bar9();
+}
+
+//CHECK: define {{.*}}bar8@FooThree{{.*}} section "someother"
+//CHECK: define {{.*}}bar9@FooThree{{.*}} section "AnotherSeg"
+
+struct NonTrivialCopy { NonTrivialCopy(); 
+                  NonTrivialCopy(const NonTrivialCopy&); 
+      ~NonTrivialCopy(); };
+
+// check the section for compiler-generated function with declspec.
+
+struct __declspec(code_seg("foo_seven")) FooFour {
+  FooFour() {}
+  int __declspec(code_seg("foo_eight")) bar10(int t) { return t; }
+  NonTrivialCopy f;
+};
+
+//CHECK: define {{.*}}0FooFour@@QAE@ABU0@@Z{{.*}} section "foo_seven"
+// check the section for compiler-generated function with no declspec.
+
+struct FooFive {
+  FooFive() {}
+  int __declspec(code_seg("foo_nine")) bar11(int t) { return t; }
+  NonTrivialCopy f;
+};
+
+//CHECK: define {{.*}}0FooFive@@QAE@ABU0@@Z{{.*}} section "someother"
+
+#pragma code_seg("YetAnother")
+int caller4()
+{
+  FooFour z1;
+  FooFour z2 = z1;
+  FooFive y1;
+  FooFive y2 = y1;
+  return z2.bar10(0) + y2.bar11(1);
+}
+
+//CHECK: define {{.*}}bar10@FooFour{{.*}} section "foo_eight"
+//CHECK: define {{.*}}bar11@FooFive{{.*}} section "foo_nine"
+
+struct FooSix {
+  #pragma code_seg("foo_ten")
+  int bar12() { return 12; }
+  #pragma code_seg("foo_eleven")
+  int bar13() { return 13; }
+};
+
+int bar14() { return 14; }
+//CHECK: define {{.*}}bar14{{.*}} section "foo_eleven"
+
+int caller5()
+{
+  FooSix fsix;
+  return fsix.bar12() + fsix.bar13();
+}
+
+//CHECK: define {{.*}}bar12@FooSix{{.*}} section "foo_ten"
+//CHECK: define {{.*}}bar13@FooSix{{.*}} section "foo_eleven"
+//CHECK: define {{.*}}baz1@FooTwo{{.*}} section "foo_four"

test/CodeGenCXX/code_seg2.cpp

+// RUN: %clang_cc1 -emit-llvm -triple i686-pc-win32 -std=c++11 -fms-extensions -verify -o - %s | FileCheck %s
+// expected-no-diagnostics
+
+// Class member templates
+
+#pragma code_seg(push, "something")
+
+template <typename T>
+struct __declspec(code_seg("foo_one")) ClassOne {
+  int bar1(T t) { return int(t); }
+  int bar2(T t);
+  int bar3(T t);
+};
+
+template <typename T>
+int ClassOne<T>::bar2(T t) {
+  return int(t);
+}
+
+int caller1() {
+  ClassOne<int> coi;
+  return coi.bar1(6) + coi.bar2(3);
+}
+
+//CHECK: define {{.*}}bar1@?$ClassOne{{.*}} section "foo_one"
+//CHECK: define {{.*}}bar2@?$ClassOne{{.*}} section "foo_one"
+
+
+template <typename T>
+struct ClassTwo {
+  int bar11(T t) { return int(t); }
+  int bar22(T t);
+  int bar33(T t);
+};
+
+#pragma code_seg("newone")
+
+template <typename T>
+int ClassTwo<T>::bar22(T t) {
+  return int(t);
+}
+
+#pragma code_seg("someother")
+
+template <typename T>
+int ClassTwo<T>::bar33(T t) {
+  return int(t);
+}
+
+#pragma code_seg("yetanother")
+
+int caller2() {
+  ClassTwo<int> coi;
+  return coi.bar11(6) + coi.bar22(3) + coi.bar33(44);
+}
+
+//CHECK: define {{.*}}bar11@?$ClassTwo{{.*}} section "something"
+//CHECK: define {{.*}}bar22@?$ClassTwo{{.*}} section "newone"
+//CHECK: define {{.*}}bar33@?$ClassTwo{{.*}} section "someother"
+
+template<>
+struct ClassOne<double>
+{
+  int bar44(double d) { return 1; }
+};
+template<>
+struct  __declspec(code_seg("foo_three")) ClassOne<long>
+{
+  int bar55(long d) { return 1; }
+};
+
+#pragma code_seg("onemore")
+int caller3() {
+  ClassOne<double> d;
+  ClassOne<long> l;
+  return d.bar44(1.0)+l.bar55(1);
+}
+
+//CHECK: define {{.*}}bar44{{.*}} section "yetanother"
+//CHECK: define {{.*}}bar55{{.*}} section "foo_three"
+
+
+// Function templates
+template <typename T>
+int __declspec(code_seg("foo_four")) bar66(T t) { return int(t); }
+
+// specializations do not take the segment from primary
+template<>
+int bar66(int i) { return 0; }
+
+#pragma code_seg(pop)
+
+template<>
+int bar66(char c) { return 0; }
+
+struct A1 {int i;};
+template<>
+int __declspec(code_seg("foo_five")) bar66(A1 a) { return a.i; }
+
+int caller4()
+{
+// but instantiations do use the section from the primary
+return bar66(0) + bar66(1.0) + bar66('c');
+}
+//CHECK: define {{.*}}bar66@H{{.*}} section "onemore"
+//CHECK-NOT: define {{.*}}bar66@D{{.*}} section
+//CHECK: define {{.*}}bar66@UA1{{.*}} section "foo_five"
+//CHECK: define {{.*}}bar66@N{{.*}} section "foo_four"
+
+
+#pragma code_seg("another")
+// Member functions
+struct __declspec(code_seg("foo_four")) Foo {
+  int bar3() {return 0;}
+ __declspec(code_seg("foo_lala")) int bar4() {return 0;} }; int caller() {Foo f; return f.bar3() + f.bar4(); }
+
+//CHECK: define {{.*}}bar3@Foo{{.*}} section "foo_four"
+//CHECK: define {{.*}}bar4@Foo{{.*}} section "foo_lala"
+
+// Lambdas
+#pragma code_seg("something")
+
+int __declspec(code_seg("foo")) bar1()
+{
+  int lala = 4;
+  auto l = [=](int i) { return i+4; };
+  return l(-4);
+}
+
+//CHECK: define {{.*}}bar1{{.*}} section "foo"
+//CHECK: define {{.*}}lambda{{.*}}bar1{{.*}} section "something"
+
+double __declspec(code_seg("foo")) bar2()
+{
+  double lala = 4.0;
+  auto l = [=](double d) __declspec(code_seg("another"))  { return d+4.0; };
+  return l(4.0);
+}
+
+//CHECK: define {{.*}}bar2{{.*}} section "foo"
+//CHECK: define {{.*}}lambda{{.*}}bar2{{.*}} section "another"

test/CodeGenCXX/code_seg3.cpp

+// RUN: %clang_cc1 -emit-llvm -triple i686-pc-win32 -fms-extensions -verify -o - %s | FileCheck %s
+// expected-no-diagnostics
+// The Microsoft document says: "When this attribute 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."
+// But the MS compiler does not always follow that.  A bug has been reported:
+// see https://reviews.llvm.org/D22931, the Microsoft feedback page is no
+// longer available.
+// The MS compiler will apply a declspec from the parent class if there is no
+// #pragma code_seg active at the class definition.  If there is an active
+// code_seg that is used instead.
+
+// No active code_seg
+
+struct __declspec(code_seg("foo_outer")) Foo1 {
+  struct Inner {
+    void bar1();
+    static void bar2();
+  };
+};
+void Foo1::Inner::bar1() {}
+void Foo1::Inner::bar2() {}
+
+//CHECK: define {{.*}}bar1@Inner@Foo1{{.*}} section "foo_outer"
+//CHECK: define {{.*}}bar2@Inner@Foo1{{.*}} section "foo_outer"
+
+struct __declspec(code_seg("foo_outer")) Foo2 {
+  struct __declspec(code_seg("foo_inner")) Inner {
+    void bar1();
+    static void bar2();
+  };
+};
+void Foo2::Inner::bar1() {}
+void Foo2::Inner::bar2() {}
+
+//CHECK: define {{.*}}bar1@Inner@Foo2{{.*}} section "foo_inner"
+//CHECK: define {{.*}}bar2@Inner@Foo2{{.*}} section "foo_inner"
+
+#pragma code_seg(push, "otherseg")
+struct __declspec(code_seg("foo_outer")) Foo3 {
+  struct Inner {
+    void bar1();
+    static void bar2();
+  };
+};
+void Foo3::Inner::bar1() {}
+void Foo3::Inner::bar2() {}
+
+//CHECK: define {{.*}}bar1@Inner@Foo3{{.*}} section "otherseg"
+//CHECK: define {{.*}}bar2@Inner@Foo3{{.*}} section "otherseg"
+
+struct __declspec(code_seg("foo_outer")) Foo4 {
+  struct __declspec(code_seg("foo_inner")) Inner {
+    void bar1();
+    static void bar2();
+  };
+};
+void Foo4::Inner::bar1() {}
+void Foo4::Inner::bar2() {}
+
+//CHECK: define {{.*}}bar1@Inner@Foo4{{.*}} section "foo_inner"
+//CHECK: define {{.*}}bar2@Inner@Foo4{{.*}} section "foo_inner"
+
+#pragma code_seg(pop)
+// Back to no active pragma
+struct __declspec(code_seg("foo_outer")) Foo5 {
+  struct Inner {
+    void bar1();
+    static void bar2();
+    struct __declspec(code_seg("inner1_seg")) Inner1 {
+      struct Inner2 {
+        void bar1();
+        static void bar2();
+      };
+    };
+  };
+};
+void Foo5::Inner::bar1() {}
+void Foo5::Inner::bar2() {}
+void Foo5::Inner::Inner1::Inner2::bar1() {}
+void Foo5::Inner::Inner1::Inner2::bar2() {}
+
+//CHECK: define {{.*}}bar1@Inner@Foo5{{.*}} section "foo_outer"
+//CHECK: define {{.*}}bar2@Inner@Foo5{{.*}} section "foo_outer"
+//CHECK: define {{.*}}bar1@Inner2@Inner1@Inner@Foo5{{.*}} section "inner1_seg"
+//CHECK: define {{.*}}bar2@Inner2@Inner1@Inner@Foo5{{.*}} section "inner1_seg"

test/CodeGenCXX/code_seg4.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify -fms-extensions %s -triple x86_64-pc-win32
+// expected-no-diagnostics
+
+// Non-Member Function Overloading is involved
+
+int __declspec(code_seg("foo_one")) bar_one(int) { return 1; }
+//CHECK: define {{.*}}bar_one{{.*}} section "foo_one"
+int __declspec(code_seg("foo_two")) bar_one(int,float) { return 11; }
+//CHECK: define {{.*}}bar_one{{.*}} section "foo_two"
+int __declspec(code_seg("foo_three")) bar_one(float) { return 12; }
+//CHECK: define {{.*}}bar_one{{.*}} section "foo_three"
+
+// virtual function overloading is involved
+
+struct __declspec(code_seg("my_one")) Base3 {
+  virtual int barA(int) { return 1; }
+  virtual int barA(int,float) { return 2; }
+  virtual int barA(float) { return 3; }
+
+  virtual void __declspec(code_seg("my_two")) barB(int) { }
+  virtual void  __declspec(code_seg("my_three")) barB(float) { }
+  virtual void __declspec(code_seg("my_four")) barB(int, float) { }
+
+};
+
+//CHECK: define {{.*}}barA@Base3{{.*}} section "my_one"
+//CHECK: define {{.*}}barA@Base3{{.*}} section "my_one"
+//CHECK: define {{.*}}barA@Base3{{.*}} section "my_one"
+//CHECK: define {{.*}}barB@Base3{{.*}} section "my_two"
+//CHECK: define {{.*}}barB@Base3{{.*}} section "my_three"
+//CHECK: define {{.*}}barB@Base3{{.*}} section "my_four"

test/SemaCXX/code_seg.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify -fms-extensions %s -triple x86_64-pc-win32
+
+struct __declspec(code_seg("my_one")) FooOne {
+  int barC();
+};
+
+struct FooTwo {
+  int __declspec(code_seg("my_three")) barD();
+  int barE();
+};
+int __declspec(code_seg("my_four")) FooOne::barC() { return 10; }
+// expected-warning@-1 {{section does not match previous declaration}}
+// expected-note@3{{previous attribute is here}}
+int __declspec(code_seg("my_five")) FooTwo::barD() { return 20; }
+// expected-warning@-1 {{section does not match previous declaration}}
+// expected-note@8 {{previous attribute is here}}
+int __declspec(code_seg("my_six")) FooTwo::barE() { return 30; }
+// expected-warning@-1 {{section does not match previous declaration}}
+// expected-note@9 {{previous declaration is here}}
+
+// Microsoft docs say:
+// If a base-class has a code_seg attribute, derived classes must have the
+// same attribute.
+struct __declspec(code_seg("my_base")) Base1 {};
+struct Base2 {};
+
+struct D1 : Base1 {};
+//expected-error@-1 {{derived class must specify the same code segment as its base classes}}
+// expected-note@24 {{base class 'Base1' specified here}}
+struct __declspec(code_seg("my_derived")) D2 : Base1 {};
+// expected-error@-1 {{derived class must specify the same code segment as its base classes}}
+// expected-note@24 {{base class 'Base1' specified here}}
+struct __declspec(code_seg("my_derived")) D3 : Base2 {};
+// expected-error@-1 {{derived class must specify the same code segment as its base classes}}
+// expected-note@25 {{base class 'Base2' specified here}}
+
+template <typename T> struct __declspec(code_seg("my_base")) MB : T { };
+template <typename T> struct __declspec(code_seg("my_derived")) MD : T { };
+MB<Base1> mb1; // ok
+MB<Base2> mb2;
+// expected-error@37 {{derived class must specify the same code segment as its base classes}}
+// expected-note@-2 {{in instantiation of template class}}
+// expected-note@25  {{base class 'Base2' specified here}}
+MD<Base1> md1;
+// expected-error@38 {{derived class must specify the same code segment as its base classes}}
+// expected-note@-2 {{in instantiation of template class}}
+// expected-note@24 {{base class 'Base1' specified here}}
+MD<Base2> md2;
+// expected-error@38 {{derived class must specify the same code segment as its base classes}}
+// expected-note@-2 {{in instantiation of template class}}
+// expected-note@25 {{base class 'Base2' specified here}}
+
+// Virtual overrides must have the same code_seg.
+struct __declspec(code_seg("my_one")) Base3 {
+  virtual int barA() { return 1; }
+  virtual int __declspec(code_seg("my_two")) barB() { return 2; }
+};
+struct __declspec(code_seg("my_one")) Derived3 : Base3 {
+  int barA() { return 4; } // ok
+  int barB() { return 6; }
+  // expected-error@-1 {{overriding virtual function must specify the same code segment as its overridden function}}
+  // expected-note@56 {{previous declaration is here}}
+};
+
+struct Base4 {
+  virtual int __declspec(code_seg("my_one")) barA() {return 1;}
+  virtual int barB() { return 2;}
+};
+struct Derived4 : Base4 {
+  virtual int barA() {return 1;}
+  // expected-error@-1 {{overriding virtual function must specify the same code segment as its overridden function}}
+  // expected-note@66 {{previous declaration is here}}
+  virtual int __declspec(code_seg("my_two")) barB() {return 1;}
+  // expected-error@-1 {{overriding virtual function must specify the same code segment as its overridden function}}
+  // expected-note@67 {{previous declaration is here}}
+};
+
+// MS gives an error when different code segments are used but a warning when a duplicate is used
+
+// Function
+int __declspec(code_seg("foo")) __declspec(code_seg("foo")) bar1() { return 1; }
+// expected-warning@-1 {{duplicate code segment specifiers}}
+int __declspec(code_seg("foo")) __declspec(code_seg("bar")) bar2() { return 1; }
+// expected-error@-1 {{conflicting code segment specifiers}}
+
+// Class
+struct __declspec(code_seg("foo")) __declspec(code_seg("foo")) Foo {
+  // expected-warning@-1 {{duplicate code segment specifiers}}
+  int bar3() {return 0;}
+};
+struct __declspec(code_seg("foo")) __declspec(code_seg("bar")) FooSix {
+  // expected-error@-1 {{conflicting code segment specifiers}}
+  int bar3() {return 0;}
+};
+
+//Class Members
+struct FooThree {
+  int __declspec(code_seg("foo")) __declspec(code_seg("foo")) bar1() { return 1; }
+  // expected-warning@-1 {{duplicate code segment specifiers}}
+  int __declspec(code_seg("foo")) __declspec(code_seg("bar")) bar2() { return 1; }
+  // expected-error@-1 {{conflicting code segment specifiers}}
+  int bar8();
+  int bar9() { return 9; }
+};

test/SemaCXX/code_seg1.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify -fms-extensions %s -triple x86_64-pc-win32
+
+// Multiple inheritance is involved (code segmments all disagree between the bases and derived class)
+struct __declspec(code_seg("my_base")) Base1 {};
+struct Base2 {};
+
+struct D1 : Base1, Base2 {};
+// expected-error@-1 {{derived class must specify the same code segment as its base classes}}
+// expected-note@4 {{base class 'Base1' specified here}}
+
+struct __declspec(code_seg("my_derived")) D2 : Base2, Base1 {};
+// expected-error@-1 {{derived class must specify the same code segment as its base classes}}
+// expected-error@-2 {{derived class must specify the same code segment as its base classes}}
+// expected-note@5 {{base class 'Base2' specified here}}
+// expected-note@4 {{base class 'Base1' specified here}}
+
+// Multiple inheritance (code segments partially agree between the bases and the derived class)
+struct __declspec(code_seg("base_class")) BaseClass1 {};
+struct __declspec(code_seg("base_class")) BaseClass2 {};
+
+struct Derived1 : BaseClass1, BaseClass2 {};
+// expected-error@-1 {{derived class must specify the same code segment as its base classes}}
+// expected-error@-2 {{derived class must specify the same code segment as its base classes}}
+// expected-note@18 {{base class 'BaseClass1' specified here}}
+// expected-note@19 {{base class 'BaseClass2' specified here}}
+
+struct __declspec(code_seg("derived_class")) Derived2 : BaseClass2, BaseClass1 {};
+// expected-error@-1 {{derived class must specify the same code segment as its base classes}}
+// expected-error@-2 {{derived class must specify the same code segment as its base classes}}
+// expected-note@19 {{base class 'BaseClass2' specified here}}
+// expected-note@18 {{base class 'BaseClass1' specified here}}
+
+struct __declspec(code_seg("base_class")) Derived3 : BaseClass2, BaseClass1 {}; //OK
+struct __declspec(code_seg("base_class")) Derived4 : BaseClass1, BaseClass2 {}; //OK
+
+// Multiple inheritance is involved (code segmments all agree between the bases and derived class)
+struct __declspec(code_seg("foo_base")) B1 {};
+struct __declspec(code_seg("foo_base")) B2 {};
+struct __declspec(code_seg("foo_base")) Derived : B1, B2 {};
+
+// virtual Inheritance is involved (code segmments all disagree between the bases and derived class)
+struct __declspec(code_seg("my_one")) Base {
+  virtual int barA() { return 1; } ;
+};
+
+struct __declspec(code_seg("my_two")) Derived5 : virtual Base {
+  virtual int barB() { return 2; };
+};
+// expected-error@-3 {{derived class must specify the same code segment as its base classes}}
+// expected-note@42 {{base class 'Base' specified here}}
+
+struct __declspec(code_seg("my_three")) Derived6 : virtual Base {
+  virtual int barC() { return 3; };
+};
+// expected-error@-3 {{derived class must specify the same code segment as its base classes}}
+// expected-note@42 {{base class 'Base' specified here}}
+
+struct __declspec(code_seg("my_four")) Derived7 : Derived5, Derived6 {};
+// expected-error@-1 {{derived class must specify the same code segment as its base classes}}
+// expected-error@-2 {{derived class must specify the same code segment as its base classes}}
+// expected-note@46 {{base class 'Derived5' specified here}}
+// expected-note@52 {{base class 'Derived6' specified here}}
+
+// virtual Inheritance is involved (code segmments partially agree between the bases and derived class)
+struct __declspec(code_seg("my_class")) BaseClass {
+  virtual int barA() { return 1; } ;
+};
+
+struct __declspec(code_seg("my_class")) DerivedClass1 : virtual BaseClass { //OK
+  virtual int barB() { return 2; };
+};
+
+struct __declspec(code_seg("my_class")) DerivedClass2 : virtual BaseClass { //OK
+  virtual int barC() { return 3; };
+};
+
+struct __declspec(code_seg("my_derived_one")) DerivedClass3 : DerivedClass1, DerivedClass2 {};
+// expected-error@-1 {{derived class must specify the same code segment as its base classes}}
+// expected-error@-2 {{derived class must specify the same code segment as its base classes}}
+// expected-note@69 {{base class 'DerivedClass1' specified here}}
+// expected-note@73 {{base class 'DerivedClass2' specified here}}
+
+// virtual Inheritance is involved (code segmments all agree between the bases and derived class)
+struct __declspec(code_seg("foo_one")) Class {
+  virtual int foo1() { return 10; } ;
+};
+
+struct __declspec(code_seg("foo_one")) Derived_One: virtual Class { //OK
+  virtual int foo2() { return 20; };
+};
+
+struct __declspec(code_seg("foo_one")) Derived_Two : virtual Class { //OK
+  virtual int foo3() { return 30; };
+};
+
+struct __declspec(code_seg("foo_one")) Derived_Three : Derived_One, Derived_Two {}; //OK