Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===-- llvm/CodeGen/TargetCallingConv.h - Calling Convention ---*- 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. // This file defines types for working with calling-convention information.
  10. //
  11. //===----------------------------------------------------------------------===//
  12.  
  13. #ifndef LLVM_CODEGEN_TARGETCALLINGCONV_H
  14. #define LLVM_CODEGEN_TARGETCALLINGCONV_H
  15.  
  16. #include "llvm/CodeGen/ValueTypes.h"
  17. #include "llvm/Support/Alignment.h"
  18. #include "llvm/Support/MachineValueType.h"
  19. #include "llvm/Support/MathExtras.h"
  20. #include <cassert>
  21. #include <climits>
  22. #include <cstdint>
  23.  
  24. namespace llvm {
  25. namespace ISD {
  26.  
  27.   struct ArgFlagsTy {
  28.   private:
  29.     unsigned IsZExt : 1;     ///< Zero extended
  30.     unsigned IsSExt : 1;     ///< Sign extended
  31.     unsigned IsInReg : 1;    ///< Passed in register
  32.     unsigned IsSRet : 1;     ///< Hidden struct-ret ptr
  33.     unsigned IsByVal : 1;    ///< Struct passed by value
  34.     unsigned IsByRef : 1;    ///< Passed in memory
  35.     unsigned IsNest : 1;     ///< Nested fn static chain
  36.     unsigned IsReturned : 1; ///< Always returned
  37.     unsigned IsSplit : 1;
  38.     unsigned IsInAlloca : 1;   ///< Passed with inalloca
  39.     unsigned IsPreallocated : 1; ///< ByVal without the copy
  40.     unsigned IsSplitEnd : 1;   ///< Last part of a split
  41.     unsigned IsSwiftSelf : 1;  ///< Swift self parameter
  42.     unsigned IsSwiftAsync : 1;  ///< Swift async context parameter
  43.     unsigned IsSwiftError : 1; ///< Swift error parameter
  44.     unsigned IsCFGuardTarget : 1; ///< Control Flow Guard target
  45.     unsigned IsHva : 1;        ///< HVA field for
  46.     unsigned IsHvaStart : 1;   ///< HVA structure start
  47.     unsigned IsSecArgPass : 1; ///< Second argument
  48.     unsigned MemAlign : 4;     ///< Log 2 of alignment when arg is passed in memory
  49.                                ///< (including byval/byref). The max alignment is
  50.                                ///< verified in IR verification.
  51.     unsigned OrigAlign : 5;    ///< Log 2 of original alignment
  52.     unsigned IsInConsecutiveRegsLast : 1;
  53.     unsigned IsInConsecutiveRegs : 1;
  54.     unsigned IsCopyElisionCandidate : 1; ///< Argument copy elision candidate
  55.     unsigned IsPointer : 1;
  56.  
  57.     unsigned ByValOrByRefSize = 0; ///< Byval or byref struct size
  58.  
  59.     unsigned PointerAddrSpace = 0; ///< Address space of pointer argument
  60.  
  61.   public:
  62.     ArgFlagsTy()
  63.         : IsZExt(0), IsSExt(0), IsInReg(0), IsSRet(0), IsByVal(0), IsByRef(0),
  64.           IsNest(0), IsReturned(0), IsSplit(0), IsInAlloca(0),
  65.           IsPreallocated(0), IsSplitEnd(0), IsSwiftSelf(0), IsSwiftAsync(0),
  66.           IsSwiftError(0), IsCFGuardTarget(0), IsHva(0), IsHvaStart(0),
  67.           IsSecArgPass(0), MemAlign(0), OrigAlign(0),
  68.           IsInConsecutiveRegsLast(0), IsInConsecutiveRegs(0),
  69.           IsCopyElisionCandidate(0), IsPointer(0) {
  70.       static_assert(sizeof(*this) == 3 * sizeof(unsigned), "flags are too big");
  71.     }
  72.  
  73.     bool isZExt() const { return IsZExt; }
  74.     void setZExt() { IsZExt = 1; }
  75.  
  76.     bool isSExt() const { return IsSExt; }
  77.     void setSExt() { IsSExt = 1; }
  78.  
  79.     bool isInReg() const { return IsInReg; }
  80.     void setInReg() { IsInReg = 1; }
  81.  
  82.     bool isSRet() const { return IsSRet; }
  83.     void setSRet() { IsSRet = 1; }
  84.  
  85.     bool isByVal() const { return IsByVal; }
  86.     void setByVal() { IsByVal = 1; }
  87.  
  88.     bool isByRef() const { return IsByRef; }
  89.     void setByRef() { IsByRef = 1; }
  90.  
  91.     bool isInAlloca() const { return IsInAlloca; }
  92.     void setInAlloca() { IsInAlloca = 1; }
  93.  
  94.     bool isPreallocated() const { return IsPreallocated; }
  95.     void setPreallocated() { IsPreallocated = 1; }
  96.  
  97.     bool isSwiftSelf() const { return IsSwiftSelf; }
  98.     void setSwiftSelf() { IsSwiftSelf = 1; }
  99.  
  100.     bool isSwiftAsync() const { return IsSwiftAsync; }
  101.     void setSwiftAsync() { IsSwiftAsync = 1; }
  102.  
  103.     bool isSwiftError() const { return IsSwiftError; }
  104.     void setSwiftError() { IsSwiftError = 1; }
  105.  
  106.     bool isCFGuardTarget() const { return IsCFGuardTarget; }
  107.     void setCFGuardTarget() { IsCFGuardTarget = 1; }
  108.  
  109.     bool isHva() const { return IsHva; }
  110.     void setHva() { IsHva = 1; }
  111.  
  112.     bool isHvaStart() const { return IsHvaStart; }
  113.     void setHvaStart() { IsHvaStart = 1; }
  114.  
  115.     bool isSecArgPass() const { return IsSecArgPass; }
  116.     void setSecArgPass() { IsSecArgPass = 1; }
  117.  
  118.     bool isNest() const { return IsNest; }
  119.     void setNest() { IsNest = 1; }
  120.  
  121.     bool isReturned() const { return IsReturned; }
  122.     void setReturned(bool V = true) { IsReturned = V; }
  123.  
  124.     bool isInConsecutiveRegs()  const { return IsInConsecutiveRegs; }
  125.     void setInConsecutiveRegs(bool Flag = true) { IsInConsecutiveRegs = Flag; }
  126.  
  127.     bool isInConsecutiveRegsLast() const { return IsInConsecutiveRegsLast; }
  128.     void setInConsecutiveRegsLast(bool Flag = true) {
  129.       IsInConsecutiveRegsLast = Flag;
  130.     }
  131.  
  132.     bool isSplit()   const { return IsSplit; }
  133.     void setSplit()  { IsSplit = 1; }
  134.  
  135.     bool isSplitEnd()   const { return IsSplitEnd; }
  136.     void setSplitEnd()  { IsSplitEnd = 1; }
  137.  
  138.     bool isCopyElisionCandidate()  const { return IsCopyElisionCandidate; }
  139.     void setCopyElisionCandidate() { IsCopyElisionCandidate = 1; }
  140.  
  141.     bool isPointer()  const { return IsPointer; }
  142.     void setPointer() { IsPointer = 1; }
  143.  
  144.     Align getNonZeroMemAlign() const {
  145.       return decodeMaybeAlign(MemAlign).valueOrOne();
  146.     }
  147.  
  148.     void setMemAlign(Align A) {
  149.       MemAlign = encode(A);
  150.       assert(getNonZeroMemAlign() == A && "bitfield overflow");
  151.     }
  152.  
  153.     Align getNonZeroByValAlign() const {
  154.       assert(isByVal());
  155.       MaybeAlign A = decodeMaybeAlign(MemAlign);
  156.       assert(A && "ByValAlign must be defined");
  157.       return *A;
  158.     }
  159.  
  160.     Align getNonZeroOrigAlign() const {
  161.       return decodeMaybeAlign(OrigAlign).valueOrOne();
  162.     }
  163.  
  164.     void setOrigAlign(Align A) {
  165.       OrigAlign = encode(A);
  166.       assert(getNonZeroOrigAlign() == A && "bitfield overflow");
  167.     }
  168.  
  169.     unsigned getByValSize() const {
  170.       assert(isByVal() && !isByRef());
  171.       return ByValOrByRefSize;
  172.     }
  173.     void setByValSize(unsigned S) {
  174.       assert(isByVal() && !isByRef());
  175.       ByValOrByRefSize = S;
  176.     }
  177.  
  178.     unsigned getByRefSize() const {
  179.       assert(!isByVal() && isByRef());
  180.       return ByValOrByRefSize;
  181.     }
  182.     void setByRefSize(unsigned S) {
  183.       assert(!isByVal() && isByRef());
  184.       ByValOrByRefSize = S;
  185.     }
  186.  
  187.     unsigned getPointerAddrSpace() const { return PointerAddrSpace; }
  188.     void setPointerAddrSpace(unsigned AS) { PointerAddrSpace = AS; }
  189. };
  190.  
  191.   /// InputArg - This struct carries flags and type information about a
  192.   /// single incoming (formal) argument or incoming (from the perspective
  193.   /// of the caller) return value virtual register.
  194.   ///
  195.   struct InputArg {
  196.     ArgFlagsTy Flags;
  197.     MVT VT = MVT::Other;
  198.     EVT ArgVT;
  199.     bool Used = false;
  200.  
  201.     /// Index original Function's argument.
  202.     unsigned OrigArgIndex;
  203.     /// Sentinel value for implicit machine-level input arguments.
  204.     static const unsigned NoArgIndex = UINT_MAX;
  205.  
  206.     /// Offset in bytes of current input value relative to the beginning of
  207.     /// original argument. E.g. if argument was splitted into four 32 bit
  208.     /// registers, we got 4 InputArgs with PartOffsets 0, 4, 8 and 12.
  209.     unsigned PartOffset;
  210.  
  211.     InputArg() = default;
  212.     InputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool used,
  213.              unsigned origIdx, unsigned partOffs)
  214.       : Flags(flags), Used(used), OrigArgIndex(origIdx), PartOffset(partOffs) {
  215.       VT = vt.getSimpleVT();
  216.       ArgVT = argvt;
  217.     }
  218.  
  219.     bool isOrigArg() const {
  220.       return OrigArgIndex != NoArgIndex;
  221.     }
  222.  
  223.     unsigned getOrigArgIndex() const {
  224.       assert(OrigArgIndex != NoArgIndex && "Implicit machine-level argument");
  225.       return OrigArgIndex;
  226.     }
  227.   };
  228.  
  229.   /// OutputArg - This struct carries flags and a value for a
  230.   /// single outgoing (actual) argument or outgoing (from the perspective
  231.   /// of the caller) return value virtual register.
  232.   ///
  233.   struct OutputArg {
  234.     ArgFlagsTy Flags;
  235.     MVT VT;
  236.     EVT ArgVT;
  237.  
  238.     /// IsFixed - Is this a "fixed" value, ie not passed through a vararg "...".
  239.     bool IsFixed = false;
  240.  
  241.     /// Index original Function's argument.
  242.     unsigned OrigArgIndex;
  243.  
  244.     /// Offset in bytes of current output value relative to the beginning of
  245.     /// original argument. E.g. if argument was splitted into four 32 bit
  246.     /// registers, we got 4 OutputArgs with PartOffsets 0, 4, 8 and 12.
  247.     unsigned PartOffset;
  248.  
  249.     OutputArg() = default;
  250.     OutputArg(ArgFlagsTy flags, MVT vt, EVT argvt, bool isfixed,
  251.               unsigned origIdx, unsigned partOffs)
  252.         : Flags(flags), IsFixed(isfixed), OrigArgIndex(origIdx),
  253.           PartOffset(partOffs) {
  254.       VT = vt;
  255.       ArgVT = argvt;
  256.     }
  257.   };
  258.  
  259. } // end namespace ISD
  260. } // end namespace llvm
  261.  
  262. #endif // LLVM_CODEGEN_TARGETCALLINGCONV_H
  263.