clang-r433403b/include/clang/Basic/TargetCXXABI.h - platform/prebuilts/clang/host/darwin-x86 - Git at Google

 //===--- TargetCXXABI.h - C++ ABI Target Configuration ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Defines the TargetCXXABI class, which abstracts details of the
 /// C++ ABI that we're targeting.
 ///
 //===----------------------------------------------------------------------===//

 #ifndef LLVM_CLANG_BASIC_TARGETCXXABI_H
 #define LLVM_CLANG_BASIC_TARGETCXXABI_H

 #include <map>

 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/ErrorHandling.h"

 namespace clang {

 /// The basic abstraction for the target C++ ABI.
 class TargetCXXABI {
 public:
   /// The basic C++ ABI kind.
   enum Kind {
 #define CXXABI(Name, Str) Name,
 #include "TargetCXXABI.def"
   };

 private:
   // Right now, this class is passed around as a cheap value type.
   // If you add more members, especially non-POD members, please
   // 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;
   }

   static const auto &getSpellingMap() {
     static std::map<Kind, std::string> SpellingMap = {
 #define CXXABI(Name, Str) {Name, Str},
 #include "TargetCXXABI.def"
     };
     return SpellingMap;
   }

 public:
   static Kind getKind(StringRef Name) { return getABIMap().lookup(Name); }
   static const auto &getSpelling(Kind ABIKind) {
     return getSpellingMap().find(ABIKind)->second;
   }
   static bool isABI(StringRef Name) {
     return getABIMap().find(Name) != getABIMap().end();
   }

   // Return true if this target should use the relative vtables C++ ABI by
   // default.
   static bool usesRelativeVTables(const llvm::Triple &T) {
     return T.isOSFuchsia();
   }

   /// A bogus initialization of the platform ABI.
   TargetCXXABI() : TheKind(GenericItanium) {}

   TargetCXXABI(Kind kind) : TheKind(kind) {}

   void set(Kind kind) {
     TheKind = kind;
   }

   Kind getKind() const { return TheKind; }

   // Check that the kind provided by the fc++-abi flag is supported on this
   // target. Users who want to experiment using different ABIs on specific
   // platforms can change this freely, but this function should be conservative
   // enough such that not all ABIs are allowed on all platforms. For example, we
   // probably don't want to allow usage of an ARM ABI on an x86 architecture.
   static bool isSupportedCXXABI(const llvm::Triple &T, Kind Kind) {
     switch (Kind) {
     case GenericARM:
       return T.isARM() || T.isAArch64();

     case iOS:
     case WatchOS:
     case AppleARM64:
       return T.isOSDarwin();

     case Fuchsia:
       return T.isOSFuchsia();

     case GenericAArch64:
       return T.isAArch64();

     case GenericMIPS:
       return T.isMIPS();

     case WebAssembly:
       return T.isWasm();

     case XL:
       return T.isOSAIX();

     case GenericItanium:
       return true;

     case Microsoft:
       return T.isKnownWindowsMSVCEnvironment();
     }
     llvm_unreachable("invalid CXXABI kind");
   };

   /// 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"
       return true;

     default:
       return false;
     }
     llvm_unreachable("bad ABI kind");
   }

   /// 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:
       return false;
     }
     llvm_unreachable("bad ABI kind");
   }

   /// Are member functions differently aligned?
   ///
   /// Many Itanium-style C++ ABIs require member functions to be aligned, so
   /// that a pointer to such a function is guaranteed to have a zero in the
   /// least significant bit, so that pointers to member functions can use that
   /// bit to distinguish between virtual and non-virtual functions. However,
   /// some Itanium-style C++ ABIs differentiate between virtual and non-virtual
   /// functions via other means, and consequently don't require that member
   /// functions be aligned.
   bool areMemberFunctionsAligned() const {
     switch (getKind()) {
     case WebAssembly:
       // WebAssembly doesn't require any special alignment for member functions.
       return false;
     case AppleARM64:
     case Fuchsia:
     case GenericARM:
     case GenericAArch64:
     case GenericMIPS:
       // TODO: ARM-style pointers to member functions put the discriminator in
       //       the this adjustment, so they don't require functions to have any
       //       special alignment and could therefore also return false.
     case GenericItanium:
     case iOS:
     case WatchOS:
     case Microsoft:
     case XL:
       return true;
     }
     llvm_unreachable("bad ABI kind");
   }

   /// Are arguments to a call destroyed left to right in the callee?
   /// This is a fundamental language change, since it implies that objects
   /// passed by value do *not* live to the end of the full expression.
   /// Temporaries passed to a function taking a const reference live to the end
   /// of the full expression as usual.  Both the caller and the callee must
   /// have access to the destructor, while only the caller needs the
   /// destructor if this is false.
   bool areArgsDestroyedLeftToRightInCallee() const {
     return isMicrosoft();
   }

   /// Does this ABI have different entrypoints for complete-object
   /// and base-subobject constructors?
   bool hasConstructorVariants() const {
     return isItaniumFamily();
   }

   /// Does this ABI allow virtual bases to be primary base classes?
   bool hasPrimaryVBases() const {
     return isItaniumFamily();
   }

   /// Does this ABI use key functions?  If so, class data such as the
   /// vtable is emitted with strong linkage by the TU containing the key
   /// function.
   bool hasKeyFunctions() const {
     return isItaniumFamily();
   }

   /// Can an out-of-line inline function serve as a key function?
   ///
   /// This flag is only useful in ABIs where type data (for example,
   /// vtables and type_info objects) are emitted only after processing
   /// the definition of a special "key" virtual function.  (This is safe
   /// because the ODR requires that every virtual function be defined
   /// somewhere in a program.)  This usually permits such data to be
   /// emitted in only a single object file, as opposed to redundantly
   /// in every object file that requires it.
   ///
   /// One simple and common definition of "key function" is the first
   /// virtual function in the class definition which is not defined there.
   /// This rule works very well when that function has a non-inline
   /// definition in some non-header file.  Unfortunately, when that
   /// function is defined inline, this rule requires the type data
   /// to be emitted weakly, as if there were no key function.
   ///
   /// The ARM ABI observes that the ODR provides an additional guarantee:
   /// a virtual function is always ODR-used, so if it is defined inline,
   /// that definition must appear in every translation unit that defines
   /// the class.  Therefore, there is no reason to allow such functions
   /// to serve as key functions.
   ///
   /// Because this changes the rules for emitting type data,
   /// it can cause type data to be emitted with both weak and strong
   /// linkage, which is not allowed on all platforms.  Therefore,
   /// exploiting this observation requires an ABI break and cannot be
   /// done on a generic Itanium platform.
   bool canKeyFunctionBeInline() const {
     switch (getKind()) {
     case AppleARM64:
     case Fuchsia:
     case GenericARM:
     case WebAssembly:
     case WatchOS:
       return false;

     case GenericAArch64:
     case GenericItanium:
     case iOS:   // old iOS compilers did not follow this rule
     case Microsoft:
     case GenericMIPS:
     case XL:
       return true;
     }
     llvm_unreachable("bad ABI kind");
   }

   /// When is record layout allowed to allocate objects in the tail
   /// padding of a base class?
   ///
   /// This decision cannot be changed without breaking platform ABI
   /// compatibility. In ISO C++98, tail padding reuse was only permitted for
   /// non-POD base classes, but that restriction was removed retroactively by
   /// DR 43, and tail padding reuse is always permitted in all de facto C++
   /// language modes. However, many platforms use a variant of the old C++98
   /// rule for compatibility.
   enum TailPaddingUseRules {
     /// The tail-padding of a base class is always theoretically
     /// available, even if it's POD.
     AlwaysUseTailPadding,

     /// Only allocate objects in the tail padding of a base class if
     /// the base class is not POD according to the rules of C++ TR1.
     UseTailPaddingUnlessPOD03,

     /// Only allocate objects in the tail padding of a base class if
     /// the base class is not POD according to the rules of C++11.
     UseTailPaddingUnlessPOD11
   };
   TailPaddingUseRules getTailPaddingUseRules() const {
     switch (getKind()) {
     // To preserve binary compatibility, the generic Itanium ABI has
     // permanently locked the definition of POD to the rules of C++ TR1,
     // and that trickles down to derived ABIs.
     case GenericItanium:
     case GenericAArch64:
     case GenericARM:
     case iOS:
     case GenericMIPS:
     case XL:
       return UseTailPaddingUnlessPOD03;

     // AppleARM64 and WebAssembly use the C++11 POD rules.  They do not honor
     // the Itanium exception about classes with over-large bitfields.
     case AppleARM64:
     case Fuchsia:
     case WebAssembly:
     case WatchOS:
       return UseTailPaddingUnlessPOD11;

     // MSVC always allocates fields in the tail-padding of a base class
     // subobject, even if they're POD.
     case Microsoft:
       return AlwaysUseTailPadding;
     }
     llvm_unreachable("bad ABI kind");
   }

   friend bool operator==(const TargetCXXABI &left, const TargetCXXABI &right) {
     return left.getKind() == right.getKind();
   }

   friend bool operator!=(const TargetCXXABI &left, const TargetCXXABI &right) {
     return !(left == right);
   }
 };

 }  // end namespace clang

 #endif
	//===--- TargetCXXABI.h - C++ ABI Target Configuration ----------- C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file
	/// Defines the TargetCXXABI class, which abstracts details of the
	/// C++ ABI that we're targeting.
	///
	//===----------------------------------------------------------------------===//

	#ifndef LLVM_CLANG_BASIC_TARGETCXXABI_H
	#define LLVM_CLANG_BASIC_TARGETCXXABI_H

	#include <map>

	#include "clang/Basic/LLVM.h"
	#include "llvm/ADT/StringMap.h"
	#include "llvm/ADT/Triple.h"
	#include "llvm/Support/ErrorHandling.h"

	namespace clang {

	/// The basic abstraction for the target C++ ABI.
	class TargetCXXABI {
	public:
	/// The basic C++ ABI kind.
	enum Kind {
	#define CXXABI(Name, Str) Name,
	#include "TargetCXXABI.def"
	};

	private:
	// Right now, this class is passed around as a cheap value type.
	// If you add more members, especially non-POD members, please
	// 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;
	}

	static const auto &getSpellingMap() {
	static std::map<Kind, std::string> SpellingMap = {
	#define CXXABI(Name, Str) {Name, Str},
	#include "TargetCXXABI.def"
	};
	return SpellingMap;
	}

	public:
	static Kind getKind(StringRef Name) { return getABIMap().lookup(Name); }
	static const auto &getSpelling(Kind ABIKind) {
	return getSpellingMap().find(ABIKind)->second;
	}
	static bool isABI(StringRef Name) {
	return getABIMap().find(Name) != getABIMap().end();
	}

	// Return true if this target should use the relative vtables C++ ABI by
	// default.
	static bool usesRelativeVTables(const llvm::Triple &T) {
	return T.isOSFuchsia();
	}

	/// A bogus initialization of the platform ABI.
	TargetCXXABI() : TheKind(GenericItanium) {}

	TargetCXXABI(Kind kind) : TheKind(kind) {}

	void set(Kind kind) {
	TheKind = kind;
	}

	Kind getKind() const { return TheKind; }

	// Check that the kind provided by the fc++-abi flag is supported on this
	// target. Users who want to experiment using different ABIs on specific
	// platforms can change this freely, but this function should be conservative
	// enough such that not all ABIs are allowed on all platforms. For example, we
	// probably don't want to allow usage of an ARM ABI on an x86 architecture.
	static bool isSupportedCXXABI(const llvm::Triple &T, Kind Kind) {
	switch (Kind) {
	case GenericARM:
	return T.isARM() \|\| T.isAArch64();

	case iOS:
	case WatchOS:
	case AppleARM64:
	return T.isOSDarwin();

	case Fuchsia:
	return T.isOSFuchsia();

	case GenericAArch64:
	return T.isAArch64();

	case GenericMIPS:
	return T.isMIPS();

	case WebAssembly:
	return T.isWasm();

	case XL:
	return T.isOSAIX();

	case GenericItanium:
	return true;

	case Microsoft:
	return T.isKnownWindowsMSVCEnvironment();
	}
	llvm_unreachable("invalid CXXABI kind");
	};

	/// 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"
	return true;

	default:
	return false;
	}
	llvm_unreachable("bad ABI kind");
	}

	/// 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:
	return false;
	}
	llvm_unreachable("bad ABI kind");
	}

	/// Are member functions differently aligned?
	///
	/// Many Itanium-style C++ ABIs require member functions to be aligned, so
	/// that a pointer to such a function is guaranteed to have a zero in the
	/// least significant bit, so that pointers to member functions can use that
	/// bit to distinguish between virtual and non-virtual functions. However,
	/// some Itanium-style C++ ABIs differentiate between virtual and non-virtual
	/// functions via other means, and consequently don't require that member
	/// functions be aligned.
	bool areMemberFunctionsAligned() const {
	switch (getKind()) {
	case WebAssembly:
	// WebAssembly doesn't require any special alignment for member functions.
	return false;
	case AppleARM64:
	case Fuchsia:
	case GenericARM:
	case GenericAArch64:
	case GenericMIPS:
	// TODO: ARM-style pointers to member functions put the discriminator in
	// the this adjustment, so they don't require functions to have any
	// special alignment and could therefore also return false.
	case GenericItanium:
	case iOS:
	case WatchOS:
	case Microsoft:
	case XL:
	return true;
	}
	llvm_unreachable("bad ABI kind");
	}

	/// Are arguments to a call destroyed left to right in the callee?
	/// This is a fundamental language change, since it implies that objects
	/// passed by value do not live to the end of the full expression.
	/// Temporaries passed to a function taking a const reference live to the end
	/// of the full expression as usual. Both the caller and the callee must
	/// have access to the destructor, while only the caller needs the
	/// destructor if this is false.
	bool areArgsDestroyedLeftToRightInCallee() const {
	return isMicrosoft();
	}

	/// Does this ABI have different entrypoints for complete-object
	/// and base-subobject constructors?
	bool hasConstructorVariants() const {
	return isItaniumFamily();
	}

	/// Does this ABI allow virtual bases to be primary base classes?
	bool hasPrimaryVBases() const {
	return isItaniumFamily();
	}

	/// Does this ABI use key functions? If so, class data such as the
	/// vtable is emitted with strong linkage by the TU containing the key
	/// function.
	bool hasKeyFunctions() const {
	return isItaniumFamily();
	}

	/// Can an out-of-line inline function serve as a key function?
	///
	/// This flag is only useful in ABIs where type data (for example,
	/// vtables and type_info objects) are emitted only after processing
	/// the definition of a special "key" virtual function. (This is safe
	/// because the ODR requires that every virtual function be defined
	/// somewhere in a program.) This usually permits such data to be
	/// emitted in only a single object file, as opposed to redundantly
	/// in every object file that requires it.
	///
	/// One simple and common definition of "key function" is the first
	/// virtual function in the class definition which is not defined there.
	/// This rule works very well when that function has a non-inline
	/// definition in some non-header file. Unfortunately, when that
	/// function is defined inline, this rule requires the type data
	/// to be emitted weakly, as if there were no key function.
	///
	/// The ARM ABI observes that the ODR provides an additional guarantee:
	/// a virtual function is always ODR-used, so if it is defined inline,
	/// that definition must appear in every translation unit that defines
	/// the class. Therefore, there is no reason to allow such functions
	/// to serve as key functions.
	///
	/// Because this changes the rules for emitting type data,
	/// it can cause type data to be emitted with both weak and strong
	/// linkage, which is not allowed on all platforms. Therefore,
	/// exploiting this observation requires an ABI break and cannot be
	/// done on a generic Itanium platform.
	bool canKeyFunctionBeInline() const {
	switch (getKind()) {
	case AppleARM64:
	case Fuchsia:
	case GenericARM:
	case WebAssembly:
	case WatchOS:
	return false;

	case GenericAArch64:
	case GenericItanium:
	case iOS: // old iOS compilers did not follow this rule
	case Microsoft:
	case GenericMIPS:
	case XL:
	return true;
	}
	llvm_unreachable("bad ABI kind");
	}

	/// When is record layout allowed to allocate objects in the tail
	/// padding of a base class?
	///
	/// This decision cannot be changed without breaking platform ABI
	/// compatibility. In ISO C++98, tail padding reuse was only permitted for
	/// non-POD base classes, but that restriction was removed retroactively by
	/// DR 43, and tail padding reuse is always permitted in all de facto C++
	/// language modes. However, many platforms use a variant of the old C++98
	/// rule for compatibility.
	enum TailPaddingUseRules {
	/// The tail-padding of a base class is always theoretically
	/// available, even if it's POD.
	AlwaysUseTailPadding,

	/// Only allocate objects in the tail padding of a base class if
	/// the base class is not POD according to the rules of C++ TR1.
	UseTailPaddingUnlessPOD03,

	/// Only allocate objects in the tail padding of a base class if
	/// the base class is not POD according to the rules of C++11.
	UseTailPaddingUnlessPOD11
	};
	TailPaddingUseRules getTailPaddingUseRules() const {
	switch (getKind()) {
	// To preserve binary compatibility, the generic Itanium ABI has
	// permanently locked the definition of POD to the rules of C++ TR1,
	// and that trickles down to derived ABIs.
	case GenericItanium:
	case GenericAArch64:
	case GenericARM:
	case iOS:
	case GenericMIPS:
	case XL:
	return UseTailPaddingUnlessPOD03;

	// AppleARM64 and WebAssembly use the C++11 POD rules. They do not honor
	// the Itanium exception about classes with over-large bitfields.
	case AppleARM64:
	case Fuchsia:
	case WebAssembly:
	case WatchOS:
	return UseTailPaddingUnlessPOD11;

	// MSVC always allocates fields in the tail-padding of a base class
	// subobject, even if they're POD.
	case Microsoft:
	return AlwaysUseTailPadding;
	}
	llvm_unreachable("bad ABI kind");
	}

	friend bool operator==(const TargetCXXABI &left, const TargetCXXABI &right) {
	return left.getKind() == right.getKind();
	}

	friend bool operator!=(const TargetCXXABI &left, const TargetCXXABI &right) {
	return !(left == right);
	}
	};

	} // end namespace clang

	#endif