Revert "[clang] Add -fc++-abi= flag for specifying which C++ ABI to use"

This reverts commits 683b308 and
8487bfd.

We will go for a more restricted approach that does not give freedom to
everyone to change ABIs on whichever platform.

See the discussion on https://reviews.llvm.org/D85802.

Author: PiJoules

clang/include/clang/AST/ASTContext.h

@@ -39,7 +39,6 @@
 #include "clang/Basic/SanitizerBlacklist.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
-#include "clang/Basic/TargetCXXABI.h"
 #include "clang/Basic/XRayLists.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
@@ -698,11 +697,6 @@ class ASTContext : public RefCountedBase<ASTContext> {
     return FullSourceLoc(Loc,SourceMgr);
   }
 
-  /// Return the C++ ABI kind that should be used. The C++ ABI can be overriden
-  /// at compile time with `-fc++-abi=`. If this is not provided, we instead use
-  /// the default ABI set by the target.
-  TargetCXXABI::Kind getCXXABIKind() const;
-
   /// All comments in this translation unit.
   RawCommentList Comments;
 

clang/include/clang/Basic/DiagnosticDriverKinds.td

@@ -524,6 +524,4 @@ def err_drv_invalid_object_mode : Error<"OBJECT_MODE setting %0 is not recognize
 
 def err_drv_invalid_sve_vector_bits : Error<
   "'-msve-vector-bits' is not supported without SVE enabled">;
-
-def err_invalid_cxx_abi : Error<"invalid C++ ABI name '%0'">;
 }

clang/include/clang/Basic/LangOptions.h

@@ -18,7 +18,6 @@
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Basic/Sanitizers.h"
-#include "clang/Basic/TargetCXXABI.h"
 #include "clang/Basic/Visibility.h"
 #include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/ADT/StringRef.h"
