Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Target/TargetCallingConv.h
Line
Count
Source
1
//===-- llvm/Target/TargetCallingConv.h - Calling Convention ----*- C++ -*-===//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
// This file defines types for working with calling-convention information.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_TARGET_TARGETCALLINGCONV_H
15
#define LLVM_TARGET_TARGETCALLINGCONV_H
16
17
#include "llvm/CodeGen/MachineValueType.h"
18
#include "llvm/CodeGen/ValueTypes.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 IsNest : 1;     ///< Nested fn static chain
35
    unsigned IsReturned : 1; ///< Always returned
36
    unsigned IsSplit : 1;
37
    unsigned IsInAlloca : 1;   ///< Passed with inalloca
38
    unsigned IsSplitEnd : 1;   ///< Last part of a split
39
    unsigned IsSwiftSelf : 1;  ///< Swift self parameter
40
    unsigned IsSwiftError : 1; ///< Swift error parameter
41
    unsigned IsHva : 1;        ///< HVA field for
42
    unsigned IsHvaStart : 1;   ///< HVA structure start
43
    unsigned IsSecArgPass : 1; ///< Second argument
44
    unsigned ByValAlign : 4;   ///< Log 2 of byval alignment
45
    unsigned OrigAlign : 5;    ///< Log 2 of original alignment
46
    unsigned IsInConsecutiveRegsLast : 1;
47
    unsigned IsInConsecutiveRegs : 1;
48
    unsigned IsCopyElisionCandidate : 1; ///< Argument copy elision candidate
49
50
    unsigned ByValSize; ///< Byval struct size
51
52
  public:
53
    ArgFlagsTy()
54
        : IsZExt(0), IsSExt(0), IsInReg(0), IsSRet(0), IsByVal(0), IsNest(0),
55
          IsReturned(0), IsSplit(0), IsInAlloca(0), IsSplitEnd(0),
56
          IsSwiftSelf(0), IsSwiftError(0), IsHva(0), IsHvaStart(0),
57
          IsSecArgPass(0), ByValAlign(0), OrigAlign(0),
58
          IsInConsecutiveRegsLast(0), IsInConsecutiveRegs(0),
59
12.7M
          IsCopyElisionCandidate(0), ByValSize(0) {
60
12.7M
      static_assert(sizeof(*this) == 2 * sizeof(unsigned), "flags are too big");
61
12.7M
    }
62
63
158k
    bool isZExt() const { return IsZExt; }
64
173k
    void setZExt() { IsZExt = 1; }
65
66
198k
    bool isSExt() const { return IsSExt; }
67
23.4k
    void setSExt() { IsSExt = 1; }
68
69
180k
    bool isInReg() const { return IsInReg; }
70
2.33k
    void setInReg() { IsInReg = 1; }
71
72
8.66M
    bool isSRet() const { return IsSRet; }
73
9.46k
    void setSRet() { IsSRet = 1; }
74
75
15.1M
    bool isByVal() const { return IsByVal; }
76
1.28k
    void setByVal() { IsByVal = 1; }
77
78
5.23M
    bool isInAlloca() const { return IsInAlloca; }
79
46
    void setInAlloca() { IsInAlloca = 1; }
80
81
8.74M
    bool isSwiftSelf() const { return IsSwiftSelf; }
82
195
    void setSwiftSelf() { IsSwiftSelf = 1; }
83
84
12.5M
    bool isSwiftError() const { return IsSwiftError; }
85
475
    void setSwiftError() { IsSwiftError = 1; }
86
87
393
    bool isHva() const { return IsHva; }
88
58
    void setHva() { IsHva = 1; }
89
90
29
    bool isHvaStart() const { return IsHvaStart; }
91
16
    void setHvaStart() { IsHvaStart = 1; }
92
93
392
    bool isSecArgPass() const { return IsSecArgPass; }
94
181
    void setSecArgPass() { IsSecArgPass = 1; }
95
96
441k
    bool isNest() const { return IsNest; }
97
40
    void setNest() { IsNest = 1; }
98
99
1.61M
    bool isReturned() const { return IsReturned; }
100
5.26k
    void setReturned() { IsReturned = 1; }
101
102
8.63M
    bool isInConsecutiveRegs()  const { return IsInConsecutiveRegs; }
103
6.71k
    void setInConsecutiveRegs() { IsInConsecutiveRegs = 1; }
104
105
26.3k
    bool isInConsecutiveRegsLast() const { return IsInConsecutiveRegsLast; }
