Sema: Add semantic analysis for the C++ ABI stability attributes and whitelist.

[aaron.ballman]

I may have more comments when I catch up on email next week. Just a drive-by as I added myself as reviewer.

include/clang/Basic/Attr.td

1582

No new undocumented attributes, please. Same below.

[pcc]

include/clang/Basic/Attr.td

1582

Yes, sorry, forgot to go back and add documentation for these attributes. Will do. (Reckon it's not worth documenting the feature itself until it actually does something.)

[pcc]

• Add attribute docs

[aaron.ballman]

Missing some attribute-related tests like attaching the attribute to something other than a record, or passing arguments to the attribute.

include/clang/Basic/DiagnosticSemaKinds.td

8376

It would be good to combine these into one Note using %select.

8380

Same for these.

8389

Should this also be a %select, or can you really add either attribute to silence the warning?

lib/Sema/SemaDeclCXX.cpp

4896

Since the attributes do nothing for a non-dynamic class, should the user get a warning if the place the attribute on one (so they know it does nothing)?

[pcc]

• Address review comments

[pcc]

• Add a test for passing arguments to the attribute

[pcc]

Missing some attribute-related tests like attaching the attribute to something other than a record, or passing arguments to the attribute.

Added.

include/clang/Basic/DiagnosticSemaKinds.td

8389

The latter. I gave this a better name to make things clear.

lib/Sema/SemaDeclCXX.cpp

4896

I suppose so; done.

[pcc]

• Claim -funstable-c++-abi-classes= flags

[aaron.ballman]

Attribute side of things looks good, but I leave it to others to decide if the ABI functionality makes sense (it does to me, but I'm no ABI expert).

[mehdi_amini]

LGTM, but I'm not a clang expert, so if Richard or someone else could double-check?

lib/Sema/SemaDeclCXX.cpp

4999

Isn't this correct by the loop which starts with DC = InnermostExternalDC?

[mehdi_amini]

lib/Sema/SemaDeclCXX.cpp

4999

s/correct/already covered/

[pcc]

lib/Sema/SemaDeclCXX.cpp

4999

That loop checks for glob contexts (contexts ending in ** in the ABI list), which have different semantics to regular contexts (ending in *).

[mehdi_amini]

lib/Sema/SemaDeclCXX.cpp

4999

Oh, I misread UnstableABIGlobContexts for UnstableABIContexts...

[rsmith]

include/clang/Basic/DiagnosticSemaKinds.td

8380

How valuable is it to warn on this? It seems like we may want unstable_abi to affect other things than virtual functions in future (for instance, we may want to apply the ARM ABI "return this from constructors" change to classes with unstable ABI, fix some subtle problems in the class layout algorithm, pass certain trivially-copyable structs in registers even though they're not POD for the purpose of layout, ...). If the design intent is that this only affects the virtual call portion of the ABI, then I think it has the wrong name.

(If someone asks for the unstable ABI for the class, and it happens that the unstable ABI is the same as the stable one, I don't think that warrants a warning.)

lib/Sema/SemaDeclCXX.cpp

4891

Can we exit early if no unstable class ABI flags were passed?

4935–4943

Should you also diagnose conflicts with other struct ABI attributes like ms_struct?

5018–5019

-Weverything users will not like this.

[pcc]

• Make -Wunused-stability-attr a non-default flag

include/clang/Basic/DiagnosticSemaKinds.td

8380

I agree that the attribute should permit other struct ABI changes. I also agree that we shouldn't warn by default. We've traditionally warned when an attribute has no effect, but that's probably the wrong decision in this case. I've made this a non-default warning.

lib/Sema/SemaDeclCXX.cpp

4891

We may need to inherit an ABI from a base, even if no flags were passed.

4935–4943

I'd expect those attributes to be orthogonal, e.g. ms_struct + unstable_abi would give you whatever just unstable_abi would give you when targeting Windows.

5018–5019

That's unfortunate, but I think the alternative of creating a category of warnings that -Weverything does not warn on would be worse. My understanding is that as a user-facing flag -Weverything is mostly intended for manual discovery of warnings that Clang produces; as part of that manual process, users can easily add the -Wno-c++-stable-abi flag.

[rjmccall]

lib/Sema/SemaDeclCXX.cpp

4935–4943

No, ms_struct is a request for a specific ABI; this would be a conflict.

[pcc]

lib/Sema/SemaDeclCXX.cpp

4935–4943

Fair point. I think we can handle this by making ms_struct imply stable_abi in the same way that uuid would imply stable_abi. Then there would be a conflict between ms_struct and unstable_abi, and we would infer the correct ABI in implied namespaces.

Are there any other attributes like that? I could only find vecreturn and novtable.

[rjmccall]

lib/Sema/SemaDeclCXX.cpp

4935–4943

I can't think of anything else that's a conflict. vecreturn affects a different aspect of the ABI. novtable is advisory and orthogonal. Alignment/packed attributes should still be honored under an unstable ABI.

[pcc]

• Attributes uuid and ms_struct imply stable_abi. Also improve docs and diagnostics for non-dynamic classes

lib/Sema/SemaDeclCXX.cpp

4935–4943

Thanks, I've added conflicts for ms_struct and uuid.

[rjmccall]

I think this is okay. We can review further if we see other problems.

include/clang/AST/DeclCXX.h

struct DefinitionData {
     bool HasDeclaredCopyAssignmentWithConstParam : 1;
 
     /// \brief Whether this class describes a C++ lambda.
     bool IsLambda : 1;
 
     /// \brief Whether we are currently parsing base specifiers.
     bool IsParsingBaseSpecifiers : 1;
 
+    /// \brief Whether the class uses the unstable ABI.
+    bool IsUnstableABI : 1;
+
     /// \brief The number of base class specifiers in Bases.
     unsigned NumBases;
 
     /// \brief The number of virtual base class specifiers in VBases.
     unsigned NumVBases;
 
     /// \brief Base classes of this class.
     ///
public:
   }
 
   void setIsParsingBaseSpecifiers() { data().IsParsingBaseSpecifiers = true; }
 
   bool isParsingBaseSpecifiers() const {
     return data().IsParsingBaseSpecifiers;
   }
 
+  void setIsUnstableCXXABI() { data().IsUnstableABI = true; }
+  bool isUnstableCXXABI() const {
+    return data().IsUnstableABI;
+  }
+
   /// \brief Sets the base classes of this struct or class.
   void setBases(CXXBaseSpecifier const * const *Bases, unsigned NumBases);
 
   /// \brief Retrieves the number of base classes of this class.
   unsigned getNumBases() const { return data().NumBases; }
 
   typedef llvm::iterator_range<base_class_iterator> base_class_range;
   typedef llvm::iterator_range<base_class_const_iterator>

include/clang/Basic/Attr.td

 def WeakRef : InheritableAttr {
   let Spellings = [GCC<"weakref">];
   // A WeakRef that has an argument is treated as being an AliasAttr
   let Args = [StringArgument<"Aliasee", 1>];
   let Subjects = SubjectList<[Var, Function], ErrorDiag>;
   let Documentation = [Undocumented];
 }
 
+def StableABI : InheritableAttr {
+  let Spellings = [CXX11<"clang", "stable_abi">];
+  let Subjects = SubjectList<[Record]>;
+  let Documentation = [ABIStabilityDocs];
+}
+
+def UnstableABI : InheritableAttr {
+  let Spellings = [CXX11<"clang", "unstable_abi">];
+  let Subjects = SubjectList<[Record]>;
+  let Documentation = [ABIStabilityDocs];
+}
+
 def AnyX86Interrupt : InheritableAttr, TargetSpecificAttr<TargetAnyX86> {
   // NOTE: If you add any additional spellings, ARMInterrupt's,
   // MSP430Interrupt's and MipsInterrupt's spellings must match.
   let Spellings = [GNU<"interrupt">];
   let Subjects = SubjectList<[HasFunctionProto]>;
   let ParseKind = "Interrupt";
   let HasCustomParsing = 1;
   let Documentation = [AnyX86InterruptDocs];

include/clang/Basic/AttrDocs.td

 the ability to distinguish between different versions of the same entity but
 with different ABI versions supported. For example, a newer version of a class
 could have a different set of data members and thus have a different size. Using
 the ``abi_tag`` attribute, it is possible to have different mangled names for
 a global variable of the class type. Therefor, the old code could keep using
 the old manged name and the new code will use the new mangled name with tags.
   }];
 }
+
+def ABIStabilityDocs : Documentation {
+  let Category = DocCatType;
+  let Content = [{
+The ``[[clang::stable_abi]]`` and ``[[clang::unstable_abi]]`` attributes
+control whether Clang has permission to use an unstable ABI for the attached
+class. It is an ODR violation to use ``[[clang::unstable_abi]]`` to define
+the same class in two translation units compiled with different versions of
+Clang. Specifically, mixing different head revisions or major releases is
+not allowed, but mixing different point releases is fine.
+
+Classes inherit ABI from their dynamic base classes (i.e. classes that have
+virtual member functions or virtual bases). It is an error to derive from
+two or more bases if their ABIs are incompatible, or to use an attribute to
+specify an ABI that is incompatible with a base.
+  }];
+}

include/clang/Basic/DiagnosticSemaKinds.td

 
 def err_objc_type_arg_does_not_match_bound : Error<
   "type argument %0 does not satisfy the bound (%1) of type parameter %2">;
 
 def warn_objc_redundant_qualified_class_type : Warning<
   "parameterized class %0 already conforms to the protocols listed; did you "
   "forget a '*'?">, InGroup<ObjCProtocolQualifiers>;
 
+def err_abi_mismatch : Error<
+  "inconsistent ABI for class %0">;
+def note_abi_stability_base : Note<
+  "base %0 uses the %select{stable|unstable}1 ABI">;
+def note_abi_stability_attr : Note<
+  "%select{stable|unstable}0 ABI specified by attribute">;
+
+def warn_unused_abi_stability_attr : Warning<
+  "unused C++ ABI stability attribute on non-dynamic class">,
+  InGroup<DiagGroup<"unused-stability-attr">>;
+def warn_cxx_stable_abi : Warning<
+  "stable C++ ABI was inferred for class %0">,
+  InGroup<DiagGroup<"stable-c++-abi">>, DefaultIgnore;
+def note_add_unstable_abi_file : Note<
+  "add %0 to file %1 to silence this warning">;
+def note_add_abi_stability_attr : Note<
+  "add attribute clang::unstable_abi or clang::stable_abi to silence this warning">;
+
 } // end of sema component.

include/clang/Basic/LangOptions.h

public:
   /// \brief Triples of the OpenMP targets that the host code codegen should
   /// take into account in order to generate accurate offloading descriptors.
   std::vector<llvm::Triple> OMPTargetTriples;
 
   /// \brief Name of the IR file that contains the result of the OpenMP target
   /// host code generation.
   std::string OMPHostIRFile;
 
+  /// List of context names that should use the unstable ABI. This list is
+  /// sorted.
+  std::vector<std::string> UnstableABIContextNames;
+
+  /// If the unstable ABI context names were loaded from a single file, this
+  /// names the file.
+  std::string UnstableABIContextNamesPath;
+
+  /// Returns whether the argument names an unstable ABI context.
+  bool isUnstableABIContextName(const std::string &Name) const;
+
   LangOptions();
 
   // Define accessors/mutators for language options of enumeration type.
 #define LANGOPT(Name, Bits, Default, Description) 
 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
   Type get##Name() const { return static_cast<Type>(Name); } \
   void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }  
 #include "clang/Basic/LangOptions.def"

