Index: include/clang/Basic/Attr.td
===================================================================
--- include/clang/Basic/Attr.td
+++ include/clang/Basic/Attr.td
@@ -1739,6 +1739,24 @@
   let Documentation = [MSInheritanceDocs];
 }
 
+def MSSegment : Attr {
+  // This attribute has no spellings as it is only ever created implicitly.
+  let Spellings = [];
+  let Args = [StringArgument<"SegName">, UnsignedArgument<"kind">];
+
+  let AdditionalMembers = [{
+  enum Kind {
+    DataSeg,
+    CodeSeg,
+    BSSSeg,
+    ConstSeg
+  };
+
+  Kind getSegKind() const { return Kind(kind); }
+  }];
+  let Documentation = [Undocumented];
+}
+
 def MSVtorDisp : InheritableAttr {
   // This attribute has no spellings as it is only ever created implicitly.
   let Spellings = [];
Index: include/clang/Basic/DiagnosticParseKinds.td
===================================================================
--- include/clang/Basic/DiagnosticParseKinds.td
+++ include/clang/Basic/DiagnosticParseKinds.td
@@ -770,6 +770,8 @@
   "missing ')' after '#pragma %0' - ignoring">, InGroup<IgnoredPragmas>;
 def warn_pragma_expected_identifier : Warning<
   "expected identifier in '#pragma %0' - ignored">, InGroup<IgnoredPragmas>;
+def warn_pragma_expected_string : Warning<
+  "expected string literal in '#pragma %0' - ignored">, InGroup<IgnoredPragmas>;
 def warn_pragma_expected_integer : Warning<
   "expected integer between %0 and %1 inclusive in '#pragma %2' - ignored">,
   InGroup<IgnoredPragmas>;
Index: include/clang/Basic/TokenKinds.def
===================================================================
--- include/clang/Basic/TokenKinds.def
+++ include/clang/Basic/TokenKinds.def
@@ -683,6 +683,11 @@
 // handles them.
 ANNOTATION(pragma_ms_vtordisp)
 
+// Annotation for all microsoft #pragmas...
+// The lexer produces these so that they only take effect when the parser
+// handles them.
+ANNOTATION(pragma_ms_pragma)
+
 // Annotation for #pragma OPENCL EXTENSION...
 // The lexer produces these so that they only take effect when the parser
 // handles them.
Index: include/clang/Parse/Parser.h
===================================================================
--- include/clang/Parse/Parser.h
+++ include/clang/Parse/Parser.h
@@ -154,6 +154,10 @@
   OwningPtr<PragmaHandler> MSDetectMismatchHandler;
   OwningPtr<PragmaHandler> MSPointersToMembers;
   OwningPtr<PragmaHandler> MSVtorDisp;
+  OwningPtr<PragmaHandler> MSDataSeg;
+  OwningPtr<PragmaHandler> MSBSSSeg;
+  OwningPtr<PragmaHandler> MSConstSeg;
+  OwningPtr<PragmaHandler> MSCodeSeg;
 
   OwningPtr<CommentHandler> CommentSemaHandler;
 
@@ -468,6 +472,8 @@
 
   void HandlePragmaMSVtorDisp();
 
+  void HandlePragmaMSPragma();
+
   /// \brief Handle the annotation token produced for
   /// #pragma align...
   void HandlePragmaAlign();
Index: include/clang/Sema/Sema.h
===================================================================
--- include/clang/Sema/Sema.h
+++ include/clang/Sema/Sema.h
@@ -273,6 +273,13 @@
     PVDK_Reset          ///< #pragma vtordisp()
   };
 
+  enum PragmaMsStackAction {
+    PSK_Push,  // #pragma (push, ...)
+    PSK_Pop,   // #pragma (pop, ...)
+    PSK_Reset, // #pragma ()
+    PSK_Set    // #pragma (...)
+  };
+
   /// \brief Whether to insert vtordisps prior to virtual bases in the Microsoft
   /// C++ ABI.  Possible values are 0, 1, and 2, which mean:
   ///