106
3.81k
    void setInConsecutiveRegsLast() { IsInConsecutiveRegsLast = 1; }
107
108
14.5M
    bool isSplit()   const { return IsSplit; }
109
25.9k
    void setSplit()  { IsSplit = 1; }
110
111
126
    bool isSplitEnd()   const { return IsSplitEnd; }
112
25.3k
    void setSplitEnd()  { IsSplitEnd = 1; }
113
114
981k
    bool isCopyElisionCandidate()  const { return IsCopyElisionCandidate; }
115
4.26k
    void setCopyElisionCandidate() { IsCopyElisionCandidate = 1; }
116
117
1.70k
    unsigned getByValAlign() const { return (1U << ByValAlign) / 2; }
118
1.28k
    void setByValAlign(unsigned A) {
119
1.28k
      ByValAlign = Log2_32(A) + 1;
120
1.28k
      assert(getByValAlign() == A && "bitfield overflow");
121
1.28k
    }
122
123
143k
    unsigned getOrigAlign() const { return (1U << OrigAlign) / 2; }
124
9.25M
    void setOrigAlign(unsigned A) {
125
9.25M
      OrigAlign = Log2_32(A) + 1;
126
9.25M
      assert(getOrigAlign() == A && "bitfield overflow");
127
9.25M
    }
128
129
2.36k
    unsigned getByValSize() const { return ByValSize; }
130
1.28k
    void setByValSize(unsigned S) { ByValSize = S; }
131
  };
132
133
  /// InputArg - This struct carries flags and type information about a
134
  /// single incoming (formal) argument or incoming (from the perspective
135
  /// of the caller) return value virtual register.
136
  ///
137
  struct InputArg {
138
    ArgFlagsTy Flags;
139
    MVT VT = MVT::Other;
140
    EVT ArgVT;
141
    bool Used = false;
142
143
    /// Index original Function's argument.
144
    unsigned OrigArgIndex;
145
    /// Sentinel value for implicit machine-level input arguments.
146
    static const unsigned NoArgIndex = UINT_MAX;
147
148
    /// Offset in bytes of current input value relative to the beginning of
149
    /// original argument. E.g. if argument was splitted into four 32 bit
150
    /// registers, we got 4 InputArgs with PartOffsets 0, 4, 8 and 12.
151
    unsigned PartOffset;
152
153
1.26M
    InputArg() = default;
154
    InputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool used,
155
             unsigned origIdx, unsigned partOffs)
156
988k
      : Flags(flags), Used(used), OrigArgIndex(origIdx), PartOffset(partOffs) {
157
988k
      VT = vt.getSimpleVT();
158
988k
      ArgVT = argvt;
159
988k
    }
160
161
782k
    bool isOrigArg() const {
162
782k
      return OrigArgIndex != NoArgIndex;
163
782k
    }
164
165
1.62M
    unsigned getOrigArgIndex() const {
166
1.62M
      assert(OrigArgIndex != NoArgIndex && "Implicit machine-level argument");
167
1.62M
      return OrigArgIndex;
168
1.62M
    }
169
  };
170
171
  /// OutputArg - This struct carries flags and a value for a
172
  /// single outgoing (actual) argument or outgoing (from the perspective
173
  /// of the caller) return value virtual register.
174
  ///
175
  struct OutputArg {
176
    ArgFlagsTy Flags;
177
    MVT VT;
178
    EVT ArgVT;
179
180
    /// IsFixed - Is this a "fixed" value, ie not passed through a vararg "...".
181
    bool IsFixed = false;
182
183
    /// Index original Function's argument.
184
    unsigned OrigArgIndex;
185
186
    /// Offset in bytes of current output value relative to the beginning of
187
    /// original argument. E.g. if argument was splitted into four 32 bit
188
    /// registers, we got 4 OutputArgs with PartOffsets 0, 4, 8 and 12.
189
    unsigned PartOffset;
190
191
    OutputArg() = default;
192
    OutputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool isfixed,
193
              unsigned origIdx, unsigned partOffs)
194
      : Flags(flags), IsFixed(isfixed), OrigArgIndex(origIdx),
195
5.94M
        PartOffset(partOffs) {
196
5.94M
      VT = vt.getSimpleVT();
197
5.94M
      ArgVT = argvt;
198
5.94M
    }
199
  };
200
201
} // end namespace ISD
202
} // end namespace llvm
203
204
#endif // LLVM_TARGET_TARGETCALLINGCONV_H