include/clang/Driver/Options.td

def fno_reroll_loops : Flag<["-"], "fno-reroll-loops">, Group<f_Group>,
   HelpText<"Turn off loop reroller">;
 def ftrigraphs : Flag<["-"], "ftrigraphs">, Group<f_Group>,
   HelpText<"Process trigraph sequences">, Flags<[CC1Option]>;
 def fno_trigraphs : Flag<["-"], "fno-trigraphs">, Group<f_Group>,
   HelpText<"Do not process trigraph sequences">, Flags<[CC1Option]>;
 def funsigned_bitfields : Flag<["-"], "funsigned-bitfields">, Group<f_Group>;
 def funsigned_char : Flag<["-"], "funsigned-char">, Group<f_Group>;
 def fno_unsigned_char : Flag<["-"], "fno-unsigned-char">;
+def funstable_cxx_abi_classes : Flag<["-"], "funstable-c++-abi-classes">,
+  Group<f_Group>, Flags<[CC1Option]>,
+  HelpText<"Use the unstable C++ class ABI for all classes">;
+def funstable_cxx_abi_classes_EQ : Joined<["-"], "funstable-c++-abi-classes=">,
+  Group<f_Group>, Flags<[CC1Option]>,
+  HelpText<"Path to a list of namespaces that automatically use the unstable C++ class ABI">;
 def funwind_tables : Flag<["-"], "funwind-tables">, Group<f_Group>;
 def fuse_cxa_atexit : Flag<["-"], "fuse-cxa-atexit">, Group<f_Group>;
 def fuse_init_array : Flag<["-"], "fuse-init-array">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Use .init_array instead of .ctors">;
 def fno_var_tracking : Flag<["-"], "fno-var-tracking">, Group<clang_ignored_f_Group>;
 def fverbose_asm : Flag<["-"], "fverbose-asm">, Group<f_Group>;
 def fvisibility_EQ : Joined<["-"], "fvisibility=">, Group<f_Group>,
   HelpText<"Set the default symbol visibility for all global declarations">;