@@ -288,6 +295,24 @@
   /// \brief Source location for newly created implicit MSInheritanceAttrs
   SourceLocation ImplicitMSInheritanceAttrLoc;
 
+  struct MSSegmentStack {
+    void Act(SourceLocation PragmaLoc,
+             PragmaMsStackAction Action,
+             llvm::StringRef ActionTarget,
+             StringLiteral *Value);
+    explicit MSSegmentStack()
+      : Current(0) {}
+    typedef std::pair<llvm::StringRef,
+                      std::pair<StringLiteral *, SourceLocation>> Slot;
+    SmallVector<Slot, 2> Stack;
+    StringLiteral *Current;
+    SourceLocation SourceLoc;
+  };
+  MSSegmentStack DataSegStack;
+  MSSegmentStack BSSSegStack;
+  MSSegmentStack ConstSegStack;
+  MSSegmentStack CodeSegStack;
+
   /// VisContext - Manages the stack for \#pragma GCC visibility.
   void *VisContext; // Really a "PragmaVisStack*"
 
@@ -6994,6 +7019,30 @@
   void ActOnPragmaMSVtorDisp(PragmaVtorDispKind Kind, SourceLocation PragmaLoc,
                              MSVtorDispAttr::Mode Value);
 
+  /// \brief Called on well formed \#pragma data_seg().
+  void ActOnPragmaMSDataSeg(SourceLocation PragmaLoc,
+                            PragmaMsStackAction Action,
+                            llvm::StringRef ActionTarget,
+                            StringLiteral *SegmentName);
+
+  /// \brief Called on well formed \#pragma bss_seg().
+  void ActOnPragmaMSBSSSeg(SourceLocation PragmaLoc,
+                          PragmaMsStackAction Action,
+                          llvm::StringRef ActionTarget,
+                          StringLiteral *SegmentName);
+
+  /// \brief Called on well formed \#pragma const_seg().
+  void ActOnPragmaMSConstSeg(SourceLocation PragmaLoc,
+                             PragmaMsStackAction Action,
+                             llvm::StringRef ActionTarget,
+                             StringLiteral *SegmentName);
+
+  /// \brief Called on well formed \#pragma code_seg().
+  void ActOnPragmaMSCodeSeg(SourceLocation PragmaLoc,
+                            PragmaMsStackAction Action,
+                            llvm::StringRef ActionTarget,
+                            StringLiteral *SegmentName);
+
   /// ActOnPragmaDetectMismatch - Call on well-formed \#pragma detect_mismatch
   void ActOnPragmaDetectMismatch(StringRef Name, StringRef Value);
 
Index: lib/CodeGen/CodeGenModule.cpp
===================================================================
--- lib/CodeGen/CodeGenModule.cpp
+++ lib/CodeGen/CodeGenModule.cpp
@@ -704,6 +704,9 @@
   if (const SectionAttr *SA = D->getAttr<SectionAttr>())
     GV->setSection(SA->getName());
 
+  if (D->hasAttr<MSSegmentAttr>())
+    GV->setSection(D->getAttr<MSSegmentAttr>()->getSegName());
+
   // Alias cannot have attributes. Filter them here.
   if (!isa<llvm::GlobalAlias>(GV))
     getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this);
Index: lib/Parse/ParseDeclCXX.cpp
===================================================================
--- lib/Parse/ParseDeclCXX.cpp
+++ lib/Parse/ParseDeclCXX.cpp
@@ -2615,6 +2615,11 @@
         continue;
       }
 
+      if (Tok.is(tok::annot_pragma_ms_pragma)) {
+        HandlePragmaMSPragma();
+        continue;
+      }
+
       // If we see a namespace here, a close brace was missing somewhere.
       if (Tok.is(tok::kw_namespace)) {
         DiagnoseUnexpectedNamespace(cast<NamedDecl>(TagDecl));
Index: lib/Parse/ParsePragma.cpp
===================================================================
--- lib/Parse/ParsePragma.cpp
+++ lib/Parse/ParsePragma.cpp
@@ -124,6 +124,12 @@
                             Token &FirstToken);
 };
 
