llvm/CodeGen/TargetCallingConv.h

0001 //===-- llvm/CodeGen/TargetCallingConv.h - Calling Convention ---*- C++ -*-===//
0002 //
0003 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0004 // See https://llvm.org/LICENSE.txt for license information.
0005 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0006 //
0007 //===----------------------------------------------------------------------===//
0008 //
0009 // This file defines types for working with calling-convention information.
0010 //
0011 //===----------------------------------------------------------------------===//
0012
0013 #ifndef LLVM_CODEGEN_TARGETCALLINGCONV_H
0014 #define LLVM_CODEGEN_TARGETCALLINGCONV_H
0015
0016 #include "llvm/CodeGen/ValueTypes.h"
0017 #include "llvm/CodeGenTypes/MachineValueType.h"
0018 #include "llvm/Support/Alignment.h"
0019 #include "llvm/Support/MathExtras.h"
0020 #include <cassert>
0021 #include <climits>
0022 #include <cstdint>
0023
0024 namespace llvm {
0025 namespace ISD {
0026
0027   struct ArgFlagsTy {
0028   private:
0029     unsigned IsZExt : 1;     ///< Zero extended
0030     unsigned IsSExt : 1;     ///< Sign extended
0031     unsigned IsNoExt : 1;    ///< No extension
0032     unsigned IsInReg : 1;    ///< Passed in register
0033     unsigned IsSRet : 1;     ///< Hidden struct-ret ptr
0034     unsigned IsByVal : 1;    ///< Struct passed by value
0035     unsigned IsByRef : 1;    ///< Passed in memory
0036     unsigned IsNest : 1;     ///< Nested fn static chain
0037     unsigned IsReturned : 1; ///< Always returned
0038     unsigned IsSplit : 1;
0039     unsigned IsInAlloca : 1;   ///< Passed with inalloca
0040     unsigned IsPreallocated : 1; ///< ByVal without the copy
0041     unsigned IsSplitEnd : 1;   ///< Last part of a split
0042     unsigned IsSwiftSelf : 1;  ///< Swift self parameter
0043     unsigned IsSwiftAsync : 1;  ///< Swift async context parameter
0044     unsigned IsSwiftError : 1; ///< Swift error parameter
0045     unsigned IsCFGuardTarget : 1; ///< Control Flow Guard target
0046     unsigned IsHva : 1;        ///< HVA field for
0047     unsigned IsHvaStart : 1;   ///< HVA structure start
0048     unsigned IsSecArgPass : 1; ///< Second argument
0049     unsigned MemAlign : 6; ///< Log 2 of alignment when arg is passed in memory
0050                            ///< (including byval/byref). The max alignment is
0051                            ///< verified in IR verification.
0052     unsigned OrigAlign : 5;    ///< Log 2 of original alignment
0053     unsigned IsInConsecutiveRegsLast : 1;
0054     unsigned IsInConsecutiveRegs : 1;
0055     unsigned IsCopyElisionCandidate : 1; ///< Argument copy elision candidate
0056     unsigned IsPointer : 1;
0057
0058     unsigned ByValOrByRefSize = 0; ///< Byval or byref struct size
0059
0060     unsigned PointerAddrSpace = 0; ///< Address space of pointer argument
0061
0062   public:
0063     ArgFlagsTy()
0064         : IsZExt(0), IsSExt(0), IsNoExt(0), IsInReg(0), IsSRet(0), IsByVal(0),
0065           IsByRef(0), IsNest(0), IsReturned(0), IsSplit(0), IsInAlloca(0),
0066           IsPreallocated(0), IsSplitEnd(0), IsSwiftSelf(0), IsSwiftAsync(0),
0067           IsSwiftError(0), IsCFGuardTarget(0), IsHva(0), IsHvaStart(0),
0068           IsSecArgPass(0), MemAlign(0), OrigAlign(0),
0069           IsInConsecutiveRegsLast(0), IsInConsecutiveRegs(0),
0070           IsCopyElisionCandidate(0), IsPointer(0) {
0071       static_assert(sizeof(*this) == 4 * sizeof(unsigned), "flags are too big");
0072     }
0073
0074     bool isZExt() const { return IsZExt; }
0075     void setZExt() { IsZExt = 1; }
0076
0077     bool isSExt() const { return IsSExt; }
0078     void setSExt() { IsSExt = 1; }
0079
0080     bool isNoExt() const { return IsNoExt; }
0081     void setNoExt() { IsNoExt = 1; }
0082
0083     bool isInReg() const { return IsInReg; }
0084     void setInReg() { IsInReg = 1; }
0085
0086     bool isSRet() const { return IsSRet; }
0087     void setSRet() { IsSRet = 1; }
0088
0089     bool isByVal() const { return IsByVal; }
0090     void setByVal() { IsByVal = 1; }
0091
0092     bool isByRef() const { return IsByRef; }
0093     void setByRef() { IsByRef = 1; }
0094
0095     bool isInAlloca() const { return IsInAlloca; }
0096     void setInAlloca() { IsInAlloca = 1; }
0097
0098     bool isPreallocated() const { return IsPreallocated; }
0099     void setPreallocated() { IsPreallocated = 1; }
0100
0101     bool isSwiftSelf() const { return IsSwiftSelf; }
0102     void setSwiftSelf() { IsSwiftSelf = 1; }
0103
0104     bool isSwiftAsync() const { return IsSwiftAsync; }
0105     void setSwiftAsync() { IsSwiftAsync = 1; }
0106
0107     bool isSwiftError() const { return IsSwiftError; }
0108     void setSwiftError() { IsSwiftError = 1; }
0109
0110     bool isCFGuardTarget() const { return IsCFGuardTarget; }
0111     void setCFGuardTarget() { IsCFGuardTarget = 1; }
0112
0113     bool isHva() const { return IsHva; }
0114     void setHva() { IsHva = 1; }
0115
0116     bool isHvaStart() const { return IsHvaStart; }
0117     void setHvaStart() { IsHvaStart = 1; }
0118
0119     bool isSecArgPass() const { return IsSecArgPass; }
0120     void setSecArgPass() { IsSecArgPass = 1; }
0121
0122     bool isNest() const { return IsNest; }
0123     void setNest() { IsNest = 1; }
0124
0125     bool isReturned() const { return IsReturned; }
0126     void setReturned(bool V = true) { IsReturned = V; }
0127
0128     bool isInConsecutiveRegs()  const { return IsInConsecutiveRegs; }
0129     void setInConsecutiveRegs(bool Flag = true) { IsInConsecutiveRegs = Flag; }
0130
0131     bool isInConsecutiveRegsLast() const { return IsInConsecutiveRegsLast; }
0132     void setInConsecutiveRegsLast(bool Flag = true) {
0133       IsInConsecutiveRegsLast = Flag;
0134     }
0135
0136     bool isSplit()   const { return IsSplit; }
0137     void setSplit()  { IsSplit = 1; }
0138
0139     bool isSplitEnd()   const { return IsSplitEnd; }
0140     void setSplitEnd()  { IsSplitEnd = 1; }
0141
0142     bool isCopyElisionCandidate()  const { return IsCopyElisionCandidate; }
0143     void setCopyElisionCandidate() { IsCopyElisionCandidate = 1; }
0144
0145     bool isPointer()  const { return IsPointer; }
0146     void setPointer() { IsPointer = 1; }
0147
0148     Align getNonZeroMemAlign() const {
0149       return decodeMaybeAlign(MemAlign).valueOrOne();
0150     }
0151
0152     void setMemAlign(Align A) {
0153       MemAlign = encode(A);
0154       assert(getNonZeroMemAlign() == A && "bitfield overflow");
0155     }
0156
0157     Align getNonZeroByValAlign() const {
0158       assert(isByVal());
0159       MaybeAlign A = decodeMaybeAlign(MemAlign);
0160       assert(A && "ByValAlign must be defined");
0161       return *A;
0162     }
0163
0164     Align getNonZeroOrigAlign() const {
0165       return decodeMaybeAlign(OrigAlign).valueOrOne();
0166     }
0167
0168     void setOrigAlign(Align A) {
0169       OrigAlign = encode(A);
0170       assert(getNonZeroOrigAlign() == A && "bitfield overflow");
0171     }
0172
0173     unsigned getByValSize() const {
0174       assert(isByVal() && !isByRef());
0175       return ByValOrByRefSize;
0176     }
0177     void setByValSize(unsigned S) {
0178       assert(isByVal() && !isByRef());
0179       ByValOrByRefSize = S;
0180     }
0181
0182     unsigned getByRefSize() const {
0183       assert(!isByVal() && isByRef());
0184       return ByValOrByRefSize;
0185     }
0186     void setByRefSize(unsigned S) {
0187       assert(!isByVal() && isByRef());
0188       ByValOrByRefSize = S;
0189     }
0190
0191     unsigned getPointerAddrSpace() const { return PointerAddrSpace; }
0192     void setPointerAddrSpace(unsigned AS) { PointerAddrSpace = AS; }
0193 };
0194
0195   /// InputArg - This struct carries flags and type information about a
0196   /// single incoming (formal) argument or incoming (from the perspective
0197   /// of the caller) return value virtual register.
0198   ///
0199   struct InputArg {
0200     ArgFlagsTy Flags;
0201     MVT VT = MVT::Other;
0202     EVT ArgVT;
0203     bool Used = false;
0204
0205     /// Index original Function's argument.
0206     unsigned OrigArgIndex;
0207     /// Sentinel value for implicit machine-level input arguments.
0208     static const unsigned NoArgIndex = UINT_MAX;
0209
0210     /// Offset in bytes of current input value relative to the beginning of
0211     /// original argument. E.g. if argument was splitted into four 32 bit
0212     /// registers, we got 4 InputArgs with PartOffsets 0, 4, 8 and 12.
0213     unsigned PartOffset;
0214
0215     InputArg() = default;
0216     InputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool used,
0217              unsigned origIdx, unsigned partOffs)
0218       : Flags(flags), Used(used), OrigArgIndex(origIdx), PartOffset(partOffs) {
0219       VT = vt.getSimpleVT();
0220       ArgVT = argvt;
0221     }
0222
0223     bool isOrigArg() const {
0224       return OrigArgIndex != NoArgIndex;
0225     }
0226
0227     unsigned getOrigArgIndex() const {
0228       assert(OrigArgIndex != NoArgIndex && "Implicit machine-level argument");
0229       return OrigArgIndex;
0230     }
0231   };
0232
0233   /// OutputArg - This struct carries flags and a value for a
0234   /// single outgoing (actual) argument or outgoing (from the perspective
0235   /// of the caller) return value virtual register.
0236   ///
0237   struct OutputArg {
0238     ArgFlagsTy Flags;
0239     MVT VT;
0240     EVT ArgVT;
0241
0242     /// IsFixed - Is this a "fixed" value, ie not passed through a vararg "...".
0243     bool IsFixed = false;
0244
0245     /// Index original Function's argument.
0246     unsigned OrigArgIndex;
0247
0248     /// Offset in bytes of current output value relative to the beginning of
0249     /// original argument. E.g. if argument was splitted into four 32 bit
0250     /// registers, we got 4 OutputArgs with PartOffsets 0, 4, 8 and 12.
0251     unsigned PartOffset;
0252
0253     OutputArg() = default;
0254     OutputArg(ArgFlagsTy flags, MVT vt, EVT argvt, bool isfixed,
0255               unsigned origIdx, unsigned partOffs)
0256         : Flags(flags), IsFixed(isfixed), OrigArgIndex(origIdx),
0257           PartOffset(partOffs) {
0258       VT = vt;
0259       ArgVT = argvt;
0260     }
0261   };
0262
0263 } // end namespace ISD
0264 } // end namespace llvm
0265
0266 #endif // LLVM_CODEGEN_TARGETCALLINGCONV_H