include/clang/Sema/Sema.h

static bool TooManyArguments(size_t NumParams, size_t NumArgs,
     if (NumArgs > 0 && PartialOverloading)
       return NumArgs + 1 > NumParams; // If so, we view as an extra argument.
     return NumArgs > NumParams;
   }
 
   // Emitting members of dllexported classes is delayed until the class
   // (including field initializers) is fully parsed.
   SmallVector<CXXRecordDecl*, 4> DelayedDllExportClasses;
+
+  /// A set of contexts that imply the unstable ABI for that context and any
+  /// enclosed contexts, excluding named namespaces.
+  llvm::DenseSet<DeclContext *> UnstableABIContexts;
+
+  /// A set of contexts that imply the unstable ABI for that context and any
+  /// enclosed contexts, including namespaces.
+  llvm::DenseSet<DeclContext *> UnstableABIGlobContexts;
+
+  /// Determine the ABI for this class using its attributes, bases and implicit
+  /// contexts. Check for conflicts between bases or between a base and an
+  /// attribute. Set the class's isUnstableCXXABI() flag according to the
+  /// result.
+  void checkClassABI(CXXRecordDecl *RD);
 };
 
 /// \brief RAII object that enters a new expression evaluation context.
 class EnterExpressionEvaluationContext {
   Sema &Actions;
 
 public:
   EnterExpressionEvaluationContext(Sema &Actions,

lib/AST/DeclCXX.cpp

: UserDeclaredConstructor(false), UserDeclaredSpecialMembers(0),
       DefaultedDefaultConstructorIsConstexpr(true),
       HasConstexprDefaultConstructor(false),
       HasNonLiteralTypeFieldsOrBases(false), ComputedVisibleConversions(false),
       UserProvidedDefaultConstructor(false), DeclaredSpecialMembers(0),
       ImplicitCopyConstructorHasConstParam(true),
       ImplicitCopyAssignmentHasConstParam(true),
       HasDeclaredCopyConstructorWithConstParam(false),
       HasDeclaredCopyAssignmentWithConstParam(false), IsLambda(false),
-      IsParsingBaseSpecifiers(false), NumBases(0), NumVBases(0), Bases(),
-      VBases(), Definition(D), FirstFriend() {}
+      IsParsingBaseSpecifiers(false), IsUnstableABI(false), NumBases(0),
+      NumVBases(0), Bases(), VBases(), Definition(D), FirstFriend() {}
 
 CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getBasesSlowCase() const {
   return Bases.get(Definition->getASTContext().getExternalSource());
 }
 
 CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getVBasesSlowCase() const {
   return VBases.get(Definition->getASTContext().getExternalSource());
 }

lib/Basic/LangOptions.cpp

 
 bool LangOptions::isNoBuiltinFunc(const char *Name) const {
   StringRef FuncName(Name);
   for (unsigned i = 0, e = NoBuiltinFuncs.size(); i != e; ++i)
     if (FuncName.equals(NoBuiltinFuncs[i]))
       return true;
   return false;
 }
+
+bool LangOptions::isUnstableABIContextName(const std::string &Name) const {
+  return std::binary_search(UnstableABIContextNames.begin(),
+                            UnstableABIContextNames.end(), Name);
+}

lib/Driver/Tools.cpp

#endif
   // Host-side cuda compilation receives device-side outputs as Inputs[1...].
   // Include them with -fcuda-include-gpubinary.
   if (IsCuda && Inputs.size() > 1)
     for (auto I = std::next(Inputs.begin()), E = Inputs.end(); I != E; ++I) {
       CmdArgs.push_back("-fcuda-include-gpubinary");
       CmdArgs.push_back(I->getFilename());
     }
 
+  // Add unstable C++ ABI flags.
+  if (Args.hasArg(options::OPT_funstable_cxx_abi_classes))
+    CmdArgs.push_back("-funstable-c++-abi-classes");
+
+  for (const Arg *A :
+       Args.filtered(options::OPT_funstable_cxx_abi_classes_EQ)) {
+    CmdArgs.push_back(Args.MakeArgString(
+        std::string("-funstable-c++-abi-classes=") + A->getValue()));
+    CmdArgs.push_back(
+        Args.MakeArgString(std::string("-fdepfile-entry=") + A->getValue()));
+  }
+
   // Finally add the compile command to the compilation.
   if (Args.hasArg(options::OPT__SLASH_fallback) &&
       Output.getType() == types::TY_Object &&
       (InputType == types::TY_C || InputType == types::TY_CXX)) {
     auto CLCommand =
         getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput);
     C.addCommand(llvm::make_unique<FallbackCommand>(
         JA, *this, Exec, CmdArgs, Inputs, std::move(CLCommand)));

lib/Frontend/CompilerInvocation.cpp

if (value == "default") {
     return ProtectedVisibility;
   }
 
   diags.Report(diag::err_drv_invalid_value)
     << arg->getAsString(args) << value;
   return DefaultVisibility;
 }
 
+static void parseUnstableABIContextNameFile(std::vector<std::string> &Names,
+                                            StringRef Path,
+                                            DiagnosticsEngine &Diags) {
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> FileOrErr =
+      llvm::MemoryBuffer::getFile(Path);
+  if (std::error_code EC = FileOrErr.getError()) {
+    Diags.Report(diag::err_fe_error_opening) << Path << EC.message();
+    return;
+  }
+
+  SmallVector<StringRef, 16> Lines;
+  SplitString(FileOrErr.get()->getBuffer(), Lines, "\n\r");
+  for (auto Line : Lines) {
+    auto Idx = Line.find('#');
+    if (Idx != StringRef::npos)
+      Line = Line.substr(0, Idx);
+
+    Line = Line.trim();
+    if (!Line.empty())
+      Names.push_back(Line);
+  }
+}
+
 static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
                           const TargetOptions &TargetOpts,
                           DiagnosticsEngine &Diags) {
   // FIXME: Cleanup per-file based stuff.
   LangStandard::Kind LangStd = LangStandard::lang_unspecified;
   if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
     LangStd = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
 #define LANGSTANDARD(id, name, desc, features) \
#include "clang/Frontend/LangStandards.def"
 
   // Parse -fsanitize= arguments.
   parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
                       Diags, Opts.Sanitize);
   // -fsanitize-address-field-padding=N has to be a LangOpt, parse it here.
   Opts.SanitizeAddressFieldPadding =
       getLastArgIntValue(Args, OPT_fsanitize_address_field_padding, 0, Diags);
   Opts.SanitizerBlacklistFiles = Args.getAllArgValues(OPT_fsanitize_blacklist);