+struct PragmaMSPragma : public PragmaHandler {
+  explicit PragmaMSPragma(const char *name) : PragmaHandler(name) {}
+  virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
+    Token &FirstToken);
+};
+
 }  // end namespace
 
 void Parser::initializePragmaHandlers() {
@@ -175,6 +181,14 @@
     PP.AddPragmaHandler(MSPointersToMembers.get());
     MSVtorDisp.reset(new PragmaMSVtorDisp());
     PP.AddPragmaHandler(MSVtorDisp.get());
+    MSDataSeg.reset(new PragmaMSPragma("data_seg"));
+    PP.AddPragmaHandler(MSDataSeg.get());
+    MSBSSSeg.reset(new PragmaMSPragma("bss_seg"));
+    PP.AddPragmaHandler(MSBSSSeg.get());
+    MSConstSeg.reset(new PragmaMSPragma("const_seg"));
+    PP.AddPragmaHandler(MSConstSeg.get());
+    MSCodeSeg.reset(new PragmaMSPragma("code_seg"));
+    PP.AddPragmaHandler(MSCodeSeg.get());
   }
 }
 
@@ -214,6 +228,14 @@
     MSPointersToMembers.reset();
     PP.RemovePragmaHandler(MSVtorDisp.get());
     MSVtorDisp.reset();
+    PP.RemovePragmaHandler(MSDataSeg.get());
+    MSDataSeg.reset();
+    PP.RemovePragmaHandler(MSBSSSeg.get());
+    MSBSSSeg.reset();
+    PP.RemovePragmaHandler(MSConstSeg.get());
+    MSConstSeg.reset();
+    PP.RemovePragmaHandler(MSCodeSeg.get());
+    MSCodeSeg.reset();
   }
 
   PP.RemovePragmaHandler("STDC", FPContractHandler.get());
@@ -400,6 +422,85 @@
   Actions.ActOnPragmaMSVtorDisp(Kind, PragmaLoc, Mode);
 }
 
+void Parser::HandlePragmaMSPragma() {
+  assert(Tok.is(tok::annot_pragma_ms_pragma));
+  SourceLocation PragmaLoc = ConsumeToken(); // The annotation token.
+  // Grab the identifier following #pragma
+  assert(Tok.isAnyIdentifier());
+  llvm::StringRef PragmaName = Tok.getIdentifierInfo()->getName();
+  PP.Lex(Tok); // pragma kind
+  // Figure out which #pragma we're dealing with.  The switch has no default
+  // because lex shouldn't emit the annotation token for unrecognized pragmas.
+  enum PragmaMSKind { DataSeg, BSSSeg, ConstSeg, CodeSeg } Kind =
+    llvm::StringSwitch<PragmaMSKind>(PragmaName)
+      .Case("data_seg", DataSeg)
+      .Case("bss_seg", BSSSeg)
+      .Case("const_seg", ConstSeg)
+      .Case("code_seg", CodeSeg);
+  if (Tok.isNot(tok::l_paren)) {
+    PP.Diag(PragmaLoc, diag::warn_pragma_expected_lparen) << PragmaName;
+    return;
+  }
+  PP.Lex(Tok); // (
+  Sema::PragmaMsStackAction Action = Sema::PSK_Set;
+  llvm::StringRef IName;
+  if (Tok.isAnyIdentifier()) {
+    IName = Tok.getIdentifierInfo()->getName();
+    if (IName == "push")
+      Action = Sema::PSK_Push;
+    else if (IName == "pop")
+      Action = Sema::PSK_Pop;
+    else {
+      PP.Diag(PragmaLoc, diag::warn_pragma_invalid_action) << PragmaName;
+      return;
+    }
+    if (Action != Sema::PSK_Set) {
+      IName = llvm::StringRef();
+      PP.Lex(Tok); // push | pop
+      if (Tok.is(tok::comma)) {
+        PP.Lex(Tok); // ,
+        if (Tok.isAnyIdentifier()) {
+          IName = Tok.getIdentifierInfo()->getName();
+          PP.Lex(Tok); // identifier
+          if (Tok.is(tok::comma))
+            PP.Lex(Tok);
+          else if (Tok.isNot(tok::r_paren)) {
+            PP.Diag(PragmaLoc, diag::warn_pragma_expected_punc) << PragmaName;
+            return;
+          }
+        }
+      } else if (Tok.isNot(tok::r_paren)) {
+        PP.Diag(PragmaLoc, diag::warn_pragma_expected_punc) << PragmaName;
+        return;
+      }
+    }
+  } else if (Tok.is(tok::r_paren))
+    Action = Sema::PSK_Reset;
+  // Grab the string literal for our section name.
+  StringLiteral *SegmentName = nullptr;
+  if (Tok.isNot(tok::r_paren)) {
+    ExprResult SegmentNameExpr = ParseStringLiteralExpression();
+    if (SegmentNameExpr.isInvalid()) {
+      PP.Diag(PragmaLoc, diag::warn_pragma_expected_string) << PragmaName;
+      return;
+    }
+    SegmentName = cast<StringLiteral>(SegmentNameExpr.get());
+  }
+  if (Tok.isNot(tok::r_paren)) {
+    PP.Diag(PragmaLoc, diag::warn_pragma_expected_rparen) << PragmaName;
+    return;
+  }
+  PP.Lex(Tok); // ')'
+  if (Kind == DataSeg)
+    Actions.ActOnPragmaMSDataSeg(PragmaLoc, Action, IName, SegmentName);
+  else if (Kind == BSSSeg)
+    Actions.ActOnPragmaMSBSSSeg(PragmaLoc, Action, IName, SegmentName);
+  else if (Kind == ConstSeg)
+    Actions.ActOnPragmaMSConstSeg(PragmaLoc, Action, IName, SegmentName);
+  else if (Kind == CodeSeg)
+    Actions.ActOnPragmaMSCodeSeg(PragmaLoc, Action, IName, SegmentName);
+}
+
 // #pragma GCC visibility comes in two variants:
 //   'push' '(' [visibility] ')'
 //   'pop'
@@ -1204,6 +1305,24 @@
   PP.EnterToken(AnnotTok);
 }
 
+/// \brief Handle all MS pragmas.  Simply forwards the tokens after inserting
+/// an annotation token.
+void PragmaMSPragma::HandlePragma(Preprocessor &PP,
+                                  PragmaIntroducerKind Introducer,
+                                  Token &Tok) {
+  Token AnnotTok;
+  AnnotTok.startToken();
+  AnnotTok.setKind(tok::annot_pragma_ms_pragma);
+  AnnotTok.setLocation(Tok.getLocation());
+  SmallVector<Token, 8> TokenVector;
+  TokenVector.push_back(AnnotTok);
+  for (; Tok.isNot(tok::eod); PP.Lex(Tok))
+    TokenVector.push_back(Tok);
+  Token *TokenArray = new Token[TokenVector.size()];
+  memcpy(TokenArray, TokenVector.data(), sizeof(Token)* TokenVector.size());
+  PP.EnterTokenStream(TokenArray, TokenVector.size(), true, true);
+}
+
 /// \brief Handle the Microsoft \#pragma detect_mismatch extension.
 ///
 /// The syntax is:
Index: lib/Parse/ParseStmt.cpp
===================================================================
--- lib/Parse/ParseStmt.cpp
+++ lib/Parse/ParseStmt.cpp
@@ -350,6 +350,10 @@
     HandlePragmaMSPointersToMembers();
     return StmtEmpty();
 
