clang/lib/CodeGen/ABIInfoImpl.h

   1 //===- ABIInfoImpl.h --------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef LLVM_CLANG_LIB_CODEGEN_ABIINFOIMPL_H
  10 #define LLVM_CLANG_LIB_CODEGEN_ABIINFOIMPL_H
  11
  12 #include "ABIInfo.h"
  13 #include "CGCXXABI.h"
  14
  15 namespace clang::CodeGen {
  16
  17 /// DefaultABIInfo - The default implementation for ABI specific
  18 /// details. This implementation provides information which results in
  19 /// self-consistent and sensible LLVM IR generation, but does not
  20 /// conform to any particular ABI.
  21 class DefaultABIInfo : public ABIInfo {
  22 public:
  23   DefaultABIInfo(CodeGen::CodeGenTypes &CGT) : ABIInfo(CGT) {}
  24
  25   virtual ~DefaultABIInfo();
  26
  27   ABIArgInfo classifyReturnType(QualType RetTy) const;
  28   ABIArgInfo classifyArgumentType(QualType RetTy) const;
  29
  30   void computeInfo(CGFunctionInfo &FI) const override;
  31
  32   RValue EmitVAArg(CodeGenFunction &CGF, Address VAListAddr, QualType Ty,
  33                    AggValueSlot Slot) const override;
  34 };
  35
  36 void AssignToArrayRange(CodeGen::CGBuilderTy &Builder, llvm::Value *Array,
  37                         llvm::Value *Value, unsigned FirstIndex,
  38                         unsigned LastIndex);
  39
  40 bool isAggregateTypeForABI(QualType T);
  41
  42 llvm::Type *getVAListElementType(CodeGenFunction &CGF);
  43
  44 CGCXXABI::RecordArgABI getRecordArgABI(const RecordType *RT, CGCXXABI &CXXABI);
  45
  46 CGCXXABI::RecordArgABI getRecordArgABI(QualType T, CGCXXABI &CXXABI);
  47
  48 bool classifyReturnType(const CGCXXABI &CXXABI, CGFunctionInfo &FI,
  49                         const ABIInfo &Info);
  50
  51 /// Pass transparent unions as if they were the type of the first element. Sema
  52 /// should ensure that all elements of the union have the same "machine type".
  53 QualType useFirstFieldIfTransparentUnion(QualType Ty);
  54
  55 // Dynamically round a pointer up to a multiple of the given alignment.
  56 llvm::Value *emitRoundPointerUpToAlignment(CodeGenFunction &CGF,
  57                                            llvm::Value *Ptr, CharUnits Align);
  58
  59 /// Emit va_arg for a platform using the common void* representation,
  60 /// where arguments are simply emitted in an array of slots on the stack.
  61 ///
  62 /// This version implements the core direct-value passing rules.
  63 ///
  64 /// \param SlotSize - The size and alignment of a stack slot.
  65 ///   Each argument will be allocated to a multiple of this number of
  66 ///   slots, and all the slots will be aligned to this value.
  67 /// \param AllowHigherAlign - The slot alignment is not a cap;
  68 ///   an argument type with an alignment greater than the slot size
  69 ///   will be emitted on a higher-alignment address, potentially
  70 ///   leaving one or more empty slots behind as padding.  If this
  71 ///   is false, the returned address might be less-aligned than
  72 ///   DirectAlign.
  73 /// \param ForceRightAdjust - Default is false. On big-endian platform and
  74 ///   if the argument is smaller than a slot, set this flag will force
  75 ///   right-adjust the argument in its slot irrespective of the type.
  76 Address emitVoidPtrDirectVAArg(CodeGenFunction &CGF, Address VAListAddr,
  77                                llvm::Type *DirectTy, CharUnits DirectSize,
  78                                CharUnits DirectAlign, CharUnits SlotSize,
  79                                bool AllowHigherAlign,
  80                                bool ForceRightAdjust = false);
  81
  82 /// Emit va_arg for a platform using the common void* representation,
  83 /// where arguments are simply emitted in an array of slots on the stack.
  84 ///
  85 /// \param IsIndirect - Values of this type are passed indirectly.
  86 /// \param ValueInfo - The size and alignment of this type, generally
  87 ///   computed with getContext().getTypeInfoInChars(ValueTy).
  88 /// \param SlotSizeAndAlign - The size and alignment of a stack slot.
  89 ///   Each argument will be allocated to a multiple of this number of
  90 ///   slots, and all the slots will be aligned to this value.
  91 /// \param AllowHigherAlign - The slot alignment is not a cap;
  92 ///   an argument type with an alignment greater than the slot size
  93 ///   will be emitted on a higher-alignment address, potentially
  94 ///   leaving one or more empty slots behind as padding.
  95 /// \param ForceRightAdjust - Default is false. On big-endian platform and
  96 ///   if the argument is smaller than a slot, set this flag will force
  97 ///   right-adjust the argument in its slot irrespective of the type.
  98 RValue emitVoidPtrVAArg(CodeGenFunction &CGF, Address VAListAddr,
  99                         QualType ValueTy, bool IsIndirect,
 100                         TypeInfoChars ValueInfo, CharUnits SlotSizeAndAlign,
 101                         bool AllowHigherAlign, AggValueSlot Slot,
 102                         bool ForceRightAdjust = false);
 103
 104 Address emitMergePHI(CodeGenFunction &CGF, Address Addr1,
 105                      llvm::BasicBlock *Block1, Address Addr2,
 106                      llvm::BasicBlock *Block2, const llvm::Twine &Name = "");
 107
 108 /// isEmptyField - Return true iff a the field is "empty", that is it
 109 /// is an unnamed bit-field or an (array of) empty record(s). If
 110 /// AsIfNoUniqueAddr is true, then C++ record fields are considered empty if
 111 /// the [[no_unique_address]] attribute would have made them empty.
 112 bool isEmptyField(ASTContext &Context, const FieldDecl *FD, bool AllowArrays,
 113                   bool AsIfNoUniqueAddr = false);
 114
 115 /// isEmptyRecord - Return true iff a structure contains only empty
 116 /// fields. Note that a structure with a flexible array member is not
 117 /// considered empty. If AsIfNoUniqueAddr is true, then C++ record fields are
 118 /// considered empty if the [[no_unique_address]] attribute would have made
 119 /// them empty.
 120 bool isEmptyRecord(ASTContext &Context, QualType T, bool AllowArrays,
 121                    bool AsIfNoUniqueAddr = false);
 122
 123 /// isEmptyFieldForLayout - Return true iff the field is "empty", that is,
 124 /// either a zero-width bit-field or an \ref isEmptyRecordForLayout.
 125 bool isEmptyFieldForLayout(const ASTContext &Context, const FieldDecl *FD);
 126
 127 /// isEmptyRecordForLayout - Return true iff a structure contains only empty
 128 /// base classes (per \ref isEmptyRecordForLayout) and fields (per
 129 /// \ref isEmptyFieldForLayout). Note, C++ record fields are considered empty
 130 /// if the [[no_unique_address]] attribute would have made them empty.
 131 bool isEmptyRecordForLayout(const ASTContext &Context, QualType T);
 132
 133 /// isSingleElementStruct - Determine if a structure is a "single
 134 /// element struct", i.e. it has exactly one non-empty field or
 135 /// exactly one field which is itself a single element
 136 /// struct. Structures with flexible array members are never
 137 /// considered single element structs.
 138 ///
 139 /// \return The field declaration for the single non-empty field, if
 140 /// it exists.
 141 const Type *isSingleElementStruct(QualType T, ASTContext &Context);
 142
 143 Address EmitVAArgInstr(CodeGenFunction &CGF, Address VAListAddr, QualType Ty,
 144                        const ABIArgInfo &AI);
 145
 146 bool isSIMDVectorType(ASTContext &Context, QualType Ty);
 147
 148 bool isRecordWithSIMDVectorType(ASTContext &Context, QualType Ty);
 149
 150 } // namespace clang::CodeGen
 151
 152 #endif // LLVM_CLANG_LIB_CODEGEN_ABIINFOIMPL_H