+
+  if (Args.hasArg(OPT_funstable_cxx_abi_classes))
+    Opts.UnstableABIContextNames.push_back("**");
+
+  unsigned NumFiles = 0;
+  for (const Arg *A : Args.filtered(OPT_funstable_cxx_abi_classes_EQ)) {
+    ++NumFiles;
+    Opts.UnstableABIContextNamesPath = A->getValue();
+    parseUnstableABIContextNameFile(Opts.UnstableABIContextNames, A->getValue(),
+                                    Diags);
+  }
+
+  std::sort(Opts.UnstableABIContextNames.begin(),
+            Opts.UnstableABIContextNames.end());
+
+  if (NumFiles != 1)
+    Opts.UnstableABIContextNamesPath.clear();
 }
 
 static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
                                   FileManager &FileMgr,
                                   DiagnosticsEngine &Diags) {
   using namespace options;
   Opts.ImplicitPCHInclude = Args.getLastArgValue(OPT_include_pch);
   Opts.ImplicitPTHInclude = Args.getLastArgValue(OPT_include_pth);

lib/Sema/Sema.cpp

Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
   Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context);
 
   ExprEvalContexts.emplace_back(PotentiallyEvaluated, 0, false, nullptr, false);
 
   FunctionScopes.push_back(new FunctionScopeInfo(Diags));
 
   // Initilization of data sharing attributes stack for OpenMP
   InitDataSharingAttributesStack();