+  case tok::annot_pragma_ms_pragma:
+    ProhibitAttributes(Attrs);
+    HandlePragmaMSPragma();
+    return StmtEmpty();
   }
 
   // If we reached this code, the statement must end in a semicolon.
@@ -828,6 +832,9 @@
     case tok::annot_pragma_ms_pointers_to_members:
       HandlePragmaMSPointersToMembers();
       break;
+    case tok::annot_pragma_ms_pragma:
+      HandlePragmaMSPragma();
+      break;
     default:
       checkForPragmas = false;
       break;
Index: lib/Parse/Parser.cpp
===================================================================
--- lib/Parse/Parser.cpp
+++ lib/Parse/Parser.cpp
@@ -631,6 +631,9 @@
   case tok::annot_pragma_ms_vtordisp:
     HandlePragmaMSVtorDisp();
     return DeclGroupPtrTy();
+  case tok::annot_pragma_ms_pragma:
+    HandlePragmaMSPragma();
+    return DeclGroupPtrTy();
   case tok::semi:
     // Either a C++11 empty-declaration or attribute-declaration.
     SingleDecl = Actions.ActOnEmptyDeclaration(getCurScope(),
Index: lib/Sema/Sema.cpp
===================================================================
--- lib/Sema/Sema.cpp
+++ lib/Sema/Sema.cpp
@@ -79,6 +79,7 @@
     MSPointerToMemberRepresentationMethod(
         LangOpts.getMSPointerToMemberRepresentationMethod()),
     VtorDispModeStack(1, MSVtorDispAttr::Mode(LangOpts.VtorDispMode)),
+    DataSegStack(), CodeSegStack(), ConstSegStack(),
     VisContext(0),
     IsBuildingRecoveryCallExpr(false),
     ExprNeedsCleanups(false), LateTemplateParser(0), OpaqueParser(0),
Index: lib/Sema/SemaAttr.cpp
===================================================================
--- lib/Sema/SemaAttr.cpp
+++ lib/Sema/SemaAttr.cpp
@@ -325,6 +325,100 @@
   }
 }
 
