Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===--- 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