+
+  if (LangOpts.isUnstableABIContextName("*"))
+    UnstableABIContexts.insert(ctxt.getTranslationUnitDecl());
+  if (LangOpts.isUnstableABIContextName("**"))
+    UnstableABIGlobContexts.insert(ctxt.getTranslationUnitDecl());
 }
 
 void Sema::addImplicitTypedef(StringRef Name, QualType T) {
   DeclarationName DN = &Context.Idents.get(Name);
   if (IdResolver.begin(DN) == IdResolver.end())
     PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope);
 }
 

lib/Sema/SemaDeclAttr.cpp

case AttributeList::AT_SwiftErrorResult:
     handleParameterABIAttr(S, D, Attr, ParameterABI::SwiftErrorResult);
     break;
   case AttributeList::AT_SwiftIndirectResult:
     handleParameterABIAttr(S, D, Attr, ParameterABI::SwiftIndirectResult);
     break;
   case AttributeList::AT_InternalLinkage:
     handleInternalLinkageAttr(S, D, Attr);
     break;
+  case AttributeList::AT_StableABI:
+    handleSimpleAttribute<StableABIAttr>(S, D, Attr);
+    break;
+  case AttributeList::AT_UnstableABI:
+    handleSimpleAttribute<UnstableABIAttr>(S, D, Attr);
+    break;
 
   // Microsoft attributes:
   case AttributeList::AT_MSNoVTable:
     handleSimpleAttribute<MSNoVTableAttr>(S, D, Attr);
     break;
   case AttributeList::AT_MSStruct:
     handleSimpleAttribute<MSStructAttr>(S, D, Attr);
     break;

lib/Sema/SemaDeclCXX.cpp

Diag(BaseTemplateSpec->getLocation(),
         << BaseTemplateSpec;
   } else {
     Diag(BaseTemplateSpec->getPointOfInstantiation(),
            diag::note_template_class_instantiation_was_here)
         << BaseTemplateSpec;
   }
 }
 