+template<typename Type> Type
+PopToName(std::vector<llvm::StringRef, Type>& Stack, llvm::StringRef Key) {
+  if (!ActionTarget.empty()) {
+    auto I = std::find_if(DataSegStack.rbegin(), DataSegStack.rend(),
+      [&](const std::pair<llvm::StringRef, StringLiteral *> &x) {
+      return x.first == ActionTarget;
+    });
+    CurrentDataSegment = I->second;
+    if (I != DataSegStack.rend())
+      DataSegStack.erase(std::prev(I.base()), DataSegStack.end());
+  }
+  else if (!DataSegStack.empty()) {
+    CurrentDataSegment = DataSegStack.back().second;
+    DataSegStack.pop_back();
+  }
+}
+
+void Sema::MSSegmentStack::Act(SourceLocation PragmaLoc,
+                               PragmaMsStackAction Action,
+                               llvm::StringRef ActionTarget,
+                               StringLiteral *SectionName) {
+  switch (Action) {
+  case PSK_Push:
+    Stack.push_back(
+        std::make_pair(ActionTarget, std::make_pair(Current, SourceLoc)));
+    break;
+  case PSK_Pop:
+    if (!ActionTarget.empty()) {
+      // If we've got a label, try to find it and jump there.
+      auto I = std::find_if(Stack.rbegin(), Stack.rend(),
+        [&](const Slot &x) {
+        return x.first == ActionTarget;
+      });
+      // If we found the label so pop from there.
+      if (I != Stack.rend()) {
+        Current = I->second.first;
+        SourceLoc = I->second.second;
+        Stack.erase(std::prev(I.base()), Stack.end());
+      }
+    } else if (!Stack.empty()) {
+      // We don't have a label, just pop the last entry.
+      Current = Stack.back().second.first;
+      SourceLoc = Stack.back().second.second;
+      Stack.pop_back();
+    }
+    break;
+  case PSK_Reset:
+    assert(!SectionName);
+    Stack.clear();
+    Current = nullptr;
+    return;
+  case PSK_Set:
+    assert(SectionName);
+    break;
+  }
+  // Setting section "" has no effect
+  if (SectionName && SectionName->getLength()) {
+    Current = SectionName;
+    SourceLoc = PragmaLoc;
+  }
+}
+
+/// \brief Called on well formed \#pragma data_seg().
+void Sema::ActOnPragmaMSDataSeg(SourceLocation PragmaLoc,
+                                PragmaMsStackAction Action,
+                                llvm::StringRef ActionTarget,
+                                StringLiteral *SegmentName) {
+  DataSegStack.Act(PragmaLoc, Action, ActionTarget, SegmentName);
+}
+
+/// \brief Called on well formed \#pragma bss_seg().
+void Sema::ActOnPragmaMSBSSSeg(SourceLocation PragmaLoc,
+                               PragmaMsStackAction Action,
+                               llvm::StringRef ActionTarget,
+                               StringLiteral *SegmentName) {
+  BSSSegStack.Act(PragmaLoc, Action, ActionTarget, SegmentName);
+}
+
+/// \brief Called on well formed \#pragma bss_seg().
+void Sema::ActOnPragmaMSConstSeg(SourceLocation PragmaLoc,
+                                 PragmaMsStackAction Action,
+                                 llvm::StringRef ActionTarget,
+                                 StringLiteral *SegmentName) {
+  ConstSegStack.Act(PragmaLoc, Action, ActionTarget, SegmentName);
+}
+
+/// \brief Called on well formed \#pragma code_seg().
+void Sema::ActOnPragmaMSCodeSeg(SourceLocation PragmaLoc,
+                                PragmaMsStackAction Action,
+                                llvm::StringRef ActionTarget,
+                                StringLiteral *SegmentName) {
+  CodeSegStack.Act(PragmaLoc, Action, ActionTarget, SegmentName);
+}
+
 void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope,
                              SourceLocation PragmaLoc) {
 
Index: lib/Sema/SemaDecl.cpp
===================================================================
--- lib/Sema/SemaDecl.cpp
+++ lib/Sema/SemaDecl.cpp
@@ -7495,6 +7495,11 @@
     }
   }
 
+  if (/*NewFD->isFunctionDefinition() &&*/ CodeSegStack.Current)
+    NewFD->addAttr(MSSegmentAttr::CreateImplicit(
+                   Context, CodeSegStack.Current->getString(),
+                   MSSegmentAttr::CodeSeg, CodeSegStack.SourceLoc));
+
   if (Redeclaration) {
     // NewFD and OldDecl represent declarations that need to be
     // merged.
@@ -8817,6 +8822,23 @@
       Diag(var->getLocation(), diag::note_use_thread_local);
   }
 
+  if (var->isThisDeclarationADefinition() && ActiveTemplateInstantiations.empty()) {
+    if (var->getType().isConstQualified()) {
+      if (ConstSegStack.Current)
+        var->addAttr(MSSegmentAttr::CreateImplicit(
+                     Context, ConstSegStack.Current->getString(),
+                     MSSegmentAttr::ConstSeg, ConstSegStack.SourceLoc));
+    } else if (!var->getInit()) {
+      if (BSSSegStack.Current)
+        var->addAttr(MSSegmentAttr::CreateImplicit(
+                     Context, BSSSegStack.Current->getString(),
+                     MSSegmentAttr::BSSSeg, BSSSegStack.SourceLoc));
+    } else if (DataSegStack.Current)
+      var->addAttr(MSSegmentAttr::CreateImplicit(
+                   Context, DataSegStack.Current->getString(),
+                   MSSegmentAttr::DataSeg, DataSegStack.SourceLoc));
+  }
+
   // All the following checks are C++ only.
   if (!getLangOpts().CPlusPlus) return;