TargetInfo.h

Go to the documentation of this file.

//===----- TargetInfo.h - Target ABI information ------------------- 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
/// Target-specific ABI information and factory functions.
///
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_ABI_TARGETINFO_H
#define LLVM_ABI_TARGETINFO_H
 
#include "llvm/ABI/FunctionInfo.h"
#include "llvm/ABI/Types.h"
#include "llvm/Support/Compiler.h"
#include <cassert>
#include <memory>
 
namespace llvm {
namespace abi {
 
enum RecordArgABI {
  /// Pass it using the normal C aggregate rules for the ABI, potentially
  /// introducing extra copies and passing some or all of it in registers.
  RAA_Default = 0,
 
  /// Pass it on the stack using its defined layout.  The argument must be
  /// evaluated directly into the correct stack position in the arguments area,
  /// and the call machinery must not move it or introduce extra copies.
  RAA_DirectInMemory,
 
  /// Pass it as a pointer to temporary memory.
  RAA_Indirect
};
 
/// Flags controlling ABI compatibility behaviour that applies to every target.
/// Targets with compatibility flags of their own extend this with a derived
/// structure.
struct ABICompatInfo {
  /// Whether a matrix type may be the base type of a homogeneous aggregate.
  bool IsMatrixHA : 1;
 
  ABICompatInfo() : IsMatrixHA(true) {}
};
 
/// Flags controlling X86-specific ABI compatibility behaviour.
struct X86ABICompatInfo : ABICompatInfo {
  bool PassInt128VectorsInMem : 1;
  bool ReturnCXXRecordGreaterThan128InMem : 1;
  bool ClassifyIntegerMMXAsSSE : 1;
  bool HonorsRevision98 : 1;
  bool Clang11Compat : 1;
  bool ClassifyUnnamedBitFields : 1;
 
  X86ABICompatInfo()
      : PassInt128VectorsInMem(true), ReturnCXXRecordGreaterThan128InMem(true),
        ClassifyIntegerMMXAsSSE(true), HonorsRevision98(true),
        Clang11Compat(true), ClassifyUnnamedBitFields(true) {}
};
 
class TargetInfo {
protected:
  TypeBuilder &TB;
 
public:
  explicit TargetInfo(TypeBuilder &Builder) : TB(Builder) {}
 
  virtual ~TargetInfo() = default;
 
  /// Populate FI with the target's ABI-lowering decisions for each argument
  /// and return value.
  virtual void computeInfo(FunctionInfo &FI) const = 0;
  virtual bool isPassByRef(const Type *Ty) const { return false; }
 
  /// Return this target's ABI compatibility flags. Targets with extra flags
  /// store a derived object and return that as an ABICompatInfo reference.
  virtual const ABICompatInfo &getABICompatInfo() const = 0;
 
  /// Address space in which indirect arguments are allocated (the target's
  /// alloca/stack space).
  virtual unsigned getAllocaAddrSpace() const { return 0; }
 
  /// Address space of the sret pointer of a record that cannot be passed in
  /// registers (e.g. one with a non-trivial copy constructor or destructor).
  virtual unsigned getSRetAddrSpace() const { return 0; }
 
  /// Whether the target has a 128-bit integer type. Default true.
  virtual bool hasInt128Type() const { return true; }
 
  /// Width of `long long` in bits. Default 64.
  virtual unsigned getLongLongWidth() const { return 64; }
 
  /// Alignment of the widest integer the target's data layout gives an
  /// alignment to. An integer wider than that one is aligned to this. Default
  /// 16, the alignment of i128 on AArch64 and x86-64.
  virtual llvm::Align getMaxIntegerAlign() const { return llvm::Align(16); }
 
protected:
  LLVM_ABI RecordArgABI getRecordArgABI(const RecordType *RT) const;
  LLVM_ABI RecordArgABI getRecordArgABI(const Type *Ty) const;
  LLVM_ABI bool isPromotableInteger(const IntegerType *IT) const;
 
  /// Bit width above which a _BitInt cannot stay in registers.
  unsigned getBitIntRegThreshold() const {
    return hasInt128Type() ? 128 : getLongLongWidth();
  }
  LLVM_ABI ArgInfo getNaturalAlignIndirect(const Type *Ty, unsigned AddrSpace,
                                           bool ByVal = true) const;
 
  /// An array of \p NumBytes i8 elements, the padding element of a
  /// coerce-and-expand type.
  LLVM_ABI const Type *getI8Array(uint64_t NumBytes) const;
 