+void Sema::checkClassABI(CXXRecordDecl *Record) {
+  // This can only be done accurately for non-dependent types, as the
+  // determination uses the class's bases, which may be dependent.
+  if (Record->isDependentType())
+    return;
+
+  // No need to do this for non-dynamic classes.
+  if (!Record->isDynamicClass()) {
+    if (auto *A = Record->getAttr<StableABIAttr>())
+      Diag(A->getLocation(), diag::warn_unused_abi_stability_attr);
+    if (auto *A = Record->getAttr<UnstableABIAttr>())
+      Diag(A->getLocation(), diag::warn_unused_abi_stability_attr);
+    return;
+  }
+
+  // First, see if this class inherits an ABI from a dynamic base class. If the
+  // bases disagree on which ABI to use, diagnose.
+  bool InheritsABI = false;
+  bool InheritedABIIsUnstable;
+  CXXRecordDecl *InheritedABIFrom;
+
+  for (CXXBaseSpecifier &B : Record->bases()) {
+    auto Base = B.getType()->getAsCXXRecordDecl();
+    // Base can be null in invalid programs (see PR16677).
+    if (!Base || !Base->isDynamicClass())
+      continue;
+    if (InheritsABI) {
+      if (Base->isUnstableCXXABI() != InheritedABIIsUnstable) {
+        Diag(Record->getLocation(), diag::err_abi_mismatch) << Record;
+        CXXRecordDecl *Stable =
+            InheritedABIIsUnstable ? Base : InheritedABIFrom;
+        CXXRecordDecl *Unstable =
+            InheritedABIIsUnstable ? InheritedABIFrom : Base;
+        Diag(Stable->getLocation(), diag::note_abi_stability_base)
+            << Stable << /*Unstable=*/false;
+        Diag(Unstable->getLocation(), diag::note_abi_stability_base)
+            << Unstable << /*Unstable=*/true;
+      }
+    } else {
+      InheritsABI = true;
+      InheritedABIIsUnstable = Base->isUnstableCXXABI();
+      InheritedABIFrom = Base;
+    }
+  }
+
+  bool HasStableAttr = Record->hasAttr<StableABIAttr>();
+  bool HasUnstableAttr = Record->hasAttr<UnstableABIAttr>();
+  if (HasStableAttr && HasUnstableAttr) {
+    Diag(Record->getLocation(), diag::err_abi_mismatch) << Record;
+    Diag(Record->getAttr<StableABIAttr>()->getLocation(),
+         diag::note_abi_stability_attr) << /*Unstable=*/false;
+    Diag(Record->getAttr<UnstableABIAttr>()->getLocation(),
+         diag::note_abi_stability_attr) << /*Unstable=*/true;
+  }
+
+  // If the class inherited an ABI, the inherited ABI must agree with the
+  // class's attributes.
+  if (HasStableAttr && InheritsABI && InheritedABIIsUnstable) {
+    Diag(Record->getLocation(), diag::err_abi_mismatch) << Record;
+    Diag(InheritedABIFrom->getLocation(), diag::note_abi_stability_base)
+        << InheritedABIFrom << /*Unstable=*/true;
+    Diag(Record->getAttr<StableABIAttr>()->getLocation(),
+         diag::note_abi_stability_attr) << /*Unstable=*/false;
+  }
+  if (HasUnstableAttr && InheritsABI && !InheritedABIIsUnstable) {
+    Diag(Record->getLocation(), diag::err_abi_mismatch) << Record;
+    Diag(InheritedABIFrom->getLocation(), diag::note_abi_stability_base)
+        << InheritedABIFrom << /*Unstable=*/false;
+    Diag(Record->getAttr<UnstableABIAttr>()->getLocation(),
+         diag::note_abi_stability_attr) << /*Unstable=*/true;
+  }
+
+  if (HasStableAttr) {
+    return;
+  } else if (HasUnstableAttr) {
+    Record->setIsUnstableCXXABI();
+    return;
+  } else if (InheritsABI) {
+    if (InheritedABIIsUnstable)
+      Record->setIsUnstableCXXABI();
+    return;
+  }
+
+  // This class's ABI is not inherited or based on an attribute. Infer it from
+  // context.
+  if (UnstableABIContexts.empty() &&
+      UnstableABIGlobContexts.empty() &&
+      Diags.isIgnored(diag::warn_cxx_stable_abi, Record->getLocation()))
+    return;
+
+  // Find the innermost context not enclosed by an anonymous namespace, which
+  // is the context enclosing the outermost anonymous namespace.
+  DeclContext *NSContext = Record->getEnclosingNamespaceContext();
+  DeclContext *OutermostAnonNS = nullptr;
+  DeclContext *DC = NSContext;
+  while (DC) {
+    if (DC->isNamespace() && cast<NamespaceDecl>(DC)->isAnonymousNamespace())
+      OutermostAnonNS = DC;
+    DC = DC->getParent();
+  }
+  DeclContext *InnermostExternalDC = NSContext;
+  if (OutermostAnonNS)
+    InnermostExternalDC = OutermostAnonNS->getParent();
+  InnermostExternalDC = InnermostExternalDC->getPrimaryContext();
+
+  // Check if that context is in our set of contexts.
+  if (UnstableABIContexts.count(InnermostExternalDC)) {
+    Record->setIsUnstableCXXABI();
+    return;
+  }
+
+  // Check if that context or an enclosing context is in our set of glob
+  // contexts.
+  DC = InnermostExternalDC;
+  while (1) {
+    if (UnstableABIGlobContexts.count(DC)) {
+      Record->setIsUnstableCXXABI();
+      return;
+    }
+    DC = DC->getParent();
+    if (!DC)
+      break;
+    DC = DC->getPrimaryContext();
+  }
+
+  // Okay, we have inferred the stable ABI for this record. Warn if this is a
+  // non-system header.
+  if (!SourceMgr.isInSystemHeader(Record->getLocation())) {
+    Diag(Record->getLocation(), diag::warn_cxx_stable_abi)
+        << Record;
+    if (!getLangOpts().UnstableABIContextNamesPath.empty()) {
+      Diag(Record->getLocation(), diag::note_add_unstable_abi_file)
+          << InnermostExternalDC
+          << getLangOpts().UnstableABIContextNamesPath;
+    } else {
+      Diag(Record->getLocation(), diag::note_add_abi_stability_attr);
+    }
+  }
+}
+
 /// \brief Perform semantic checks on a class definition that has been
 /// completing, introducing implicitly-declared members, checking for
 /// abstract types, etc.
 void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
   if (!Record)
     return;
 
   if (Record->isAbstract() && !Record->isInvalidDecl()) {
void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
   //   constructors from different classes.
   // - The lazy declaration of the other implicit constructors is so as to not
   //   waste space and performance on classes that are not meant to be
   //   instantiated (e.g. meta-functions). This doesn't apply to classes that
   //   have inheriting constructors.
   DeclareInheritingConstructors(Record);
 
   checkClassLevelDLLAttribute(Record);
+
+  checkClassABI(Record);
 }
 
 /// Look up the special member function that would be called by a special
 /// member function for a subobject of class type.
 ///
 /// \param Class The class type of the subobject.
 /// \param CSM The kind of special member function.
 /// \param FieldQuals If the subobject is a field, its cv-qualifiers.
