1 //===-- llvm/Target/TargetCallingConv.h - Calling Convention ----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines types for working with calling-convention information.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_TARGET_TARGETCALLINGCONV_H
15 #define LLVM_TARGET_TARGETCALLINGCONV_H
17 #include "llvm/CodeGen/ValueTypes.h"
18 #include "llvm/Support/DataTypes.h"
19 #include "llvm/Support/MathExtras.h"
27 static const uint64_t NoFlagSet
= 0ULL;
28 static const uint64_t ZExt
= 1ULL<<0; ///< Zero extended
29 static const uint64_t ZExtOffs
= 0;
30 static const uint64_t SExt
= 1ULL<<1; ///< Sign extended
31 static const uint64_t SExtOffs
= 1;
32 static const uint64_t InReg
= 1ULL<<2; ///< Passed in register
33 static const uint64_t InRegOffs
= 2;
34 static const uint64_t SRet
= 1ULL<<3; ///< Hidden struct-ret ptr
35 static const uint64_t SRetOffs
= 3;
36 static const uint64_t ByVal
= 1ULL<<4; ///< Struct passed by value
37 static const uint64_t ByValOffs
= 4;
38 static const uint64_t Nest
= 1ULL<<5; ///< Nested fn static chain
39 static const uint64_t NestOffs
= 5;
40 static const uint64_t Returned
= 1ULL<<6; ///< Always returned
41 static const uint64_t ReturnedOffs
= 6;
42 static const uint64_t ByValAlign
= 0xFULL
<<7; ///< Struct alignment
43 static const uint64_t ByValAlignOffs
= 7;
44 static const uint64_t Split
= 1ULL<<11;
45 static const uint64_t SplitOffs
= 11;
46 static const uint64_t InAlloca
= 1ULL<<12; ///< Passed with inalloca
47 static const uint64_t InAllocaOffs
= 12;
48 static const uint64_t OrigAlign
= 0x1FULL
<<27;
49 static const uint64_t OrigAlignOffs
= 27;
50 static const uint64_t ByValSize
= 0x3fffffffULL
<<32; ///< Struct size
51 static const uint64_t ByValSizeOffs
= 32;
52 static const uint64_t InConsecutiveRegsLast
= 0x1ULL
<<62; ///< Struct size
53 static const uint64_t InConsecutiveRegsLastOffs
= 62;
54 static const uint64_t InConsecutiveRegs
= 0x1ULL
<<63; ///< Struct size
55 static const uint64_t InConsecutiveRegsOffs
= 63;
57 static const uint64_t One
= 1ULL; ///< 1 of this type, for shifts
61 ArgFlagsTy() : Flags(0) { }
63 bool isZExt() const { return Flags
& ZExt
; }
64 void setZExt() { Flags
|= One
<< ZExtOffs
; }
66 bool isSExt() const { return Flags
& SExt
; }
67 void setSExt() { Flags
|= One
<< SExtOffs
; }
69 bool isInReg() const { return Flags
& InReg
; }
70 void setInReg() { Flags
|= One
<< InRegOffs
; }
72 bool isSRet() const { return Flags
& SRet
; }
73 void setSRet() { Flags
|= One
<< SRetOffs
; }
75 bool isByVal() const { return Flags
& ByVal
; }
76 void setByVal() { Flags
|= One
<< ByValOffs
; }
78 bool isInAlloca() const { return Flags
& InAlloca
; }
79 void setInAlloca() { Flags
|= One
<< InAllocaOffs
; }
81 bool isNest() const { return Flags
& Nest
; }
82 void setNest() { Flags
|= One
<< NestOffs
; }
84 bool isReturned() const { return Flags
& Returned
; }
85 void setReturned() { Flags
|= One
<< ReturnedOffs
; }
87 bool isInConsecutiveRegs() const { return Flags
& InConsecutiveRegs
; }
88 void setInConsecutiveRegs() { Flags
|= One
<< InConsecutiveRegsOffs
; }
90 bool isInConsecutiveRegsLast() const { return Flags
& InConsecutiveRegsLast
; }
91 void setInConsecutiveRegsLast() { Flags
|= One
<< InConsecutiveRegsLastOffs
; }
93 unsigned getByValAlign() const {
95 ((One
<< ((Flags
& ByValAlign
) >> ByValAlignOffs
)) / 2);
97 void setByValAlign(unsigned A
) {
98 Flags
= (Flags
& ~ByValAlign
) |
99 (uint64_t(Log2_32(A
) + 1) << ByValAlignOffs
);
102 bool isSplit() const { return Flags
& Split
; }
103 void setSplit() { Flags
|= One
<< SplitOffs
; }
105 unsigned getOrigAlign() const {
107 ((One
<< ((Flags
& OrigAlign
) >> OrigAlignOffs
)) / 2);
109 void setOrigAlign(unsigned A
) {
110 Flags
= (Flags
& ~OrigAlign
) |
111 (uint64_t(Log2_32(A
) + 1) << OrigAlignOffs
);
114 unsigned getByValSize() const {
115 return (unsigned)((Flags
& ByValSize
) >> ByValSizeOffs
);
117 void setByValSize(unsigned S
) {
118 Flags
= (Flags
& ~ByValSize
) | (uint64_t(S
) << ByValSizeOffs
);
121 /// getRawBits - Represent the flags as a bunch of bits.
122 uint64_t getRawBits() const { return Flags
; }
125 /// InputArg - This struct carries flags and type information about a
126 /// single incoming (formal) argument or incoming (from the perspective
127 /// of the caller) return value virtual register.
135 /// Index original Function's argument.
136 unsigned OrigArgIndex
;
138 /// Offset in bytes of current input value relative to the beginning of
139 /// original argument. E.g. if argument was splitted into four 32 bit
140 /// registers, we got 4 InputArgs with PartOffsets 0, 4, 8 and 12.
143 InputArg() : VT(MVT::Other
), Used(false) {}
144 InputArg(ArgFlagsTy flags
, EVT vt
, EVT argvt
, bool used
,
145 unsigned origIdx
, unsigned partOffs
)
146 : Flags(flags
), Used(used
), OrigArgIndex(origIdx
), PartOffset(partOffs
) {
147 VT
= vt
.getSimpleVT();
152 /// OutputArg - This struct carries flags and a value for a
153 /// single outgoing (actual) argument or outgoing (from the perspective
154 /// of the caller) return value virtual register.
161 /// IsFixed - Is this a "fixed" value, ie not passed through a vararg "...".
164 /// Index original Function's argument.
165 unsigned OrigArgIndex
;
167 /// Offset in bytes of current output value relative to the beginning of
168 /// original argument. E.g. if argument was splitted into four 32 bit
169 /// registers, we got 4 OutputArgs with PartOffsets 0, 4, 8 and 12.
172 OutputArg() : IsFixed(false) {}
173 OutputArg(ArgFlagsTy flags
, EVT vt
, EVT argvt
, bool isfixed
,
174 unsigned origIdx
, unsigned partOffs
)
175 : Flags(flags
), IsFixed(isfixed
), OrigArgIndex(origIdx
),
176 PartOffset(partOffs
) {
177 VT
= vt
.getSimpleVT();
183 } // end llvm namespace