  /// In-memory form of \p Ty. A record becomes one field list: non-empty
  /// bases and fields in offset order. Padding is an array of i8. The result
  /// is packed when a member offset or the record size is not a multiple of
  /// the converted member alignment, and then every gap is an explicit array.
  /// Any other record has an array only where that alignment does not already
  /// produce the gap, and for the tail that alignment is capped at
  /// getMaxIntegerAlign(). A record with a virtual base has no layout here. An
  /// array is rebuilt when its element type changes. Any other type is
  /// returned unchanged.
  LLVM_ABI const Type *convertTypeForMem(const Type *Ty) const;
 
  /// A record with one field per element of \p Elems, each at offset 0.
  /// \p Packed selects a packed record, which has no alignment padding
  /// between fields.
  LLVM_ABI const Type *getStructOfTypes(ArrayRef<const Type *> Elems,
                                        bool Packed) const;
 
  LLVM_ABI bool isAggregateTypeForABI(const Type *Ty) const;
 
  /// If Ty is a transparent union, return its first field type; otherwise
  /// return Ty unchanged.
  LLVM_ABI const Type *useFirstFieldIfTransparentUnion(const Type *Ty) const;
 
  /// Returns the scalar a single-element struct reduces to, else null.
  LLVM_ABI const Type *isSingleElementStruct(const Type *Ty) const;
 
  /// Apply rules for classifying return types that are common to all targets.
  LLVM_ABI bool maybeCommonClassifyReturnType(FunctionInfo &FI) const;
 
  /// Return true if \p Ty is a valid base type for a homogeneous aggregate.
  virtual bool isHomogeneousAggregateBaseType(const Type *Ty) const {
    return false;
  }
 
  /// Return true if a homogeneous aggregate with \p Members copies of \p Base
  /// is small enough to be passed in registers for this ABI.
  virtual bool isHomogeneousAggregateSmallEnough(const Type *Base,
                                                 uint64_t Members) const {
    return false;
  }
 
  /// Return true if zero-length bitfields should be ignored when deciding
  /// whether an aggregate is homogeneous.
  virtual bool isZeroLengthBitfieldPermittedInHomogeneousAggregate() const {
    return false;
  }
 
  /// Return true if the C++ ABI permits \p RT to be a homogeneous aggregate.
  virtual bool isPermittedToBeHomogeneousAggregate(const RecordType *RT) const {
    return true;
  }
 
  /// Return true if \p Ty is an ELFv2-style homogeneous aggregate. \p Base is
  /// set to the base element type and \p Members to the number of base
  /// elements.
  LLVM_ABI bool isHomogeneousAggregate(const Type *Ty, const Type *&Base,
                                       uint64_t &Members) const;
};
 
LLVM_ABI std::unique_ptr<TargetInfo> createBPFTargetInfo(TypeBuilder &TB);
 
LLVM_ABI std::unique_ptr<TargetInfo>
createAMDGPUTargetInfo(TypeBuilder &TB,
                       bool CoerceGenericPtrArgToGlobal = false);
 
LLVM_ABI std::unique_ptr<TargetInfo>
createSPIRVTargetInfo(TypeBuilder &TB, unsigned DefaultAddrSpace,
                      bool KernelPassAggregatesIndirect = false);
 
/// The AVX ABI level for X86 targets.
enum class X86AVXABILevel {
  None,
  AVX,
  AVX512,
  Last = AVX512 // must be last
};
 
LLVM_ABI std::unique_ptr<TargetInfo>
createX86_64TargetInfo(TypeBuilder &TB, X86AVXABILevel AVXLevel,
                       bool Has64BitPointers, const X86ABICompatInfo &Compat);
 
enum class AArch64ABIKind {
  AAPCS = 0,
  DarwinPCS,
  Win64,
  AAPCSSoft,
};
 
/// Target / language flags that affect AArch64 ABI classification.
/// Callers (e.g. Clang) resolve Triple and LangOptions into these flags
/// rather than passing a Triple into the ABI library.
struct AArch64ABIOptions {
  AArch64ABIKind Kind = AArch64ABIKind::AAPCS;
  bool IsILP32 = false;
  bool IsCXX = false;
  bool IsMachO = false;
  bool IsAndroidOrOHOS = false;
  bool IsWindowsArm64EC = false;
  bool IsMicrosoftCXXABI = false;
  bool IsBigEndian = false;
  ABICompatInfo CompatInfo;
 
  AArch64ABIOptions() = default;
  explicit AArch64ABIOptions(AArch64ABIKind Kind) : Kind(Kind) {}
};
 
LLVM_ABI std::unique_ptr<TargetInfo>
createAArch64TargetInfo(TypeBuilder &TB, const AArch64ABIOptions &Opts);
 
} // namespace abi
} // namespace llvm
 
#endif // LLVM_ABI_TARGETINFO_H