4 files changed, 13 insertions, 146 deletions

diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 8c16bbc2480..9a1ab4a3c58 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -2667,14 +2667,9 @@ void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old,
         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;
 
@@ -8721,18 +8716,18 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
                                                  PragmaClangTextSection.PragmaLocation));
   }
 
-  // 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>();
-    }
+  // 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(),
+                     ASTContext::PSF_Implicit | ASTContext::PSF_Execute |
+                         ASTContext::PSF_Read,
+                     NewFD))
+      NewFD->dropAttr<SectionAttr>();
   }
 
   // Handle attributes.
@@ -9182,64 +9177,6 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
   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.
 ///
diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
index 7e64b2369b3..e4532a7e678 100644
--- a/clang/lib/Sema/SemaDeclAttr.cpp
+++ b/clang/lib/Sema/SemaDeclAttr.cpp
@@ -2853,13 +2853,6 @@ static void handleVecTypeHint(Sema &S, Decl *D, const AttributeList &AL) {
 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;
@@ -2949,27 +2942,6 @@ static void handleTargetAttr(Sema &S, Decl *D, const AttributeList &AL) {
   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();
@@ -6325,9 +6297,6 @@ static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
   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;
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
index b836d4c8ad7..d5af147279a 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -2231,20 +2231,6 @@ Sema::CheckBaseSpecifier(CXXRecordDecl *Class,
   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,
@@ -5590,16 +5576,6 @@ static void checkForMultipleExportedDefaultConstructors(Sema &S,
   }
 }
 
-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);
@@ -6103,7 +6079,6 @@ void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
   }
 
   checkClassLevelDLLAttribute(Record);
-  checkClassLevelSectionAttribute(Record);
 
   bool ClangABICompat4 =
       Context.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver4;
@@ -14556,16 +14531,6 @@ bool Sema::CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
              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();
 
diff --git a/clang/lib/Sema/SemaLambda.cpp b/clang/lib/Sema/SemaLambda.cpp
index 4acff89fb90..fec0d575e5b 100644
--- a/clang/lib/Sema/SemaLambda.cpp
+++ b/clang/lib/Sema/SemaLambda.cpp
@@ -910,10 +910,6 @@ void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
   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