if (PrevNS && IsInline != PrevNS->isInline())
       DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, NamespaceLoc, II,
                                       &IsInline, PrevNS);
   }
   
   NamespaceDecl *Namespc = NamespaceDecl::Create(Context, CurContext, IsInline,
                                                  StartLoc, Loc, II, PrevNS);
   if (IsInvalid)
     Namespc->setInvalidDecl();
-  
+  // See if this namespace should be added to the set of unstable ABI contexts.
+  if ((!PrevNS || IsStd) && II &&
+      !getLangOpts().UnstableABIContextNames.empty()) {
+    NamespaceDecl *FirstNS = Namespc->getOriginalNamespace();
+    std::string Name = Namespc->getQualifiedNameAsString();
+    if (getLangOpts().isUnstableABIContextName(Name + "::*"))
+      UnstableABIContexts.insert(FirstNS);
+    else if (getLangOpts().isUnstableABIContextName(Name + "::**"))
+      UnstableABIGlobContexts.insert(FirstNS);
+  }
+
   ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList);
 
   // FIXME: Should we be merging attributes?
   if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
     PushNamespaceVisibilityAttr(Attr, Loc);
 
   if (IsStd)
     StdNamespace = Namespc;

test/Driver/funstable-cxx-abi.cpp

+// RUN: %clang -funstable-c++-abi-classes -### %s 2>&1 | FileCheck -check-prefix=CLASSES %s
+// CLASSES: "-funstable-c++-abi-classes"
+
+// RUN: %clang -funstable-c++-abi-classes=foo.txt -### %s 2>&1 | FileCheck -check-prefix=CLASSES-ARG %s
+// CLASSES-ARG: "-funstable-c++-abi-classes=foo.txt"
+// CLASSES-ARG: "-fdepfile-entry=foo.txt"

test/SemaCXX/Inputs/unstable-abi-list-global1.txt

+*

test/SemaCXX/Inputs/unstable-abi-list-global2.txt

+**

test/SemaCXX/Inputs/unstable-abi-list.txt

+unstable_glob::**
+std::*

test/SemaCXX/attr-stability.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -DABI=stable_abi %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -DABI=unstable_abi %s
+
+int i [[clang::ABI]]; // expected-warning {{attribute only applies to struct, union or class}}
+typedef int t [[clang::ABI]]; // expected-warning {{attribute only applies to struct, union or class}}
+[[clang::ABI]] void f(); // expected-warning {{attribute only applies to struct, union or class}}
+void f() [[clang::ABI]]; // expected-error {{attribute cannot be applied to types}}
+
+struct [[clang::ABI]] s1 { // expected-warning {{unused C++ ABI stability attribute on non-dynamic class}}
+  int i [[clang::ABI]]; // expected-warning {{attribute only applies to struct, union or class}}
+  [[clang::ABI]] void f(); // expected-warning {{attribute only applies to struct, union or class}}
+};
+
+struct [[clang::ABI(1)]] s2 { // expected-error {{attribute takes no arguments}}
+  virtual void f();
+};

test/SemaCXX/unstable-cxx-abi-global1.cpp

+// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -verify -funstable-c++-abi-classes=%S/Inputs/unstable-abi-list-global1.txt
+
+namespace foo {
+
+struct stable { // expected-note {{base 'stable' uses the stable ABI}}
+  virtual void f();
+};
+
+}
+
+struct unstable { // expected-note {{base 'unstable' uses the unstable ABI}}
+  virtual void f();
+};
+
+struct mixed_bases : foo::stable, unstable {};  // expected-error {{inconsistent ABI for class 'mixed_bases'}}

test/SemaCXX/unstable-cxx-abi-global2.cpp

+// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -verify -funstable-c++-abi-classes
+// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -verify -funstable-c++-abi-classes=%S/Inputs/unstable-abi-list-global2.txt
+
+namespace foo {
+
+struct unstable { // expected-note {{base 'unstable' uses the unstable ABI}}
+  virtual void f();
+};
+
+}
+
+struct unstable {
+  virtual void f();
+};
+
+struct [[clang::stable_abi]] stable { // expected-note {{base 'stable' uses the stable ABI}}
+  virtual void f();
+};
+
+struct unstable_derived : foo::unstable, unstable {};
+struct mixed_bases : foo::unstable, stable {}; // expected-error {{inconsistent ABI for class 'mixed_bases'}}

test/SemaCXX/unstable-cxx-abi-warning.cpp

+// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -verify -Wstable-c++-abi
+// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -verify -Wstable-c++-abi -funstable-c++-abi-classes=%S/Inputs/unstable-abi-list.txt -funstable-c++-abi-classes=%S/Inputs/unstable-abi-list-global1.txt
+
+namespace ns {
+
+class non_dynamic {};
+
+class dynamic { // expected-warning {{stable C++ ABI was inferred for class 'dynamic'}} expected-note {{add attribute clang::unstable_abi or clang::stable_abi to silence this warning}}
+  virtual void f();
+};
+
+}

test/SemaCXX/unstable-cxx-abi.cpp

+// RUN: %clang_cc1 %s -std=c++11 -fsyntax-only -verify -funstable-c++-abi-classes=%S/Inputs/unstable-abi-list.txt -Wstable-c++-abi
+
+struct stable { // expected-note 3{{base 'stable' uses the stable ABI}} expected-warning {{stable C++ ABI was inferred for class 'stable'}} expected-note-re {{add the global namespace to file {{.*}} to silence this warning}}
+  virtual void f();
+};
+struct [[clang::unstable_abi]] unstable { // expected-note 3{{base 'unstable' uses the unstable ABI}}
+  virtual void f();
+};
+
+struct
+[[clang::stable_abi]] // expected-note {{stable ABI specified by attribute}}
+[[clang::unstable_abi]] // expected-note {{unstable ABI specified by attribute}}
+bistable { // expected-error {{inconsistent ABI for class 'bistable'}}
+  virtual void f();
+};
+
+struct mixed_bases : stable, unstable {}; // expected-error {{inconsistent ABI for class 'mixed_bases'}}
+struct mixed_base_vbase : stable, virtual unstable {}; // expected-error {{inconsistent ABI for class 'mixed_base_vbase'}}
+
+struct
+[[clang::unstable_abi]] // expected-note {{unstable ABI specified by attribute}}
+mixed_attr_base : stable { // expected-error {{inconsistent ABI for class 'mixed_attr_base'}}
+};
+
+struct
+[[clang::stable_abi]] // expected-note {{stable ABI specified by attribute}}
+mixed_attr_base2 : unstable { // expected-error {{inconsistent ABI for class 'mixed_attr_base2'}}
+};
+
+namespace std {
+
+struct unstable {
+  virtual void f();
+};
+
+}
+
+namespace std {
+
+namespace {
+
+struct unstable2 {
+  virtual void f();
+};
+
+namespace foo {
+
+struct unstable {
+  virtual void f();
+};
+
+}
+
+}
+
+namespace bar {
+
+struct stable { // expected-warning {{stable C++ ABI was inferred for class 'stable'}} expected-note-re {{add namespace 'std::bar' to file {{.*}} to silence this warning}}
+  virtual void f();
+};
+
+}
+
+struct non_dynamic {
+  struct unstable3 {
+    virtual void f();
+  };
+  void mf() {
+    struct unstable4 {
+      virtual void f();
+    };
+    struct unstable_derived : unstable, unstable4 {};
+  }
+};
+
+void f() {
+  struct unstable5 {
+    virtual void f();
+  };
+  struct unstable_derived : unstable, unstable5 {};
+}
+
+}
+
+struct stable2 : std::non_dynamic { // expected-warning {{stable C++ ABI was inferred for class 'stable2'}}  expected-note-re {{add the global namespace to file {{.*}} to silence this warning}}
+  virtual void f();
+};
+
+struct unstable_derived : unstable, std::unstable2, std::foo::unstable,
+                          std::non_dynamic::unstable3 {};
+struct stable_derived : stable, std::bar::stable, stable2 {};