@@ -295,10 +294,6 @@ class LangOptions : public LangOptionsBase {
   /// host code generation.
   std::string OMPHostIRFile;
 
-  /// C++ ABI to compile with, if specified by the frontend through -fc++-abi=.
-  /// This overrides the default ABI used by the target.
-  llvm::Optional<TargetCXXABI::Kind> CXXABI;
-
   /// Indicates whether the front-end is explicitly told that the
   /// input is a header file (i.e. -x c-header).
   bool IsHeaderFile = false;

clang/include/clang/Basic/TargetCXXABI.def

@@ -16,7 +16,6 @@
 #define LLVM_CLANG_BASIC_TARGETCXXABI_H
 
 #include "clang/Basic/LLVM.h"
-#include "llvm/ADT/StringMap.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace clang {
@@ -26,8 +25,105 @@ class TargetCXXABI {
 public:
   /// The basic C++ ABI kind.
   enum Kind {
-#define CXXABI(Name, Str) Name,
-#include "TargetCXXABI.def"
+    /// The generic Itanium ABI is the standard ABI of most open-source
+    /// and Unix-like platforms.  It is the primary ABI targeted by
+    /// many compilers, including Clang and GCC.
+    ///
+    /// It is documented here:
+    ///   http://www.codesourcery.com/public/cxx-abi/
+    GenericItanium,
+
+    /// The generic ARM ABI is a modified version of the Itanium ABI
+    /// proposed by ARM for use on ARM-based platforms.
+    ///
+    /// These changes include:
+    ///   - the representation of member function pointers is adjusted
+    ///     to not conflict with the 'thumb' bit of ARM function pointers;
+    ///   - constructors and destructors return 'this';
+    ///   - guard variables are smaller;
+    ///   - inline functions are never key functions;
+    ///   - array cookies have a slightly different layout;
+    ///   - additional convenience functions are specified;
+    ///   - and more!
+    ///
+    /// It is documented here:
+    ///    http://infocenter.arm.com
+    ///                    /help/topic/com.arm.doc.ihi0041c/IHI0041C_cppabi.pdf
+    GenericARM,
+
+    /// The iOS ABI is a partial implementation of the ARM ABI.
+    /// Several of the features of the ARM ABI were not fully implemented
+    /// in the compilers that iOS was launched with.
+    ///
+    /// Essentially, the iOS ABI includes the ARM changes to:
+    ///   - member function pointers,
+    ///   - guard variables,
+    ///   - array cookies, and
+    ///   - constructor/destructor signatures.
+    iOS,
+
+    /// The iOS 64-bit ABI is follows ARM's published 64-bit ABI more
+    /// closely, but we don't guarantee to follow it perfectly.
+    ///
+    /// It is documented here:
+    ///    http://infocenter.arm.com
+    ///                  /help/topic/com.arm.doc.ihi0059a/IHI0059A_cppabi64.pdf
+    iOS64,
+
+    /// WatchOS is a modernisation of the iOS ABI, which roughly means it's
+    /// the iOS64 ABI ported to 32-bits. The primary difference from iOS64 is
+    /// that RTTI objects must still be unique at the moment.
+    WatchOS,
+
+    /// The generic AArch64 ABI is also a modified version of the Itanium ABI,
+    /// but it has fewer divergences than the 32-bit ARM ABI.
+    ///
+    /// The relevant changes from the generic ABI in this case are:
+    ///   - representation of member function pointers adjusted as in ARM.
+    ///   - guard variables  are smaller.
+    GenericAArch64,
+
+    /// The generic Mips ABI is a modified version of the Itanium ABI.
+    ///
+    /// At the moment, only change from the generic ABI in this case is:
+    ///   - representation of member function pointers adjusted as in ARM.
+    GenericMIPS,
+
+    /// The WebAssembly ABI is a modified version of the Itanium ABI.
+    ///
+    /// The changes from the Itanium ABI are:
+    ///   - representation of member function pointers is adjusted, as in ARM;
+    ///   - member functions are not specially aligned;
+    ///   - constructors and destructors return 'this', as in ARM;
+    ///   - guard variables are 32-bit on wasm32, as in ARM;
+    ///   - unused bits of guard variables are reserved, as in ARM;
+    ///   - inline functions are never key functions, as in ARM;
+    ///   - C++11 POD rules are used for tail padding, as in iOS64.
+    ///
+    /// TODO: At present the WebAssembly ABI is not considered stable, so none
+    /// of these details is necessarily final yet.
+    WebAssembly,
+
+    /// The Fuchsia ABI is a modified version of the Itanium ABI.
+    ///
+    /// The relevant changes from the Itanium ABI are:
+    ///   - constructors and destructors return 'this', as in ARM.
+    Fuchsia,
+
+    /// The XL ABI is the ABI used by IBM xlclang compiler and is a modified
+    /// version of the Itanium ABI.
+    ///
+    /// The relevant changes from the Itanium ABI are:
+    ///   - static initialization is adjusted to use sinit and sterm functions;
+    XL,
+
+    /// The Microsoft ABI is the ABI used by Microsoft Visual Studio (and
+    /// compatible compilers).
+    ///
+    /// FIXME: should this be split into Win32 and Win64 variants?
+    ///
+    /// Only scattered and incomplete official documentation exists.
+    Microsoft
   };
 
 private:
@@ -36,20 +132,7 @@ class TargetCXXABI {
   // audit the users to pass it by reference instead.
   Kind TheKind;
 
-  static const auto &getABIMap() {
-    static llvm::StringMap<Kind> ABIMap = {
-#define CXXABI(Name, Str) {Str, Name},
-#include "TargetCXXABI.def"
-    };
-    return ABIMap;
-  }
-
 public:
-  static Kind getKind(StringRef Name) { return getABIMap().lookup(Name); }
-  static bool isABI(StringRef Name) {
-    return getABIMap().find(Name) != getABIMap().end();
-  }
-
   /// A bogus initialization of the platform ABI.
   TargetCXXABI() : TheKind(GenericItanium) {}
 
@@ -64,11 +147,19 @@ class TargetCXXABI {
   /// Does this ABI generally fall into the Itanium family of ABIs?
   bool isItaniumFamily() const {
     switch (getKind()) {
-#define CXXABI(Name, Str)
-#define ITANIUM_CXXABI(Name, Str) case Name:
-#include "TargetCXXABI.def"
+    case Fuchsia:
+    case GenericAArch64:
+    case GenericItanium:
+    case GenericARM:
+    case iOS:
+    case iOS64:
+    case WatchOS:
+    case GenericMIPS:
+    case WebAssembly:
+    case XL:
       return true;
-    default:
+
+    case Microsoft:
       return false;
     }
     llvm_unreachable("bad ABI kind");
@@ -77,12 +168,20 @@ class TargetCXXABI {
   /// Is this ABI an MSVC-compatible ABI?
   bool isMicrosoft() const {
     switch (getKind()) {
-#define CXXABI(Name, Str)
-#define MICROSOFT_CXXABI(Name, Str) case Name:
-#include "TargetCXXABI.def"
-      return true;
-    default:
+    case Fuchsia:
+    case GenericAArch64:
+    case GenericItanium:
+    case GenericARM:
+    case iOS:
+    case iOS64:
+    case WatchOS:
+    case GenericMIPS:
+    case WebAssembly:
+    case XL:
       return false;
+
+    case Microsoft:
+      return true;
     }
     llvm_unreachable("bad ABI kind");
   }

clang/include/clang/Basic/TargetCXXABI.h

@@ -1371,10 +1371,6 @@ def fno_experimental_relative_cxx_abi_vtables : Flag<["-"], "fno-experimental-re
   Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Do not use the experimental C++ class ABI for classes with virtual tables">;
 
-def fcxx_abi_EQ : Joined<["-"], "fc++-abi=">,
-                  Group<f_clang_Group>, Flags<[CC1Option]>,
-                  HelpText<"C++ ABI to use. This will override the target C++ ABI.">;
-
 def flat__namespace : Flag<["-"], "flat_namespace">;
 def flax_vector_conversions_EQ : Joined<["-"], "flax-vector-conversions=">, Group<f_Group>,
   HelpText<"Enable implicit vector bit-casts">, Values<"none,integer,all">, Flags<[CC1Option]>;

clang/include/clang/Driver/Options.td

@@ -879,15 +879,10 @@ ASTContext::getCanonicalTemplateTemplateParmDecl(
   return CanonTTP;
 }
 
-TargetCXXABI::Kind ASTContext::getCXXABIKind() const {
-  auto Kind = getTargetInfo().getCXXABI().getKind();
-  return getLangOpts().CXXABI.getValueOr(Kind);
-}
-
 CXXABI *ASTContext::createCXXABI(const TargetInfo &T) {
   if (!LangOpts.CPlusPlus) return nullptr;
 
-  switch (getCXXABIKind()) {
+  switch (T.getCXXABI().getKind()) {
   case TargetCXXABI::Fuchsia:
   case TargetCXXABI::GenericARM: // Same as Itanium at this level
   case TargetCXXABI::iOS: